From 35a588109b2a6d8b610be08d32aaf99ef1549085 Mon Sep 17 00:00:00 2001 From: Filippo Valsorda Date: Sun, 31 Oct 2021 23:22:38 -0400 Subject: [PATCH 001/752] net: accept "." as a valid domain name Fixes #45715 Change-Id: Ibdaa91c97d34473061b377325ebe9a3bf5696c8e Reviewed-on: https://go-review.googlesource.com/c/go/+/360314 Trust: Filippo Valsorda Run-TryBot: Filippo Valsorda TryBot-Result: Go Bot Reviewed-by: Ian Lance Taylor --- src/net/dnsclient.go | 5 +++++ src/net/dnsclient_unix_test.go | 41 ++++++++++++++++++++++++++++++++++ src/net/lookup.go | 4 +--- 3 files changed, 47 insertions(+), 3 deletions(-) diff --git a/src/net/dnsclient.go b/src/net/dnsclient.go index 3c1a12995a..a779c37e53 100644 --- a/src/net/dnsclient.go +++ b/src/net/dnsclient.go @@ -76,6 +76,11 @@ func equalASCIIName(x, y dnsmessage.Name) bool { // (currently restricted to hostname-compatible "preferred name" LDH labels and // SRV-like "underscore labels"; see golang.org/issue/12421). func isDomainName(s string) bool { + // The root domain name is valid. See golang.org/issue/45715. + if s == "." { + return true + } + // See RFC 1035, RFC 3696. // Presentation format has dots before every label except the first, and the // terminal empty label is optional here because we assume fully-qualified diff --git a/src/net/dnsclient_unix_test.go b/src/net/dnsclient_unix_test.go index 1d704d021e..14366eca8c 100644 --- a/src/net/dnsclient_unix_test.go +++ b/src/net/dnsclient_unix_test.go @@ -2120,3 +2120,44 @@ func TestNullMX(t *testing.T) { t.Errorf("records = [%v]; want [%v]", strings.Join(records, " "), want[0]) } } + +func TestRootNS(t *testing.T) { + // See https://golang.org/issue/45715. + fake := fakeDNSServer{ + rh: func(n, _ string, q dnsmessage.Message, _ time.Time) (dnsmessage.Message, error) { + r := dnsmessage.Message{ + Header: dnsmessage.Header{ + ID: q.Header.ID, + Response: true, + RCode: dnsmessage.RCodeSuccess, + }, + Questions: q.Questions, + Answers: []dnsmessage.Resource{ + { + Header: dnsmessage.ResourceHeader{ + Name: q.Questions[0].Name, + Type: dnsmessage.TypeNS, + Class: dnsmessage.ClassINET, + }, + Body: &dnsmessage.NSResource{ + NS: dnsmessage.MustNewName("i.root-servers.net."), + }, + }, + }, + } + return r, nil + }, + } + r := Resolver{PreferGo: true, Dial: fake.DialContext} + rrset, err := r.LookupNS(context.Background(), ".") + if err != nil { + t.Fatalf("LookupNS: %v", err) + } + if want := []*NS{&NS{Host: "i.root-servers.net."}}; !reflect.DeepEqual(rrset, want) { + records := []string{} + for _, rr := range rrset { + records = append(records, fmt.Sprintf("%v", rr)) + } + t.Errorf("records = [%v]; want [%v]", strings.Join(records, " "), want[0]) + } +} diff --git a/src/net/lookup.go b/src/net/lookup.go index e10c71ae75..ff4ddbeb82 100644 --- a/src/net/lookup.go +++ b/src/net/lookup.go @@ -558,9 +558,7 @@ func (r *Resolver) LookupMX(ctx context.Context, name string) ([]*MX, error) { if mx == nil { continue } - // Bypass the hostname validity check for targets which contain only a dot, - // as this is used to represent a 'Null' MX record. - if mx.Host != "." && !isDomainName(mx.Host) { + if !isDomainName(mx.Host) { continue } filteredMX = append(filteredMX, mx) From d3a80c795e9368e9dfac4efb49e3ee041513d24a Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Tue, 2 Nov 2021 20:44:32 +0100 Subject: [PATCH 002/752] net/netip: add Addr.AsSlice() method We have AddrFrom4, AddrFrom6, AddrFromSlice and As4, As6, but we are missing AsSlice, so this commit adds the missing function. It also gets rid of the less ergonomic and inconsistently named IPAddrParts. Updates #49298. Change-Id: I1c6a2c32fc6c69b244ab49765412ffe3bbe7e5c2 Reviewed-on: https://go-review.googlesource.com/c/go/+/360874 Trust: Jason A. Donenfeld Trust: Josh Bleecher Snyder Run-TryBot: Jason A. Donenfeld TryBot-Result: Go Bot Reviewed-by: Brad Fitzpatrick --- src/net/netip/netip.go | 42 +++++++++++++++++------------------------- 1 file changed, 17 insertions(+), 25 deletions(-) diff --git a/src/net/netip/netip.go b/src/net/netip/netip.go index 8cde6ef3d2..9e08be94fc 100644 --- a/src/net/netip/netip.go +++ b/src/net/netip/netip.go @@ -448,31 +448,6 @@ func (ip Addr) Less(ip2 Addr) bool { return ip.Compare(ip2) == -1 } func (ip Addr) lessOrEq(ip2 Addr) bool { return ip.Compare(ip2) <= 0 } -// ipZone returns the standard library net.IP from ip, as well -// as the zone. -// The optional reuse IP provides memory to reuse. -func (ip Addr) ipZone(reuse []byte) (stdIP []byte, zone string) { - base := reuse[:0] - switch { - case ip.z == z0: - return nil, "" - case ip.Is4(): - a4 := ip.As4() - return append(base, a4[:]...), "" - default: - a16 := ip.As16() - return append(base, a16[:]...), ip.Zone() - } -} - -// IPAddrParts returns the net.IPAddr representation of an Addr. -// -// The slice will be nil if ip is the zero Addr. -// The zone is the empty string if there is no zone. -func (ip Addr) IPAddrParts() (slice []byte, zone string) { - return ip.ipZone(nil) -} - // Is4 reports whether ip is an IPv4 address. // // It returns false for IP4-mapped IPv6 addresses. See IP.Unmap. @@ -718,6 +693,23 @@ func (ip Addr) As4() (a4 [4]byte) { panic("As4 called on IPv6 address") } +// AsSlice returns an IPv4 or IPv6 address in its respective 4-byte or 16-byte representation. +func (ip Addr) AsSlice() []byte { + switch ip.z { + case z0: + return nil + case z4: + var ret [4]byte + bePutUint32(ret[:], uint32(ip.addr.lo)) + return ret[:] + default: + var ret [16]byte + bePutUint64(ret[:8], ip.addr.hi) + bePutUint64(ret[8:], ip.addr.lo) + return ret[:] + } +} + // Next returns the address following ip. // If there is none, it returns the zero Addr. func (ip Addr) Next() Addr { From 8f923a4e3c03829874b43291f2bdfd12e2d8189b Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Tue, 2 Nov 2021 21:33:23 +0100 Subject: [PATCH 003/752] net/netip: add missing encoding.BinaryUnmarshaler to AddrPort and Prefix The Addr type got an encoding.BinaryUnmarshaler implementation, but not AddrPort and Prefix. This commit adds the missing implementation of that interface to these types. It also adds two round trip tests that follow the template of the existing one for Addr. Updates #49298. Change-Id: Iac633aed8aac579960815bb64d06ff3181214841 Reviewed-on: https://go-review.googlesource.com/c/go/+/360875 Trust: Jason A. Donenfeld Run-TryBot: Jason A. Donenfeld TryBot-Result: Go Bot Reviewed-by: Brad Fitzpatrick --- src/net/netip/leaf_alts.go | 11 +++++ src/net/netip/netip.go | 54 +++++++++++++++++++++++ src/net/netip/netip_test.go | 88 +++++++++++++++++++++++++++++++++++-- 3 files changed, 150 insertions(+), 3 deletions(-) diff --git a/src/net/netip/leaf_alts.go b/src/net/netip/leaf_alts.go index c51f7dfa54..70513abfd9 100644 --- a/src/net/netip/leaf_alts.go +++ b/src/net/netip/leaf_alts.go @@ -41,3 +41,14 @@ func bePutUint32(b []byte, v uint32) { b[2] = byte(v >> 8) b[3] = byte(v) } + +func leUint16(b []byte) uint16 { + _ = b[1] // bounds check hint to compiler; see golang.org/issue/14808 + return uint16(b[0]) | uint16(b[1])<<8 +} + +func lePutUint16(b []byte, v uint16) { + _ = b[1] // early bounds check to guarantee safety of writes below + b[0] = byte(v) + b[1] = byte(v >> 8) +} diff --git a/src/net/netip/netip.go b/src/net/netip/netip.go index 9e08be94fc..90672e045d 100644 --- a/src/net/netip/netip.go +++ b/src/net/netip/netip.go @@ -1170,6 +1170,34 @@ func (p *AddrPort) UnmarshalText(text []byte) error { return err } +// MarshalBinary implements the encoding.BinaryMarshaler interface. +// It returns Addr.MarshalBinary with an additional two bytes appended +// containing the port in little-endian. +func (p AddrPort) MarshalBinary() ([]byte, error) { + b, err := p.Addr().MarshalBinary() + if err != nil { + return nil, err + } + b = append(b, 0, 0) + lePutUint16(b[len(b)-2:], p.Port()) + return b, nil +} + +// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. +// It expects data in the form generated by MarshalBinary. +func (p *AddrPort) UnmarshalBinary(b []byte) error { + if len(b) < 2 { + return errors.New("unexpected slice size") + } + var addr Addr + err := addr.UnmarshalBinary(b[:len(b)-2]) + if err != nil { + return err + } + *p = AddrPortFrom(addr, leUint16(b[len(b)-2:])) + return nil +} + // Prefix is an IP address prefix (CIDR) representing an IP network. // // The first Bits() of Addr() are specified. The remaining bits match any address. @@ -1401,6 +1429,32 @@ func (p *Prefix) UnmarshalText(text []byte) error { return err } +// MarshalBinary implements the encoding.BinaryMarshaler interface. +// It returns Addr.MarshalBinary with an additional byte appended +// containing the prefix bits. +func (p Prefix) MarshalBinary() ([]byte, error) { + b, err := p.Addr().MarshalBinary() + if err != nil { + return nil, err + } + return append(b, uint8(p.Bits())), nil +} + +// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. +// It expects data in the form generated by MarshalBinary. +func (p *Prefix) UnmarshalBinary(b []byte) error { + if len(b) < 1 { + return errors.New("unexpected slice size") + } + var addr Addr + err := addr.UnmarshalBinary(b[:len(b)-1]) + if err != nil { + return err + } + *p = PrefixFrom(addr, int(b[len(b)-1])) + return nil +} + // String returns the CIDR notation of p: "/". func (p Prefix) String() string { if !p.IsValid() { diff --git a/src/net/netip/netip_test.go b/src/net/netip/netip_test.go index c39b1ec201..63af853cb3 100644 --- a/src/net/netip/netip_test.go +++ b/src/net/netip/netip_test.go @@ -25,6 +25,7 @@ type uint128 = Uint128 var ( mustPrefix = MustParsePrefix mustIP = MustParseAddr + mustIPPort = MustParseAddrPort ) func TestParseAddr(t *testing.T) { @@ -332,10 +333,91 @@ func TestAddrMarshalUnmarshalBinary(t *testing.T) { } // Cannot unmarshal from unexpected IP length. - for _, l := range []int{3, 5} { + for _, n := range []int{3, 5} { var ip2 Addr - if err := ip2.UnmarshalBinary(bytes.Repeat([]byte{1}, l)); err == nil { - t.Fatalf("unmarshaled from unexpected IP length %d", l) + if err := ip2.UnmarshalBinary(bytes.Repeat([]byte{1}, n)); err == nil { + t.Fatalf("unmarshaled from unexpected IP length %d", n) + } + } +} + +func TestAddrPortMarshalUnmarshalBinary(t *testing.T) { + tests := []struct { + ipport string + wantSize int + }{ + {"1.2.3.4:51820", 4 + 2}, + {"[fd7a:115c:a1e0:ab12:4843:cd96:626b:430b]:80", 16 + 2}, + {"[::ffff:c000:0280]:65535", 16 + 2}, + {"[::ffff:c000:0280%eth0]:1", 20 + 2}, + } + for _, tc := range tests { + var ipport AddrPort + if len(tc.ipport) > 0 { + ipport = mustIPPort(tc.ipport) + } + b, err := ipport.MarshalBinary() + if err != nil { + t.Fatal(err) + } + if len(b) != tc.wantSize { + t.Fatalf("%q encoded to size %d; want %d", tc.ipport, len(b), tc.wantSize) + } + var ipport2 AddrPort + if err := ipport2.UnmarshalBinary(b); err != nil { + t.Fatal(err) + } + if ipport != ipport2 { + t.Fatalf("got %v; want %v", ipport2, ipport) + } + } + + // Cannot unmarshal from unexpected lengths. + for _, n := range []int{3, 7} { + var ipport2 AddrPort + if err := ipport2.UnmarshalBinary(bytes.Repeat([]byte{1}, n)); err == nil { + t.Fatalf("unmarshaled from unexpected length %d", n) + } + } +} + +func TestPrefixMarshalUnmarshalBinary(t *testing.T) { + type testCase struct { + prefix Prefix + wantSize int + } + tests := []testCase{ + {mustPrefix("1.2.3.4/24"), 4 + 1}, + {mustPrefix("fd7a:115c:a1e0:ab12:4843:cd96:626b:430b/118"), 16 + 1}, + {mustPrefix("::ffff:c000:0280/96"), 16 + 1}, + {mustPrefix("::ffff:c000:0280%eth0/37"), 16 + 1}, // Zone should be stripped + } + tests = append(tests, + testCase{PrefixFrom(tests[0].prefix.Addr(), 33), tests[0].wantSize}, + testCase{PrefixFrom(tests[1].prefix.Addr(), 129), tests[1].wantSize}) + for _, tc := range tests { + prefix := tc.prefix + b, err := prefix.MarshalBinary() + if err != nil { + t.Fatal(err) + } + if len(b) != tc.wantSize { + t.Fatalf("%q encoded to size %d; want %d", tc.prefix, len(b), tc.wantSize) + } + var prefix2 Prefix + if err := prefix2.UnmarshalBinary(b); err != nil { + t.Fatal(err) + } + if prefix != prefix2 { + t.Fatalf("got %v; want %v", prefix2, prefix) + } + } + + // Cannot unmarshal from unexpected lengths. + for _, n := range []int{3, 6} { + var prefix2 Prefix + if err := prefix2.UnmarshalBinary(bytes.Repeat([]byte{1}, n)); err == nil { + t.Fatalf("unmarshaled from unexpected length %d", n) } } } From feb024f4153395e5bbb2a51bb3d1ddc4f5b0d2dc Mon Sep 17 00:00:00 2001 From: Roland Shoemaker Date: Wed, 29 Sep 2021 11:31:01 -0700 Subject: [PATCH 004/752] crypto/x509: use platform verifier on darwin When VerifyOptions.Roots is nil, default to using the platform X.509 certificate verification APIs on darwin, rather than using the Go verifier. Since our oldest supported version of macOS is 10.12, we are able to use the modern verification APIs, and don't need to resort to the complex chain building trickery employed by chromium et al. Unfortunately there is not a clean way to programmatically add test roots to the system trust store that the builders would tolerate. The most obvious solution, using 'security add-trusted-cert' requires human interaction for authorization. We could also manually add anchors to the constructed SecTrustRef, but that would require adding a whole bunch of plumbing for test functionality, and would mean we weren't really testing the actual non-test path. The path I've chosen here is to just utilize existing valid, and purposefully invalid, trusted chains, from google.com and the badssl.com test suite. This requires external network access, but most accurately reflects real world contexts. This change removes the x509.SystemCertPool() functionality, which will be ammended in a follow-up change which supports the suggested hybrid pool approach described in #46287. Updates #46287 Fixes #42414 Fixes #38888 Fixes #35631 Fixes #19561 Change-Id: I17f0d6c5cb3ef8a1f2731ce3296478b28d30df46 Reviewed-on: https://go-review.googlesource.com/c/go/+/353132 Trust: Roland Shoemaker Run-TryBot: Roland Shoemaker Reviewed-by: Filippo Valsorda TryBot-Result: Go Bot --- src/crypto/x509/cert_pool.go | 2 + .../x509/internal/macos/corefoundation.go | 77 +++++ .../x509/internal/macos/corefoundation.s | 12 + src/crypto/x509/internal/macos/security.go | 118 ++++++++ src/crypto/x509/internal/macos/security.s | 18 ++ src/crypto/x509/root_darwin.go | 270 +++++------------- src/crypto/x509/root_darwin_test.go | 129 +++++++-- src/crypto/x509/verify.go | 4 +- src/crypto/x509/verify_test.go | 4 +- src/crypto/x509/x509_test.go | 4 +- 10 files changed, 411 insertions(+), 227 deletions(-) diff --git a/src/crypto/x509/cert_pool.go b/src/crypto/x509/cert_pool.go index bcc5db3b70..1886825b17 100644 --- a/src/crypto/x509/cert_pool.go +++ b/src/crypto/x509/cert_pool.go @@ -106,6 +106,8 @@ func SystemCertPool() (*CertPool, error) { if runtime.GOOS == "windows" { // Issue 16736, 18609: return nil, errors.New("crypto/x509: system root pool is not available on Windows") + } else if runtime.GOOS == "darwin" { + return nil, errors.New("crypto/x509: system root pool is not available on macOS") } if sysRoots := systemRootsPool(); sysRoots != nil { diff --git a/src/crypto/x509/internal/macos/corefoundation.go b/src/crypto/x509/internal/macos/corefoundation.go index a91131ac98..07db5c7527 100644 --- a/src/crypto/x509/internal/macos/corefoundation.go +++ b/src/crypto/x509/internal/macos/corefoundation.go @@ -14,6 +14,7 @@ import ( "internal/abi" "reflect" "runtime" + "time" "unsafe" ) @@ -35,11 +36,37 @@ func CFDataToSlice(data CFRef) []byte { return out } +// CFStringToString returns a Go string representation of the passed +// in CFString. +func CFStringToString(ref CFRef) string { + data := CFStringCreateExternalRepresentation(ref) + b := CFDataToSlice(data) + CFRelease(data) + return string(b) +} + +// TimeToCFDateRef converts a time.Time into an apple CFDateRef +func TimeToCFDateRef(t time.Time) CFRef { + secs := t.Sub(time.Date(2001, 1, 1, 0, 0, 0, 0, time.UTC)).Seconds() + ref := CFDateCreate(int(secs)) + return ref +} + type CFString CFRef const kCFAllocatorDefault = 0 const kCFStringEncodingUTF8 = 0x08000100 +//go:cgo_import_dynamic x509_CFDataCreate CFDataCreate "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation" + +func BytesToCFData(b []byte) CFRef { + p := unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(&b)).Data) + ret := syscall(abi.FuncPCABI0(x509_CFDataCreate_trampoline), kCFAllocatorDefault, uintptr(p), uintptr(len(b)), 0, 0, 0) + runtime.KeepAlive(p) + return CFRef(ret) +} +func x509_CFDataCreate_trampoline() + //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. @@ -126,5 +153,55 @@ func CFRelease(ref CFRef) { } func x509_CFRelease_trampoline() +//go:cgo_import_dynamic x509_CFArrayCreateMutable CFArrayCreateMutable "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation" + +func CFArrayCreateMutable() CFRef { + ret := syscall(abi.FuncPCABI0(x509_CFArrayCreateMutable_trampoline), kCFAllocatorDefault, 0, 0 /* kCFTypeArrayCallBacks */, 0, 0, 0) + return CFRef(ret) +} +func x509_CFArrayCreateMutable_trampoline() + +//go:cgo_import_dynamic x509_CFArrayAppendValue CFArrayAppendValue "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation" + +func CFArrayAppendValue(array CFRef, val CFRef) { + syscall(abi.FuncPCABI0(x509_CFArrayAppendValue_trampoline), uintptr(array), uintptr(val), 0, 0, 0, 0) +} +func x509_CFArrayAppendValue_trampoline() + +//go:cgo_import_dynamic x509_CFDateCreate CFDateCreate "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation" + +func CFDateCreate(seconds int) CFRef { + ret := syscall(abi.FuncPCABI0(x509_CFDateCreate_trampoline), kCFAllocatorDefault, uintptr(seconds), 0, 0, 0, 0) + return CFRef(ret) +} +func x509_CFDateCreate_trampoline() + +//go:cgo_import_dynamic x509_CFErrorCopyDescription CFErrorCopyDescription "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation" + +func CFErrorCopyDescription(errRef CFRef) CFRef { + ret := syscall(abi.FuncPCABI0(x509_CFErrorCopyDescription_trampoline), uintptr(errRef), 0, 0, 0, 0, 0) + return CFRef(ret) +} +func x509_CFErrorCopyDescription_trampoline() + +//go:cgo_import_dynamic x509_CFStringCreateExternalRepresentation CFStringCreateExternalRepresentation "/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation" + +func CFStringCreateExternalRepresentation(strRef CFRef) CFRef { + ret := syscall(abi.FuncPCABI0(x509_CFStringCreateExternalRepresentation_trampoline), kCFAllocatorDefault, uintptr(strRef), kCFStringEncodingUTF8, 0, 0, 0) + return CFRef(ret) +} +func x509_CFStringCreateExternalRepresentation_trampoline() + // syscall is implemented in the runtime package (runtime/sys_darwin.go) func syscall(fn, a1, a2, a3, a4, a5, a6 uintptr) uintptr + +// ReleaseCFArray iterates through an array, releasing its contents, and then +// releases the array itself. This is necessary because we cannot, easily, set the +// CFArrayCallBacks argument when creating CFArrays. +func ReleaseCFArray(array CFRef) { + for i := 0; i < CFArrayGetCount(array); i++ { + ref := CFArrayGetValueAtIndex(array, i) + CFRelease(ref) + } + CFRelease(array) +} diff --git a/src/crypto/x509/internal/macos/corefoundation.s b/src/crypto/x509/internal/macos/corefoundation.s index cda2336c9d..376099caa3 100644 --- a/src/crypto/x509/internal/macos/corefoundation.s +++ b/src/crypto/x509/internal/macos/corefoundation.s @@ -28,3 +28,15 @@ TEXT ·x509_CFNumberGetValue_trampoline(SB),NOSPLIT,$0-0 JMP x509_CFNumberGetValue(SB) TEXT ·x509_CFEqual_trampoline(SB),NOSPLIT,$0-0 JMP x509_CFEqual(SB) +TEXT ·x509_CFArrayCreateMutable_trampoline(SB),NOSPLIT,$0-0 + JMP x509_CFArrayCreateMutable(SB) +TEXT ·x509_CFArrayAppendValue_trampoline(SB),NOSPLIT,$0-0 + JMP x509_CFArrayAppendValue(SB) +TEXT ·x509_CFDateCreate_trampoline(SB),NOSPLIT,$0-0 + JMP x509_CFDateCreate(SB) +TEXT ·x509_CFDataCreate_trampoline(SB),NOSPLIT,$0-0 + JMP x509_CFDataCreate(SB) +TEXT ·x509_CFErrorCopyDescription_trampoline(SB),NOSPLIT,$0-0 + JMP x509_CFErrorCopyDescription(SB) +TEXT ·x509_CFStringCreateExternalRepresentation_trampoline(SB),NOSPLIT,$0-0 + JMP x509_CFStringCreateExternalRepresentation(SB) diff --git a/src/crypto/x509/internal/macos/security.go b/src/crypto/x509/internal/macos/security.go index a560248e8b..2805076ccd 100644 --- a/src/crypto/x509/internal/macos/security.go +++ b/src/crypto/x509/internal/macos/security.go @@ -8,6 +8,7 @@ package macOS import ( "errors" + "fmt" "internal/abi" "strconv" "unsafe" @@ -29,6 +30,19 @@ const ( SecTrustSettingsResultUnspecified ) +type SecTrustResultType int32 + +const ( + SecTrustResultInvalid SecTrustResultType = iota + SecTrustResultProceed + SecTrustResultConfirm // deprecated + SecTrustResultDeny + SecTrustResultUnspecified + SecTrustResultRecoverableTrustFailure + SecTrustResultFatalTrustFailure + SecTrustResultOtherError +) + type SecTrustSettingsDomain int32 const ( @@ -115,3 +129,107 @@ func SecPolicyCopyProperties(policy CFRef) CFRef { return CFRef(ret) } func x509_SecPolicyCopyProperties_trampoline() + +//go:cgo_import_dynamic x509_SecTrustCreateWithCertificates SecTrustCreateWithCertificates "/System/Library/Frameworks/Security.framework/Versions/A/Security" + +func SecTrustCreateWithCertificates(certs CFRef, policies CFRef) (CFRef, error) { + var trustObj CFRef + ret := syscall(abi.FuncPCABI0(x509_SecTrustCreateWithCertificates_trampoline), uintptr(certs), uintptr(policies), + uintptr(unsafe.Pointer(&trustObj)), 0, 0, 0) + if int32(ret) != 0 { + return 0, OSStatus{"SecTrustCreateWithCertificates", int32(ret)} + } + return trustObj, nil +} +func x509_SecTrustCreateWithCertificates_trampoline() + +//go:cgo_import_dynamic x509_SecCertificateCreateWithData SecCertificateCreateWithData "/System/Library/Frameworks/Security.framework/Versions/A/Security" + +func SecCertificateCreateWithData(b []byte) CFRef { + data := BytesToCFData(b) + ret := syscall(abi.FuncPCABI0(x509_SecCertificateCreateWithData_trampoline), kCFAllocatorDefault, uintptr(data), 0, 0, 0, 0) + CFRelease(data) + return CFRef(ret) +} +func x509_SecCertificateCreateWithData_trampoline() + +//go:cgo_import_dynamic x509_SecPolicyCreateSSL SecPolicyCreateSSL "/System/Library/Frameworks/Security.framework/Versions/A/Security" + +func SecPolicyCreateSSL(name string) CFRef { + var hostname CFString + if name != "" { + hostname = StringToCFString(name) + defer CFRelease(CFRef(hostname)) + } + ret := syscall(abi.FuncPCABI0(x509_SecPolicyCreateSSL_trampoline), 1 /* true */, uintptr(hostname), 0, 0, 0, 0) + return CFRef(ret) +} +func x509_SecPolicyCreateSSL_trampoline() + +//go:cgo_import_dynamic x509_SecTrustSetVerifyDate SecTrustSetVerifyDate "/System/Library/Frameworks/Security.framework/Versions/A/Security" + +func SecTrustSetVerifyDate(trustObj CFRef, dateRef CFRef) error { + ret := syscall(abi.FuncPCABI0(x509_SecTrustSetVerifyDate_trampoline), uintptr(trustObj), uintptr(dateRef), 0, 0, 0, 0) + if int32(ret) != 0 { + return OSStatus{"SecTrustSetVerifyDate", int32(ret)} + } + return nil +} +func x509_SecTrustSetVerifyDate_trampoline() + +//go:cgo_import_dynamic x509_SecTrustEvaluate SecTrustEvaluate "/System/Library/Frameworks/Security.framework/Versions/A/Security" + +func SecTrustEvaluate(trustObj CFRef) (CFRef, error) { + var result CFRef + ret := syscall(abi.FuncPCABI0(x509_SecTrustEvaluate_trampoline), uintptr(trustObj), uintptr(unsafe.Pointer(&result)), 0, 0, 0, 0) + if int32(ret) != 0 { + return 0, OSStatus{"SecTrustEvaluate", int32(ret)} + } + return CFRef(result), nil +} +func x509_SecTrustEvaluate_trampoline() + +//go:cgo_import_dynamic x509_SecTrustGetResult SecTrustGetResult "/System/Library/Frameworks/Security.framework/Versions/A/Security" + +func SecTrustGetResult(trustObj CFRef, result CFRef) (CFRef, CFRef, error) { + var chain, info CFRef + ret := syscall(abi.FuncPCABI0(x509_SecTrustGetResult_trampoline), uintptr(trustObj), uintptr(unsafe.Pointer(&result)), + uintptr(unsafe.Pointer(&chain)), uintptr(unsafe.Pointer(&info)), 0, 0) + if int32(ret) != 0 { + return 0, 0, OSStatus{"SecTrustGetResult", int32(ret)} + } + return chain, info, nil +} +func x509_SecTrustGetResult_trampoline() + +//go:cgo_import_dynamic x509_SecTrustEvaluateWithError SecTrustEvaluateWithError "/System/Library/Frameworks/Security.framework/Versions/A/Security" + +func SecTrustEvaluateWithError(trustObj CFRef) error { + var errRef CFRef + ret := syscall(abi.FuncPCABI0(x509_SecTrustEvaluateWithError_trampoline), uintptr(trustObj), uintptr(unsafe.Pointer(&errRef)), 0, 0, 0, 0) + if int32(ret) != 1 { + errStr := CFErrorCopyDescription(errRef) + err := fmt.Errorf("x509: %s", CFStringToString(errStr)) + CFRelease(errRef) + CFRelease(errStr) + return err + } + return nil +} +func x509_SecTrustEvaluateWithError_trampoline() + +//go:cgo_import_dynamic x509_SecTrustGetCertificateCount SecTrustGetCertificateCount "/System/Library/Frameworks/Security.framework/Versions/A/Security" + +func SecTrustGetCertificateCount(trustObj CFRef) int { + ret := syscall(abi.FuncPCABI0(x509_SecTrustGetCertificateCount_trampoline), uintptr(trustObj), 0, 0, 0, 0, 0) + return int(ret) +} +func x509_SecTrustGetCertificateCount_trampoline() + +//go:cgo_import_dynamic x509_SecTrustGetCertificateAtIndex SecTrustGetCertificateAtIndex "/System/Library/Frameworks/Security.framework/Versions/A/Security" + +func SecTrustGetCertificateAtIndex(trustObj CFRef, i int) CFRef { + ret := syscall(abi.FuncPCABI0(x509_SecTrustGetCertificateAtIndex_trampoline), uintptr(trustObj), uintptr(i), 0, 0, 0, 0) + return CFRef(ret) +} +func x509_SecTrustGetCertificateAtIndex_trampoline() diff --git a/src/crypto/x509/internal/macos/security.s b/src/crypto/x509/internal/macos/security.s index 0038f25b27..9c1c133489 100644 --- a/src/crypto/x509/internal/macos/security.s +++ b/src/crypto/x509/internal/macos/security.s @@ -18,3 +18,21 @@ TEXT ·x509_SecTrustSettingsCopyTrustSettings_trampoline(SB),NOSPLIT,$0-0 JMP x509_SecTrustSettingsCopyTrustSettings(SB) TEXT ·x509_SecPolicyCopyProperties_trampoline(SB),NOSPLIT,$0-0 JMP x509_SecPolicyCopyProperties(SB) +TEXT ·x509_SecTrustCreateWithCertificates_trampoline(SB),NOSPLIT,$0-0 + JMP x509_SecTrustCreateWithCertificates(SB) +TEXT ·x509_SecCertificateCreateWithData_trampoline(SB),NOSPLIT,$0-0 + JMP x509_SecCertificateCreateWithData(SB) +TEXT ·x509_SecPolicyCreateSSL_trampoline(SB),NOSPLIT,$0-0 + JMP x509_SecPolicyCreateSSL(SB) +TEXT ·x509_SecTrustSetVerifyDate_trampoline(SB),NOSPLIT,$0-0 + JMP x509_SecTrustSetVerifyDate(SB) +TEXT ·x509_SecTrustEvaluate_trampoline(SB),NOSPLIT,$0-0 + JMP x509_SecTrustEvaluate(SB) +TEXT ·x509_SecTrustGetResult_trampoline(SB),NOSPLIT,$0-0 + JMP x509_SecTrustGetResult(SB) +TEXT ·x509_SecTrustEvaluateWithError_trampoline(SB),NOSPLIT,$0-0 + JMP x509_SecTrustEvaluateWithError(SB) +TEXT ·x509_SecTrustGetCertificateCount_trampoline(SB),NOSPLIT,$0-0 + JMP x509_SecTrustGetCertificateCount(SB) +TEXT ·x509_SecTrustGetCertificateAtIndex_trampoline(SB),NOSPLIT,$0-0 + JMP x509_SecTrustGetCertificateAtIndex(SB) diff --git a/src/crypto/x509/root_darwin.go b/src/crypto/x509/root_darwin.go index ef051efd31..eab046120f 100644 --- a/src/crypto/x509/root_darwin.go +++ b/src/crypto/x509/root_darwin.go @@ -7,109 +7,93 @@ package x509 import ( - "bytes" macOS "crypto/x509/internal/macos" - "fmt" - "internal/godebug" - "os" + "errors" ) -var debugDarwinRoots = godebug.Get("x509roots") == "1" - func (c *Certificate) systemVerify(opts *VerifyOptions) (chains [][]*Certificate, err error) { - return nil, nil -} + certs := macOS.CFArrayCreateMutable() + defer macOS.ReleaseCFArray(certs) + leaf := macOS.SecCertificateCreateWithData(c.Raw) + macOS.CFArrayAppendValue(certs, leaf) + if opts.Intermediates != nil { + for _, lc := range opts.Intermediates.lazyCerts { + c, err := lc.getCert() + if err != nil { + return nil, err + } + sc := macOS.SecCertificateCreateWithData(c.Raw) + macOS.CFArrayAppendValue(certs, sc) + } + } -func loadSystemRoots() (*CertPool, error) { - var trustedRoots []*Certificate - untrustedRoots := make(map[string]bool) + policies := macOS.CFArrayCreateMutable() + defer macOS.ReleaseCFArray(policies) + sslPolicy := macOS.SecPolicyCreateSSL(opts.DNSName) + macOS.CFArrayAppendValue(policies, sslPolicy) - // macOS has three trust domains: one for CAs added by users to their - // "login" keychain, one for CAs added by Admins to the "System" keychain, - // and one for the CAs that ship with the OS. - for _, domain := range []macOS.SecTrustSettingsDomain{ - macOS.SecTrustSettingsDomainUser, - macOS.SecTrustSettingsDomainAdmin, - macOS.SecTrustSettingsDomainSystem, - } { - certs, err := macOS.SecTrustSettingsCopyCertificates(domain) - if err == macOS.ErrNoTrustSettings { - continue - } else if err != nil { + trustObj, err := macOS.SecTrustCreateWithCertificates(certs, policies) + if err != nil { + return nil, err + } + defer macOS.CFRelease(trustObj) + + if !opts.CurrentTime.IsZero() { + dateRef := macOS.TimeToCFDateRef(opts.CurrentTime) + defer macOS.CFRelease(dateRef) + if err := macOS.SecTrustSetVerifyDate(trustObj, dateRef); err != nil { return nil, err } - defer macOS.CFRelease(certs) + } - for i := 0; i < macOS.CFArrayGetCount(certs); i++ { - c := macOS.CFArrayGetValueAtIndex(certs, i) - cert, err := exportCertificate(c) - if err != nil { - if debugDarwinRoots { - fmt.Fprintf(os.Stderr, "crypto/x509: domain %d, certificate #%d: %v\n", domain, i, err) - } - continue - } + // TODO(roland): we may want to allow passing in SCTs via VerifyOptions and + // set them via SecTrustSetSignedCertificateTimestamps, since Apple will + // always enforce its SCT requirements, and there are still _some_ people + // using TLS or OCSP for that. - var result macOS.SecTrustSettingsResult - if domain == macOS.SecTrustSettingsDomainSystem { - // Certs found in the system domain are always trusted. If the user - // configures "Never Trust" on such a cert, it will also be found in the - // admin or user domain, causing it to be added to untrustedRoots. - result = macOS.SecTrustSettingsResultTrustRoot - } else { - result, err = sslTrustSettingsResult(c) - if err != nil { - if debugDarwinRoots { - fmt.Fprintf(os.Stderr, "crypto/x509: trust settings for %v: %v\n", cert.Subject, err) - } - continue - } - if debugDarwinRoots { - fmt.Fprintf(os.Stderr, "crypto/x509: trust settings for %v: %d\n", cert.Subject, result) - } - } + if err := macOS.SecTrustEvaluateWithError(trustObj); err != nil { + return nil, err + } - switch result { - // "Note the distinction between the results kSecTrustSettingsResultTrustRoot - // and kSecTrustSettingsResultTrustAsRoot: The former can only be applied to - // root (self-signed) certificates; the latter can only be applied to - // non-root certificates." - case macOS.SecTrustSettingsResultTrustRoot: - if isRootCertificate(cert) { - trustedRoots = append(trustedRoots, cert) - } - case macOS.SecTrustSettingsResultTrustAsRoot: - if !isRootCertificate(cert) { - trustedRoots = append(trustedRoots, cert) - } + chain := [][]*Certificate{{}} + numCerts := macOS.SecTrustGetCertificateCount(trustObj) + for i := 0; i < numCerts; i++ { + certRef := macOS.SecTrustGetCertificateAtIndex(trustObj, i) + cert, err := exportCertificate(certRef) + if err != nil { + return nil, err + } + chain[0] = append(chain[0], cert) + } + if len(chain[0]) == 0 { + // This should _never_ happen, but to be safe + return nil, errors.New("x509: macOS certificate verification internal error") + } - case macOS.SecTrustSettingsResultDeny: - // Add this certificate to untrustedRoots, which are subtracted - // from trustedRoots, so that we don't have to evaluate policies - // for every root in the system domain, but still apply user and - // admin policies that override system roots. - untrustedRoots[string(cert.Raw)] = true - - case macOS.SecTrustSettingsResultUnspecified: - // Certificates with unspecified trust should be added to a pool - // of intermediates for chain building, but we don't support it - // at the moment. This is Issue 35631. - - default: - if debugDarwinRoots { - fmt.Fprintf(os.Stderr, "crypto/x509: unknown trust setting for %v: %d\n", cert.Subject, result) - } - } + if opts.DNSName != "" { + // If we have a DNS name, apply our own name verification + if err := chain[0][0].VerifyHostname(opts.DNSName); err != nil { + return nil, err } } - pool := NewCertPool() - for _, cert := range trustedRoots { - if !untrustedRoots[string(cert.Raw)] { - pool.AddCert(cert) + keyUsages := opts.KeyUsages + if len(keyUsages) == 0 { + keyUsages = []ExtKeyUsage{ExtKeyUsageServerAuth} + } + + // If any key usage is acceptable then we're done. + for _, usage := range keyUsages { + if usage == ExtKeyUsageAny { + return chain, nil } } - return pool, nil + + if !checkChainForKeyUsage(chain[0], keyUsages) { + return nil, CertificateInvalidError{c, IncompatibleUsage, ""} + } + + return chain, nil } // exportCertificate returns a *Certificate for a SecCertificateRef. @@ -124,116 +108,6 @@ func exportCertificate(cert macOS.CFRef) (*Certificate, error) { return ParseCertificate(der) } -// isRootCertificate reports whether Subject and Issuer match. -func isRootCertificate(cert *Certificate) bool { - return bytes.Equal(cert.RawSubject, cert.RawIssuer) -} - -// sslTrustSettingsResult obtains the final kSecTrustSettingsResult value for a -// certificate in the user or admin domain, combining usage constraints for the -// SSL SecTrustSettingsPolicy, -// -// It ignores SecTrustSettingsKeyUsage and kSecTrustSettingsAllowedError, and -// doesn't support kSecTrustSettingsDefaultRootCertSetting. -// -// https://developer.apple.com/documentation/security/1400261-sectrustsettingscopytrustsetting -func sslTrustSettingsResult(cert macOS.CFRef) (macOS.SecTrustSettingsResult, error) { - // In Apple's implementation user trust settings override admin trust settings - // (which themselves override system trust settings). If SecTrustSettingsCopyTrustSettings - // fails, or returns a NULL trust settings, when looking for the user trust - // settings then fallback to checking the admin trust settings. - // - // See Security-59306.41.2/trust/headers/SecTrustSettings.h for a description of - // the trust settings overrides, and SecLegacyAnchorSourceCopyUsageConstraints in - // Security-59306.41.2/trust/trustd/SecCertificateSource.c for a concrete example - // of how Apple applies the override in the case of NULL trust settings, or non - // success errors. - trustSettings, err := macOS.SecTrustSettingsCopyTrustSettings(cert, macOS.SecTrustSettingsDomainUser) - if err != nil || trustSettings == 0 { - if debugDarwinRoots && err != macOS.ErrNoTrustSettings { - fmt.Fprintf(os.Stderr, "crypto/x509: SecTrustSettingsCopyTrustSettings for SecTrustSettingsDomainUser failed: %s\n", err) - } - trustSettings, err = macOS.SecTrustSettingsCopyTrustSettings(cert, macOS.SecTrustSettingsDomainAdmin) - } - if err != nil || trustSettings == 0 { - // If there are neither user nor admin trust settings for a certificate returned - // from SecTrustSettingsCopyCertificates Apple returns kSecTrustSettingsResultInvalid, - // as this method is intended to return certificates _which have trust settings_. - // The most likely case for this being triggered is that the existing trust settings - // are invalid and cannot be properly parsed. In this case SecTrustSettingsCopyTrustSettings - // returns errSecInvalidTrustSettings. The existing cgo implementation returns - // kSecTrustSettingsResultUnspecified in this case, which mostly matches the Apple - // implementation because we don't do anything with certificates marked with this - // result. - // - // See SecPVCGetTrustSettingsResult in Security-59306.41.2/trust/trustd/SecPolicyServer.c - if debugDarwinRoots && err != macOS.ErrNoTrustSettings { - fmt.Fprintf(os.Stderr, "crypto/x509: SecTrustSettingsCopyTrustSettings for SecTrustSettingsDomainAdmin failed: %s\n", err) - } - return macOS.SecTrustSettingsResultUnspecified, nil - } - defer macOS.CFRelease(trustSettings) - - // "An empty trust settings array means 'always trust this certificate' with an - // overall trust setting for the certificate of kSecTrustSettingsResultTrustRoot." - if macOS.CFArrayGetCount(trustSettings) == 0 { - return macOS.SecTrustSettingsResultTrustRoot, nil - } - - isSSLPolicy := func(policyRef macOS.CFRef) bool { - properties := macOS.SecPolicyCopyProperties(policyRef) - defer macOS.CFRelease(properties) - if v, ok := macOS.CFDictionaryGetValueIfPresent(properties, macOS.SecPolicyOid); ok { - return macOS.CFEqual(v, macOS.CFRef(macOS.SecPolicyAppleSSL)) - } - return false - } - - for i := 0; i < macOS.CFArrayGetCount(trustSettings); i++ { - tSetting := macOS.CFArrayGetValueAtIndex(trustSettings, i) - - // First, check if this trust setting is constrained to a non-SSL policy. - if policyRef, ok := macOS.CFDictionaryGetValueIfPresent(tSetting, macOS.SecTrustSettingsPolicy); ok { - if !isSSLPolicy(policyRef) { - continue - } - } - - // Then check if it is restricted to a hostname, so not a root. - if _, ok := macOS.CFDictionaryGetValueIfPresent(tSetting, macOS.SecTrustSettingsPolicyString); ok { - continue - } - - cfNum, ok := macOS.CFDictionaryGetValueIfPresent(tSetting, macOS.SecTrustSettingsResultKey) - // "If this key is not present, a default value of kSecTrustSettingsResultTrustRoot is assumed." - if !ok { - return macOS.SecTrustSettingsResultTrustRoot, nil - } - result, err := macOS.CFNumberGetValue(cfNum) - if err != nil { - return 0, err - } - - // If multiple dictionaries match, we are supposed to "OR" them, - // the semantics of which are not clear. Since TrustRoot and TrustAsRoot - // are mutually exclusive, Deny should probably override, and Invalid and - // Unspecified be overridden, approximate this by stopping at the first - // TrustRoot, TrustAsRoot or Deny. - switch r := macOS.SecTrustSettingsResult(result); r { - case macOS.SecTrustSettingsResultTrustRoot, - macOS.SecTrustSettingsResultTrustAsRoot, - macOS.SecTrustSettingsResultDeny: - return r, nil - } - } - - // If trust settings are present, but none of them match the policy... - // the docs don't tell us what to do. - // - // "Trust settings for a given use apply if any of the dictionaries in the - // certificate’s trust settings array satisfies the specified use." suggests - // that it's as if there were no trust settings at all, so we should maybe - // fallback to the admin trust settings? TODO(golang.org/issue/38888). - - return macOS.SecTrustSettingsResultUnspecified, nil +func loadSystemRoots() (*CertPool, error) { + return nil, nil } diff --git a/src/crypto/x509/root_darwin_test.go b/src/crypto/x509/root_darwin_test.go index ae2bd02bf8..90a464f624 100644 --- a/src/crypto/x509/root_darwin_test.go +++ b/src/crypto/x509/root_darwin_test.go @@ -2,38 +2,121 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -package x509 +package x509_test import ( - "os" - "os/exec" + "crypto/tls" + "crypto/x509" + "internal/testenv" "testing" "time" ) -func TestSystemRoots(t *testing.T) { - t0 := time.Now() - sysRoots, err := loadSystemRoots() // actual system roots - sysRootsDuration := time.Since(t0) - - if err != nil { - t.Fatalf("failed to read system roots: %v", err) +func TestPlatformVerifier(t *testing.T) { + if !testenv.HasExternalNetwork() { + t.Skip() } - t.Logf("loadSystemRoots: %v", sysRootsDuration) - - // There are 174 system roots on Catalina, and 163 on iOS right now, require - // at least 100 to make sure this is not completely broken. - if want, have := 100, sysRoots.len(); have < want { - t.Errorf("want at least %d system roots, have %d", want, have) + getChain := func(host string) []*x509.Certificate { + t.Helper() + c, err := tls.Dial("tcp", host+":443", &tls.Config{InsecureSkipVerify: true}) + if err != nil { + t.Fatalf("tls connection failed: %s", err) + } + return c.ConnectionState().PeerCertificates } - if t.Failed() { - cmd := exec.Command("security", "dump-trust-settings") - cmd.Stdout, cmd.Stderr = os.Stderr, os.Stderr - cmd.Run() - cmd = exec.Command("security", "dump-trust-settings", "-d") - cmd.Stdout, cmd.Stderr = os.Stderr, os.Stderr - cmd.Run() + tests := []struct { + name string + host string + verifyName string + verifyTime time.Time + verifyEKU []x509.ExtKeyUsage + expectedErr string + }{ + { + // whatever google.com serves should, hopefully, be trusted + name: "valid chain", + host: "google.com", + }, + { + name: "expired leaf", + host: "expired.badssl.com", + expectedErr: "x509: “*.badssl.com” certificate is expired", + }, + { + name: "wrong host for leaf", + host: "wrong.host.badssl.com", + verifyName: "wrong.host.badssl.com", + expectedErr: "x509: “*.badssl.com” certificate name does not match input", + }, + { + name: "self-signed leaf", + host: "self-signed.badssl.com", + expectedErr: "x509: “*.badssl.com” certificate is not trusted", + }, + { + name: "untrusted root", + host: "untrusted-root.badssl.com", + expectedErr: "x509: “BadSSL Untrusted Root Certificate Authority” certificate is not trusted", + }, + { + name: "revoked leaf", + host: "revoked.badssl.com", + expectedErr: "x509: “revoked.badssl.com” certificate is revoked", + }, + { + name: "leaf missing SCTs", + host: "no-sct.badssl.com", + expectedErr: "x509: “no-sct.badssl.com” certificate is not standards compliant", + }, + { + name: "expired leaf (custom time)", + host: "google.com", + verifyTime: time.Time{}.Add(time.Hour), + expectedErr: "x509: “*.google.com” certificate is expired", + }, + { + name: "valid chain (custom time)", + host: "google.com", + verifyTime: time.Now(), + }, + { + name: "leaf doesn't have acceptable ExtKeyUsage", + host: "google.com", + expectedErr: "x509: certificate specifies an incompatible key usage", + verifyEKU: []x509.ExtKeyUsage{x509.ExtKeyUsageEmailProtection}, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + chain := getChain(tc.host) + var opts x509.VerifyOptions + if len(chain) > 1 { + opts.Intermediates = x509.NewCertPool() + for _, c := range chain[1:] { + opts.Intermediates.AddCert(c) + } + } + if tc.verifyName != "" { + opts.DNSName = tc.verifyName + } + if !tc.verifyTime.IsZero() { + opts.CurrentTime = tc.verifyTime + } + if len(tc.verifyEKU) > 0 { + opts.KeyUsages = tc.verifyEKU + } + + _, err := chain[0].Verify(opts) + if err != nil && tc.expectedErr == "" { + t.Errorf("unexpected verification error: %s", err) + } else if err != nil && err.Error() != tc.expectedErr { + t.Errorf("unexpected verification error: got %q, want %q", err.Error(), tc.expectedErr) + } else if err == nil && tc.expectedErr != "" { + t.Errorf("unexpected verification success: want %q", tc.expectedErr) + } + }) } } diff --git a/src/crypto/x509/verify.go b/src/crypto/x509/verify.go index 8aff53afa1..1822a609da 100644 --- a/src/crypto/x509/verify.go +++ b/src/crypto/x509/verify.go @@ -741,8 +741,8 @@ func (c *Certificate) Verify(opts VerifyOptions) (chains [][]*Certificate, err e } } - // Use Windows's own verification and chain building. - if opts.Roots == nil && runtime.GOOS == "windows" { + // Use platform verifiers, where available + if opts.Roots == nil && (runtime.GOOS == "windows" || runtime.GOOS == "darwin") { return c.systemVerify(&opts) } diff --git a/src/crypto/x509/verify_test.go b/src/crypto/x509/verify_test.go index b9b71f4c1e..5b3bf9340a 100644 --- a/src/crypto/x509/verify_test.go +++ b/src/crypto/x509/verify_test.go @@ -1836,8 +1836,8 @@ func TestLongChain(t *testing.T) { } func TestSystemRootsError(t *testing.T) { - if runtime.GOOS == "windows" { - t.Skip("Windows does not use (or support) systemRoots") + if runtime.GOOS == "windows" || runtime.GOOS == "darwin" { + t.Skip("Windows and darwin do not use (or support) systemRoots") } defer func(oldSystemRoots *CertPool) { systemRoots = oldSystemRoots }(systemRootsPool()) diff --git a/src/crypto/x509/x509_test.go b/src/crypto/x509/x509_test.go index affab3789d..949bd7f08b 100644 --- a/src/crypto/x509/x509_test.go +++ b/src/crypto/x509/x509_test.go @@ -1975,8 +1975,8 @@ func TestMultipleRDN(t *testing.T) { } func TestSystemCertPool(t *testing.T) { - if runtime.GOOS == "windows" { - t.Skip("not implemented on Windows; Issue 16736, 18609") + if runtime.GOOS == "windows" || runtime.GOOS == "darwin" { + t.Skip("not implemented on Windows (Issue 16736, 18609) or darwin (Issue 46287)") } a, err := SystemCertPool() if err != nil { From 87a3fc518a462a6bef4c395ec5af26f2cdc41207 Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Wed, 3 Nov 2021 15:16:01 +0100 Subject: [PATCH 005/752] net/netip: reduce allocations in MarshalBinary Addr's MarshalBinary required two allocations in the case of a zone existing, and AddrPort and Prefix both required three. This refactors things slightly so that each marshal function only needs a single allocation. Change-Id: I9bde9969fedc1cad64bebb607188c4287f6a0d01 Reviewed-on: https://go-review.googlesource.com/c/go/+/361054 Trust: Jason A. Donenfeld Run-TryBot: Jason A. Donenfeld TryBot-Result: Go Bot Reviewed-by: Brad Fitzpatrick --- src/net/netip/netip.go | 47 +++++++++++++++++++++--------------------- 1 file changed, 23 insertions(+), 24 deletions(-) diff --git a/src/net/netip/netip.go b/src/net/netip/netip.go index 90672e045d..e6e90f11db 100644 --- a/src/net/netip/netip.go +++ b/src/net/netip/netip.go @@ -962,25 +962,30 @@ func (ip *Addr) UnmarshalText(text []byte) error { return err } +func (ip Addr) marshalBinaryWithTrailingBytes(trailingBytes int) []byte { + var b []byte + switch ip.z { + case z0: + b = make([]byte, trailingBytes) + case z4: + b = make([]byte, 4+trailingBytes) + bePutUint32(b, uint32(ip.addr.lo)) + default: + z := ip.Zone() + b = make([]byte, 16+len(z)+trailingBytes) + bePutUint64(b[:8], ip.addr.hi) + bePutUint64(b[8:], ip.addr.lo) + copy(b[16:], z) + } + return b +} + // MarshalBinary implements the encoding.BinaryMarshaler interface. // It returns a zero-length slice for the zero Addr, // the 4-byte form for an IPv4 address, // and the 16-byte form with zone appended for an IPv6 address. func (ip Addr) MarshalBinary() ([]byte, error) { - switch ip.z { - case z0: - return nil, nil - case z4: - b := ip.As4() - return b[:], nil - default: - b16 := ip.As16() - b := b16[:] - if z := ip.Zone(); z != "" { - b = append(b, []byte(z)...) - } - return b, nil - } + return ip.marshalBinaryWithTrailingBytes(0), nil } // UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. @@ -1174,11 +1179,7 @@ func (p *AddrPort) UnmarshalText(text []byte) error { // It returns Addr.MarshalBinary with an additional two bytes appended // containing the port in little-endian. func (p AddrPort) MarshalBinary() ([]byte, error) { - b, err := p.Addr().MarshalBinary() - if err != nil { - return nil, err - } - b = append(b, 0, 0) + b := p.Addr().marshalBinaryWithTrailingBytes(2) lePutUint16(b[len(b)-2:], p.Port()) return b, nil } @@ -1433,11 +1434,9 @@ func (p *Prefix) UnmarshalText(text []byte) error { // It returns Addr.MarshalBinary with an additional byte appended // containing the prefix bits. func (p Prefix) MarshalBinary() ([]byte, error) { - b, err := p.Addr().MarshalBinary() - if err != nil { - return nil, err - } - return append(b, uint8(p.Bits())), nil + b := p.Addr().withoutZone().marshalBinaryWithTrailingBytes(1) + b[len(b)-1] = uint8(p.Bits()) + return b, nil } // UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. From b07c41d2c1c8d5729250a13b7c560c150c1d9011 Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Wed, 3 Nov 2021 16:46:44 +0100 Subject: [PATCH 006/752] net/netip: add IPv4Unspecified There is IPv6Unspecified but there is not IPv4Unspecified, making for inconsistent code. This commit adds the missing function. Updates #49298. Change-Id: Id2519b646323642f59fb1cc6ea8e335fdde16290 Reviewed-on: https://go-review.googlesource.com/c/go/+/361056 Trust: Jason A. Donenfeld Trust: Brad Fitzpatrick Run-TryBot: Jason A. Donenfeld TryBot-Result: Go Bot Reviewed-by: Brad Fitzpatrick --- src/net/netip/netip.go | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/net/netip/netip.go b/src/net/netip/netip.go index e6e90f11db..1596acbb8e 100644 --- a/src/net/netip/netip.go +++ b/src/net/netip/netip.go @@ -75,6 +75,9 @@ func IPv6LinkLocalAllNodes() Addr { return AddrFrom16([16]byte{0: 0xff, 1: 0x02, // IPv6Unspecified returns the IPv6 unspecified address "::". func IPv6Unspecified() Addr { return Addr{z: z6noz} } +// IPv4Unspecified returns the IPv4 unspecified address "0.0.0.0". +func IPv4Unspecified() Addr { return AddrFrom4([4]byte{}) } + // AddrFrom4 returns the address of the IPv4 address given by the bytes in addr. func AddrFrom4(addr [4]byte) Addr { return Addr{ @@ -595,7 +598,7 @@ func (ip Addr) IsGlobalUnicast() bool { // Match package net's IsGlobalUnicast logic. Notably private IPv4 addresses // and ULA IPv6 addresses are still considered "global unicast". - if ip.Is4() && (ip == AddrFrom4([4]byte{}) || ip == AddrFrom4([4]byte{255, 255, 255, 255})) { + if ip.Is4() && (ip == IPv4Unspecified() || ip == AddrFrom4([4]byte{255, 255, 255, 255})) { return false } @@ -633,7 +636,7 @@ func (ip Addr) IsPrivate() bool { // // Note that the zero Addr is not an unspecified address. func (ip Addr) IsUnspecified() bool { - return ip == AddrFrom4([4]byte{}) || ip == IPv6Unspecified() + return ip == IPv4Unspecified() || ip == IPv6Unspecified() } // Prefix keeps only the top b bits of IP, producing a Prefix From 3b7e376df87fa5255c7aa58d5719593b314338fd Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 5 Nov 2021 15:34:20 -0700 Subject: [PATCH 007/752] net/netip: add tests for Addr.AsSlice Change-Id: Ib88dd101b3bbdf4d2bfd79838994cfadef1b604d Reviewed-on: https://go-review.googlesource.com/c/go/+/361915 Trust: Josh Bleecher Snyder Run-TryBot: Josh Bleecher Snyder Reviewed-by: Brad Fitzpatrick TryBot-Result: Go Bot --- src/net/netip/netip_test.go | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/net/netip/netip_test.go b/src/net/netip/netip_test.go index 63af853cb3..a6327f0dea 100644 --- a/src/net/netip/netip_test.go +++ b/src/net/netip/netip_test.go @@ -1889,6 +1889,24 @@ func TestInvalidAddrPortString(t *testing.T) { } } +func TestAsSlice(t *testing.T) { + tests := []struct { + in Addr + want []byte + }{ + {in: Addr{}, want: nil}, + {in: mustIP("1.2.3.4"), want: []byte{1, 2, 3, 4}}, + {in: mustIP("ffff::1"), want: []byte{0xff, 0xff, 15: 1}}, + } + + for _, test := range tests { + got := test.in.AsSlice() + if !bytes.Equal(got, test.want) { + t.Errorf("%v.AsSlice() = %v want %v", test.in, got, test.want) + } + } +} + var sink16 [16]byte func BenchmarkAs16(b *testing.B) { From ba79c1e24198c2222e3bfe350326a8962fee0441 Mon Sep 17 00:00:00 2001 From: Dmitri Shuralyov Date: Fri, 5 Nov 2021 18:40:03 -0400 Subject: [PATCH 008/752] doc/go1.18: split bytes and strings packages A small touchup after CL 361894. For #47694. Change-Id: Ifc161516f897f727195d21351a3c8eda7b6e327e Reviewed-on: https://go-review.googlesource.com/c/go/+/361895 Trust: Dmitri Shuralyov Reviewed-by: Carlos Amedee Reviewed-by: Michael Knyszek Run-TryBot: Carlos Amedee --- doc/go1.18.html | 22 +++++++++++++--------- 1 file changed, 13 insertions(+), 9 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 55a1de3bd8..b86e907874 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -115,7 +115,7 @@ Do not send CLs removing the interior tags from such phrases.

- TODO: https://golang.org/cl/349595: https://golang.org/cl/349595: cmd/go: add GOAMD64 environment variable + TODO: https://golang.org/cl/349595: cmd/go: add GOAMD64 environment variable

gofmt

@@ -135,17 +135,17 @@ Do not send CLs removing the interior tags from such phrases.

Compiler

- TODO: https://golang.org/cl/298611: https://golang.org/cl/298611: cmd/compile: add -asan option + TODO: https://golang.org/cl/298611: cmd/compile: add -asan option

- TODO: https://golang.org/cl/352057: https://golang.org/cl/352057: cmd/compile, runtime: track argument stack slot liveness + TODO: https://golang.org/cl/352057: cmd/compile, runtime: track argument stack slot liveness

Linker

- TODO: https://golang.org/cl/298610: https://golang.org/cl/298610: cmd/link: add -asan option + TODO: https://golang.org/cl/298610: cmd/link: add -asan option

Core library

@@ -209,6 +209,14 @@ Do not send CLs removing the interior tags from such phrases. +
bytes
+
+

+ TODO: https://golang.org/cl/332771: avoid allocations in Trim/TrimLeft/TrimRight +

+
+
+
crypto/tls

@@ -330,16 +338,12 @@ Do not send CLs removing the interior tags from such phrases.

TODO: https://golang.org/cl/345849: add Clone function

-
-
-
strings,bytes
-

TODO: https://golang.org/cl/332771: avoid allocations in Trim/TrimLeft/TrimRight

-
+
sync
From e83a2047e0332e45c20fb1bcdb984e9cc74ffb1f Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Fri, 5 Nov 2021 14:55:52 -0700 Subject: [PATCH 009/752] net/netip: document the zero Addr Fixes #49364 Change-Id: I3372f80723a4deae48ef106f88b0ad880cdd0e45 Reviewed-on: https://go-review.googlesource.com/c/go/+/361914 Trust: Josh Bleecher Snyder Run-TryBot: Josh Bleecher Snyder Reviewed-by: Brad Fitzpatrick --- src/net/netip/netip.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/net/netip/netip.go b/src/net/netip/netip.go index 1596acbb8e..01f6fe5efa 100644 --- a/src/net/netip/netip.go +++ b/src/net/netip/netip.go @@ -32,6 +32,9 @@ import ( // // Unlike net.IP or net.IPAddr, Addr is a comparable value // type (it supports == and can be a map key) and is immutable. +// +// The zero Addr is not a valid IP address. +// Addr{} is distinct from both 0.0.0.0 and ::. type Addr struct { // addr is the hi and lo bits of an IPv6 address. If z==z4, // hi and lo contain the IPv4-mapped IPv6 address. From 2f71c86370a2c3bf2827e8d9f9080d9bf92a5317 Mon Sep 17 00:00:00 2001 From: Michael Anthony Knyszek Date: Thu, 21 Oct 2021 21:19:23 +0000 Subject: [PATCH 010/752] runtime: retype gcControllerState.gcPercent as atomic.Int32 [git-generate] cd src/runtime mv export_test.go export.go GOROOT=$(dirname $(dirname $PWD)) rf ' add gcControllerState.gcPercent \ // Initialized from GOGC. GOGC=off means no GC. \ gcPercent_ atomic.Int32 ex { import "runtime/internal/atomic" var t gcControllerState var v, w int32 var d int32 t.gcPercent -> t.gcPercent_.Load() t.gcPercent = v -> t.gcPercent_.Store(v) atomic.Loadint32(&t.gcPercent) -> t.gcPercent_.Load() atomic.Storeint32(&t.gcPercent, v) -> t.gcPercent_.Store(v) atomic.Xaddint32(&t.gcPercent, d) -> t.gcPercent_.Add(d) atomic.Casint32(&t.gcPercent, v, w) -> t.gcPercent_.CompareAndSwap(v, w) atomic.Xchgint32(&t.gcPercent, v) -> t.gcPercent_.Swap(v) } rm gcControllerState.gcPercent mv gcControllerState.gcPercent_ gcControllerState.gcPercent ' mv export.go export_test.go Change-Id: I1aae34a3f782d096c6b6233bbf7986e67ce9c5f9 Reviewed-on: https://go-review.googlesource.com/c/go/+/357794 Trust: Michael Knyszek Reviewed-by: Michael Pratt --- src/runtime/mgc.go | 2 +- src/runtime/mgcpacer.go | 31 ++++++++++++++----------------- 2 files changed, 15 insertions(+), 18 deletions(-) diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go index 96f4157b59..d75893dc43 100644 --- a/src/runtime/mgc.go +++ b/src/runtime/mgc.go @@ -545,7 +545,7 @@ func (t gcTrigger) test() bool { // own write. return gcController.heapLive >= gcController.trigger case gcTriggerTime: - if atomic.Loadint32(&gcController.gcPercent) < 0 { + if gcController.gcPercent.Load() < 0 { return false } lastgc := int64(atomic.Load64(&memstats.last_gc_nanotime)) diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go index 5b699cb298..525f33a0cd 100644 --- a/src/runtime/mgcpacer.go +++ b/src/runtime/mgcpacer.go @@ -84,12 +84,9 @@ func init() { var gcController gcControllerState type gcControllerState struct { - // Initialized from $GOGC. GOGC=off means no GC. - // - // Updated atomically with mheap_.lock held or during a STW. - // Safe to read atomically at any time, or non-atomically with - // mheap_.lock or STW. - gcPercent int32 + + // Initialized from GOGC. GOGC=off means no GC. + gcPercent atomic.Int32 _ uint32 // padding so following 64-bit values are 8-byte aligned @@ -479,7 +476,7 @@ func (c *gcControllerState) startCycle(markStartTime int64, procs int) { // is when assists are enabled and the necessary statistics are // available). func (c *gcControllerState) revise() { - gcPercent := atomic.Loadint32(&c.gcPercent) + gcPercent := c.gcPercent.Load() if gcPercent < 0 { // If GC is disabled but we're running a forced GC, // act like GOGC is huge for the below calculations. @@ -969,8 +966,8 @@ func (c *gcControllerState) commit(triggerRatio float64) { // has grown by GOGC/100 over where it started the last cycle, // plus additional runway for non-heap sources of GC work. goal := ^uint64(0) - if c.gcPercent >= 0 { - goal = c.heapMarked + (c.heapMarked+atomic.Load64(&c.stackScan)+atomic.Load64(&c.globalsScan))*uint64(c.gcPercent)/100 + if c.gcPercent.Load() >= 0 { + goal = c.heapMarked + (c.heapMarked+atomic.Load64(&c.stackScan)+atomic.Load64(&c.globalsScan))*uint64(c.gcPercent.Load())/100 } // Don't trigger below the minimum heap size. @@ -1088,13 +1085,13 @@ func (c *gcControllerState) oldCommit(triggerRatio float64) { // has grown by GOGC/100 over the heap marked by the last // cycle. goal := ^uint64(0) - if c.gcPercent >= 0 { - goal = c.heapMarked + c.heapMarked*uint64(c.gcPercent)/100 + if c.gcPercent.Load() >= 0 { + goal = c.heapMarked + c.heapMarked*uint64(c.gcPercent.Load())/100 } // Set the trigger ratio, capped to reasonable bounds. - if c.gcPercent >= 0 { - scalingFactor := float64(c.gcPercent) / 100 + if c.gcPercent.Load() >= 0 { + scalingFactor := float64(c.gcPercent.Load()) / 100 // Ensure there's always a little margin so that the // mutator assist ratio isn't infinity. maxTriggerRatio := 0.95 * scalingFactor @@ -1134,7 +1131,7 @@ func (c *gcControllerState) oldCommit(triggerRatio float64) { // We trigger the next GC cycle when the allocated heap has // grown by the trigger ratio over the marked heap size. trigger := ^uint64(0) - if c.gcPercent >= 0 { + if c.gcPercent.Load() >= 0 { trigger = uint64(float64(c.heapMarked) * (1 + triggerRatio)) // Don't trigger below the minimum heap size. minTrigger := c.heapMinimum @@ -1210,13 +1207,13 @@ func (c *gcControllerState) setGCPercent(in int32) int32 { assertWorldStoppedOrLockHeld(&mheap_.lock) } - out := c.gcPercent + out := c.gcPercent.Load() if in < 0 { in = -1 } // Write it atomically so readers like revise() can read it safely. - atomic.Storeint32(&c.gcPercent, in) - c.heapMinimum = defaultHeapMinimum * uint64(c.gcPercent) / 100 + c.gcPercent.Store(in) + c.heapMinimum = defaultHeapMinimum * uint64(c.gcPercent.Load()) / 100 // Update pacing in response to gcPercent change. c.commit(c.triggerRatio) From 09e8de70c2ee36d99ba02389da0fe2e203879022 Mon Sep 17 00:00:00 2001 From: Michael Anthony Knyszek Date: Thu, 21 Oct 2021 21:26:50 +0000 Subject: [PATCH 011/752] runtime: eliminate rendundant loads gcPercent The previous change was an automated change that made gcPercent a type-safe atomic variable. However, that introduced a lot of redundant formal atomic loads of the variable. Remove them by only loading once in each case, and reusing the value. Change-Id: I49647135f423574f94506d456d1cc390150fad02 Reviewed-on: https://go-review.googlesource.com/c/go/+/357795 Trust: Michael Knyszek Reviewed-by: Michael Pratt --- src/runtime/mgcpacer.go | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go index 525f33a0cd..868666036c 100644 --- a/src/runtime/mgcpacer.go +++ b/src/runtime/mgcpacer.go @@ -966,8 +966,8 @@ func (c *gcControllerState) commit(triggerRatio float64) { // has grown by GOGC/100 over where it started the last cycle, // plus additional runway for non-heap sources of GC work. goal := ^uint64(0) - if c.gcPercent.Load() >= 0 { - goal = c.heapMarked + (c.heapMarked+atomic.Load64(&c.stackScan)+atomic.Load64(&c.globalsScan))*uint64(c.gcPercent.Load())/100 + if gcPercent := c.gcPercent.Load(); gcPercent >= 0 { + goal = c.heapMarked + (c.heapMarked+atomic.Load64(&c.stackScan)+atomic.Load64(&c.globalsScan))*uint64(gcPercent)/100 } // Don't trigger below the minimum heap size. @@ -1081,17 +1081,19 @@ func (c *gcControllerState) commit(triggerRatio float64) { // // For !goexperiment.PacerRedesign. func (c *gcControllerState) oldCommit(triggerRatio float64) { + gcPercent := c.gcPercent.Load() + // Compute the next GC goal, which is when the allocated heap // has grown by GOGC/100 over the heap marked by the last // cycle. goal := ^uint64(0) - if c.gcPercent.Load() >= 0 { - goal = c.heapMarked + c.heapMarked*uint64(c.gcPercent.Load())/100 + if gcPercent >= 0 { + goal = c.heapMarked + c.heapMarked*uint64(gcPercent)/100 } // Set the trigger ratio, capped to reasonable bounds. - if c.gcPercent.Load() >= 0 { - scalingFactor := float64(c.gcPercent.Load()) / 100 + if gcPercent >= 0 { + scalingFactor := float64(gcPercent) / 100 // Ensure there's always a little margin so that the // mutator assist ratio isn't infinity. maxTriggerRatio := 0.95 * scalingFactor @@ -1131,7 +1133,7 @@ func (c *gcControllerState) oldCommit(triggerRatio float64) { // We trigger the next GC cycle when the allocated heap has // grown by the trigger ratio over the marked heap size. trigger := ^uint64(0) - if c.gcPercent.Load() >= 0 { + if gcPercent >= 0 { trigger = uint64(float64(c.heapMarked) * (1 + triggerRatio)) // Don't trigger below the minimum heap size. minTrigger := c.heapMinimum @@ -1211,9 +1213,8 @@ func (c *gcControllerState) setGCPercent(in int32) int32 { if in < 0 { in = -1 } - // Write it atomically so readers like revise() can read it safely. + c.heapMinimum = defaultHeapMinimum * uint64(in) / 100 c.gcPercent.Store(in) - c.heapMinimum = defaultHeapMinimum * uint64(c.gcPercent.Load()) / 100 // Update pacing in response to gcPercent change. c.commit(c.triggerRatio) From b74f2efc47bbfcc4aa301ebda1033948d8b6b63e Mon Sep 17 00:00:00 2001 From: Roland Shoemaker Date: Fri, 1 Oct 2021 09:14:10 -0700 Subject: [PATCH 012/752] crypto/x509: use the platform verifier on iOS Use the same certificate verification APIs on iOS as on macOS (they share the same APIs, so we should be able to transparently use them on both.) Updates #46287 Fixes #38843 Change-Id: If70f99b0823dd5fa747c42ff4f20c3b625605327 Reviewed-on: https://go-review.googlesource.com/c/go/+/353403 Trust: Roland Shoemaker Reviewed-by: Filippo Valsorda Run-TryBot: Roland Shoemaker --- src/cmd/dist/test.go | 11 - src/crypto/x509/cert_pool.go | 2 + src/crypto/x509/root_darwin.go | 2 - src/crypto/x509/root_ios.go | 4872 ----------------------------- src/crypto/x509/root_ios_gen.go | 180 -- src/crypto/x509/root_omit.go | 25 - src/crypto/x509/root_omit_test.go | 22 - src/crypto/x509/verify.go | 2 +- src/crypto/x509/verify_test.go | 2 +- src/crypto/x509/x509_test.go | 2 +- 10 files changed, 5 insertions(+), 5115 deletions(-) delete mode 100644 src/crypto/x509/root_ios.go delete mode 100644 src/crypto/x509/root_ios_gen.go delete mode 100644 src/crypto/x509/root_omit.go delete mode 100644 src/crypto/x509/root_omit_test.go diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go index 98e30a158f..aea1ee6f25 100644 --- a/src/cmd/dist/test.go +++ b/src/cmd/dist/test.go @@ -499,17 +499,6 @@ func (t *tester) registerTests() { }) } - if t.iOS() && !t.compileOnly { - t.tests = append(t.tests, distTest{ - name: "x509omitbundledroots", - heading: "crypto/x509 without bundled roots", - fn: func(dt *distTest) error { - t.addCmd(dt, "src", t.goTest(), t.timeout(300), "-tags=x509omitbundledroots", "-run=OmitBundledRoots", "crypto/x509") - return nil - }, - }) - } - // Test ios/amd64 for the iOS simulator. if goos == "darwin" && goarch == "amd64" && t.cgoEnabled { t.tests = append(t.tests, distTest{ diff --git a/src/crypto/x509/cert_pool.go b/src/crypto/x509/cert_pool.go index 1886825b17..d760dc11c6 100644 --- a/src/crypto/x509/cert_pool.go +++ b/src/crypto/x509/cert_pool.go @@ -108,6 +108,8 @@ func SystemCertPool() (*CertPool, error) { return nil, errors.New("crypto/x509: system root pool is not available on Windows") } else if runtime.GOOS == "darwin" { return nil, errors.New("crypto/x509: system root pool is not available on macOS") + } else if runtime.GOOS == "ios" { + return nil, errors.New("crypto/x509: system root pool is not available on iOS") } if sysRoots := systemRootsPool(); sysRoots != nil { diff --git a/src/crypto/x509/root_darwin.go b/src/crypto/x509/root_darwin.go index eab046120f..7bc6ce09fa 100644 --- a/src/crypto/x509/root_darwin.go +++ b/src/crypto/x509/root_darwin.go @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build !ios - package x509 import ( diff --git a/src/crypto/x509/root_ios.go b/src/crypto/x509/root_ios.go deleted file mode 100644 index c5e3fc0b72..0000000000 --- a/src/crypto/x509/root_ios.go +++ /dev/null @@ -1,4872 +0,0 @@ -// Code generated by root_ios_gen.go -version 55188.120.1.0.1; DO NOT EDIT. -// Update the version in root.go and regenerate with "go generate". - -//go:build ios && !x509omitbundledroots - -package x509 - -func (c *Certificate) systemVerify(opts *VerifyOptions) (chains [][]*Certificate, err error) { - return nil, nil -} - -func loadSystemRoots() (*CertPool, error) { - p := NewCertPool() - p.AppendCertsFromPEM([]byte(systemRootsPEM)) - return p, nil -} - -const systemRootsPEM = ` -# "AAA Certificate Services" -# D7 A7 A0 FB 5D 7E 27 31 D7 71 E9 48 4E BC DE F7 -# 1D 5F 0C 3E 0A 29 48 78 2B C8 3E E0 EA 69 9E F4 ------BEGIN CERTIFICATE----- -MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb -MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow -GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj -YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL -MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE -BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM -GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP -ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua -BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe -3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4 -YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR -rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm -ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU -oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF -MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v -QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t -b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF -AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q -GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz -Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2 -G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi -l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3 -smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg== ------END CERTIFICATE----- -# "AC RAIZ FNMT-RCM" -# EB C5 57 0C 29 01 8C 4D 67 B1 AA 12 7B AF 12 F7 -# 03 B4 61 1E BC 17 B7 DA B5 57 38 94 17 9B 93 FA ------BEGIN CERTIFICATE----- -MIIFgzCCA2ugAwIBAgIPXZONMGc2yAYdGsdUhGkHMA0GCSqGSIb3DQEBCwUAMDsx -CzAJBgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJ -WiBGTk1ULVJDTTAeFw0wODEwMjkxNTU5NTZaFw0zMDAxMDEwMDAwMDBaMDsxCzAJ -BgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJWiBG -Tk1ULVJDTTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBALpxgHpMhm5/ -yBNtwMZ9HACXjywMI7sQmkCpGreHiPibVmr75nuOi5KOpyVdWRHbNi63URcfqQgf -BBckWKo3Shjf5TnUV/3XwSyRAZHiItQDwFj8d0fsjz50Q7qsNI1NOHZnjrDIbzAz -WHFctPVrbtQBULgTfmxKo0nRIBnuvMApGGWn3v7v3QqQIecaZ5JCEJhfTzC8PhxF -tBDXaEAUwED653cXeuYLj2VbPNmaUtu1vZ5Gzz3rkQUCwJaydkxNEJY7kvqcfw+Z -374jNUUeAlz+taibmSXaXvMiwzn15Cou08YfxGyqxRxqAQVKL9LFwag0Jl1mpdIC -IfkYtwb1TplvqKtMUejPUBjFd8g5CSxJkjKZqLsXF3mwWsXmo8RZZUc1g16p6DUL -mbvkzSDGm0oGObVo/CK67lWMK07q87Hj/LaZmtVC+nFNCM+HHmpxffnTtOmlcYF7 -wk5HlqX2doWjKI/pgG6BU6VtX7hI+cL5NqYuSf+4lsKMB7ObiFj86xsc3i1w4peS -MKGJ47xVqCfWS+2QrYv6YyVZLag13cqXM7zlzced0ezvXg5KkAYmY6252TUtB7p2 -ZSysV4999AeU14ECll2jB0nVetBX+RvnU0Z1qrB5QstocQjpYL05ac70r8NWQMet -UqIJ5G+GR4of6ygnXYMgrwTJbFaai0b1AgMBAAGjgYMwgYAwDwYDVR0TAQH/BAUw -AwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFPd9xf3E6Jobd2Sn9R2gzL+H -YJptMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vd3d3 -LmNlcnQuZm5tdC5lcy9kcGNzLzANBgkqhkiG9w0BAQsFAAOCAgEAB5BK3/MjTvDD -nFFlm5wioooMhfNzKWtN/gHiqQxjAb8EZ6WdmF/9ARP67Jpi6Yb+tmLSbkyU+8B1 -RXxlDPiyN8+sD8+Nb/kZ94/sHvJwnvDKuO+3/3Y3dlv2bojzr2IyIpMNOmqOFGYM -LVN0V2Ue1bLdI4E7pWYjJ2cJj+F3qkPNZVEI7VFY/uY5+ctHhKQV8Xa7pO6kO8Rf -77IzlhEYt8llvhjho6Tc+hj507wTmzl6NLrTQfv6MooqtyuGC2mDOL7Nii4LcK2N -JpLuHvUBKwrZ1pebbuCoGRw6IYsMHkCtA+fdZn71uSANA+iW+YJF1DngoABd15jm -fZ5nc8OaKveri6E6FO80vFIOiZiaBECEHX5FaZNXzuvO+FB8TxxuBEOb+dY7Ixjp -6o7RTUaN8Tvkasq6+yO3m/qZASlaWFot4/nUbQ4mrcFuNLwy+AwF+mWj2zs3gyLp -1txyM/1d8iC9djwj2ij3+RvrWWTV3F9yfiD8zYm1kGdNYno/Tq0dwzn+evQoFt9B -9kiABdcPUXmsEKvU7ANm5mqwujGSQkBqvjrTcuFqN1W8rB2Vt2lh8kORdOag0wok -RqEIr9baRRmW1FMdW4R58MD3R++Lj8UGrp1MYp3/RgT408m2ECVAdf4WqslKYIYv -uu8wd+RU4riEmViAqhOLUTpPSPaLtrM= ------END CERTIFICATE----- -# "Actalis Authentication Root CA" -# 55 92 60 84 EC 96 3A 64 B9 6E 2A BE 01 CE 0B A8 -# 6A 64 FB FE BC C7 AA B5 AF C1 55 B3 7F D7 60 66 ------BEGIN CERTIFICATE----- -MIIFuzCCA6OgAwIBAgIIVwoRl0LE48wwDQYJKoZIhvcNAQELBQAwazELMAkGA1UE -BhMCSVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpBY3RhbGlzIFMucC5BLi8w -MzM1ODUyMDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNhdGlvbiBSb290 -IENBMB4XDTExMDkyMjExMjIwMloXDTMwMDkyMjExMjIwMlowazELMAkGA1UEBhMC -SVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpBY3RhbGlzIFMucC5BLi8wMzM1 -ODUyMDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNhdGlvbiBSb290IENB -MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAp8bEpSmkLO/lGMWwUKNv -UTufClrJwkg4CsIcoBh/kbWHuUA/3R1oHwiD1S0eiKD4j1aPbZkCkpAW1V8IbInX -4ay8IMKx4INRimlNAJZaby/ARH6jDuSRzVju3PvHHkVH3Se5CAGfpiEd9UEtL0z9 -KK3giq0itFZljoZUj5NDKd45RnijMCO6zfB9E1fAXdKDa0hMxKufgFpbOr3JpyI/ -gCczWw63igxdBzcIy2zSekciRDXFzMwujt0q7bd9Zg1fYVEiVRvjRuPjPdA1Yprb -rxTIW6HMiRvhMCb8oJsfgadHHwTrozmSBp+Z07/T6k9QnBn+locePGX2oxgkg4YQ -51Q+qDp2JE+BIcXjDwL4k5RHILv+1A7TaLndxHqEguNTVHnd25zS8gebLra8Pu2F -be8lEfKXGkJh90qX6IuxEAf6ZYGyojnP9zz/GPvG8VqLWeICrHuS0E4UT1lF9gxe -KF+w6D9Fz8+vm2/7hNN3WpVvrJSEnu68wEqPSpP4RCHiMUVhUE4Q2OM1fEwZtN4F -v6MGn8i1zeQf1xcGDXqVdFUNaBr8EBtiZJ1t4JWgw5QHVw0U5r0F+7if5t+L4sbn -fpb2U8WANFAoWPASUHEXMLrmeGO89LKtmyuy/uE5jF66CyCU3nuDuP/jVo23Eek7 -jPKxwV2dpAtMK9myGPW1n0sCAwEAAaNjMGEwHQYDVR0OBBYEFFLYiDrIn3hm7Ynz -ezhwlMkCAjbQMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUUtiIOsifeGbt -ifN7OHCUyQICNtAwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4ICAQAL -e3KHwGCmSUyIWOYdiPcUZEim2FgKDk8TNd81HdTtBjHIgT5q1d07GjLukD0R0i70 -jsNjLiNmsGe+b7bAEzlgqqI0JZN1Ut6nna0Oh4lScWoWPBkdg/iaKWW+9D+a2fDz -WochcYBNy+A4mz+7+uAwTc+G02UQGRjRlwKxK3JCaKygvU5a2hi/a5iB0P2avl4V -SM0RFbnAKVy06Ij3Pjaut2L9HmLecHgQHEhb2rykOLpn7VU+Xlff1ANATIGk0k9j -pwlCCRT8AKnCgHNPLsBA2RF7SOp6AsDT6ygBJlh0wcBzIm2Tlf05fbsq4/aC4yyX -X04fkZT6/iyj2HYauE2yOE+b+h1IYHkm4vP9qdCa6HCPSXrW5b0KDtst842/6+Ok -fcvHlXHo2qN8xcL4dJIEG4aspCJTQLas/kx2z/uUMsA1n3Y/buWQbqCmJqK4LL7R -K4X9p2jIugErsWx0Hbhzlefut8cl8ABMALJ+tguLHPPAUJ4lueAI3jZm/zel0btU -ZCzJJ7VLkn5l/9Mt4blOvH+kQSGQQXemOR/qnuOf0GZvBeyqdn6/axag67XH/JJU -LysRJyU3eExRarDzzFhdFPFqSBX/wge2sY0PjlxQRrM9vwGYT7JZVEc+NHt4bVaT -LnPqZih4zR0Uv6CPLy64Lo7yFIrM6bV8+2ydDKXhlg== ------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 ------BEGIN CERTIFICATE----- -MIIFVTCCBD2gAwIBAgIEO/OB0DANBgkqhkiG9w0BAQUFADBsMQswCQYDVQQGEwJj -aDEOMAwGA1UEChMFYWRtaW4xETAPBgNVBAsTCFNlcnZpY2VzMSIwIAYDVQQLExlD -ZXJ0aWZpY2F0aW9uIEF1dGhvcml0aWVzMRYwFAYDVQQDEw1BZG1pbi1Sb290LUNB -MB4XDTAxMTExNTA4NTEwN1oXDTIxMTExMDA3NTEwN1owbDELMAkGA1UEBhMCY2gx -DjAMBgNVBAoTBWFkbWluMREwDwYDVQQLEwhTZXJ2aWNlczEiMCAGA1UECxMZQ2Vy -dGlmaWNhdGlvbiBBdXRob3JpdGllczEWMBQGA1UEAxMNQWRtaW4tUm9vdC1DQTCC -ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMvgr0QUIv5qF0nyXZ3PXAJi -C4C5Wr+oVTN7oxIkXkxvO0GJToM9n7OVJjSmzBL0zJ2HXj0MDRcvhSY+KiZZc6Go -vDvr5Ua481l7ILFeQAFtumeza+vvxeL5Nd0Maga2miiacLNAKXbAcUYRa0Ov5VZB -++YcOYNNt/aisWbJqA2y8He+NsEgJzK5zNdayvYXQTZN+7tVgWOck16Da3+4FXdy -fH1NCWtZlebtMKtERtkVAaVbiWW24CjZKAiVfggjsiLo3yVMPGj3budLx5D9hEEm -vlyDOtcjebca+AcZglppWMX/iHIrx7740y0zd6cWEqiLIcZCrnpkr/KzwO135GkC -AwEAAaOCAf0wggH5MA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIASBkTCBjjCBiwYI -YIV0AREDAQAwfzArBggrBgEFBQcCAjAfGh1UaGlzIGlzIHRoZSBBZG1pbi1Sb290 -LUNBIENQUzBQBggrBgEFBQcCARZEaHR0cDovL3d3dy5pbmZvcm1hdGlrLmFkbWlu -LmNoL1BLSS9saW5rcy9DUFNfMl8xNl83NTZfMV8xN18zXzFfMC5wZGYwfwYDVR0f -BHgwdjB0oHKgcKRuMGwxFjAUBgNVBAMTDUFkbWluLVJvb3QtQ0ExIjAgBgNVBAsT -GUNlcnRpZmljYXRpb24gQXV0aG9yaXRpZXMxETAPBgNVBAsTCFNlcnZpY2VzMQ4w -DAYDVQQKEwVhZG1pbjELMAkGA1UEBhMCY2gwHQYDVR0OBBYEFIKf+iNzIPGXi7JM -Tb5CxX9mzWToMIGZBgNVHSMEgZEwgY6AFIKf+iNzIPGXi7JMTb5CxX9mzWTooXCk -bjBsMQswCQYDVQQGEwJjaDEOMAwGA1UEChMFYWRtaW4xETAPBgNVBAsTCFNlcnZp -Y2VzMSIwIAYDVQQLExlDZXJ0aWZpY2F0aW9uIEF1dGhvcml0aWVzMRYwFAYDVQQD -Ew1BZG1pbi1Sb290LUNBggQ784HQMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0B -AQUFAAOCAQEAeE96XCYRpy6umkPKXDWCRn7INo96ZrWpMggcDORuofHIwdTkgOeM -vWOxDN/yuT7CC3FAaUajbPRbDw0hRMcqKz0aC8CgwcyIyhw/rFK29mfNTG3EviP9 -QSsEbnelFnjpm1wjz4EaBiFjatwpUbI6+Zv3XbEt9QQXBn+c6DeFLe4xvC4B+MTr -a440xTk59pSYux8OHhEvqIwHCkiijGqZhTS3KmGFeBopaR+dJVBRBMoXwzk4B3Hn -0Zib1dEYFZa84vPJZyvxCbLOnPRDJgH6V2uQqbG+6DXVaf/wORVOvF/wzzv0viM/ -RWbEtJZdvo8N3sdtCULzifnxP/V0T9+4ZQ== ------END CERTIFICATE----- -# "AffirmTrust Commercial" -# 03 76 AB 1D 54 C5 F9 80 3C E4 B2 E2 01 A0 EE 7E -# EF 7B 57 B6 36 E8 A9 3C 9B 8D 48 60 C9 6F 5F A7 ------BEGIN CERTIFICATE----- -MIIDTDCCAjSgAwIBAgIId3cGJyapsXwwDQYJKoZIhvcNAQELBQAwRDELMAkGA1UE -BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz -dCBDb21tZXJjaWFsMB4XDTEwMDEyOTE0MDYwNloXDTMwMTIzMTE0MDYwNlowRDEL -MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp -cm1UcnVzdCBDb21tZXJjaWFsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEA9htPZwcroRX1BiLLHwGy43NFBkRJLLtJJRTWzsO3qyxPxkEylFf6EqdbDuKP -Hx6GGaeqtS25Xw2Kwq+FNXkyLbscYjfysVtKPcrNcV/pQr6U6Mje+SJIZMblq8Yr -ba0F8PrVC8+a5fBQpIs7R6UjW3p6+DM/uO+Zl+MgwdYoic+U+7lF7eNAFxHUdPAL -MeIrJmqbTFeurCA+ukV6BfO9m2kVrn1OIGPENXY6BwLJN/3HR+7o8XYdcxXyl6S1 -yHp52UKqK39c/s4mT6NmgTWvRLpUHhwwMmWd5jyTXlBOeuM61G7MGvv50jeuJCqr -VwMiKA1JdX+3KNp1v47j3A55MQIDAQABo0IwQDAdBgNVHQ4EFgQUnZPGU4teyq8/ -nx4P5ZmVvCT2lI8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ -KoZIhvcNAQELBQADggEBAFis9AQOzcAN/wr91LoWXym9e2iZWEnStB03TX8nfUYG -XUPGhi4+c7ImfU+TqbbEKpqrIZcUsd6M06uJFdhrJNTxFq7YpFzUf1GO7RgBsZNj -vbz4YYCanrHOQnDiqX0GJX0nof5v7LMeJNrjS1UaADs1tDvZ110w/YETifLCBivt -Z8SOyUOyXGsViQK8YvxO8rUzqrJv0wqiUOP2O+guRMLbZjipM1ZI8W0bM40NjD9g -N53Tym1+NH4Nn3J2ixufcv1SNUFFApYvHLKac0khsUlHRUe072o0EclNmsxZt9YC -nlpOZbWUrhvfKbAW8b8Angc6F2S1BLUjIZkKlTuXfO8= ------END CERTIFICATE----- -# "AffirmTrust Networking" -# 0A 81 EC 5A 92 97 77 F1 45 90 4A F3 8D 5D 50 9F -# 66 B5 E2 C5 8F CD B5 31 05 8B 0E 17 F3 F0 B4 1B ------BEGIN CERTIFICATE----- -MIIDTDCCAjSgAwIBAgIIfE8EORzUmS0wDQYJKoZIhvcNAQEFBQAwRDELMAkGA1UE -BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz -dCBOZXR3b3JraW5nMB4XDTEwMDEyOTE0MDgyNFoXDTMwMTIzMTE0MDgyNFowRDEL -MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp -cm1UcnVzdCBOZXR3b3JraW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEAtITMMxcua5Rsa2FSoOujz3mUTOWUgJnLVWREZY9nZOIG41w3SfYvm4SEHi3y -YJ0wTsyEheIszx6e/jarM3c1RNg1lho9Nuh6DtjVR6FqaYvZ/Ls6rnla1fTWcbua -kCNrmreIdIcMHl+5ni36q1Mr3Lt2PpNMCAiMHqIjHNRqrSK6mQEubWXLviRmVSRL -QESxG9fhwoXA3hA/Pe24/PHxI1Pcv2WXb9n5QHGNfb2V1M6+oF4nI979ptAmDgAp -6zxG8D1gvz9Q0twmQVGeFDdCBKNwV6gbh+0t+nvujArjqWaJGctB+d1ENmHP4ndG -yH329JKBNv3bNPFyfvMMFr20FQIDAQABo0IwQDAdBgNVHQ4EFgQUBx/S55zawm6i -QLSwelAQUHTEyL0wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ -KoZIhvcNAQEFBQADggEBAIlXshZ6qML91tmbmzTCnLQyFE2npN/svqe++EPbkTfO -tDIuUFUaNU52Q3Eg75N3ThVwLofDwR1t3Mu1J9QsVtFSUzpE0nPIxBsFZVpikpzu -QY0x2+c06lkh1QF612S4ZDnNye2v7UsDSKegmQGA3GWjNq5lWUhPgkvIZfFXHeVZ -Lgo/bNjR9eUJtGxUAArgFU2HdW23WJZa3W3SAKD0m0i+wzekujbgfIeFlxoVot4u -olu9rxj5kFDNcFn4J2dHy8egBzp90SxdbBk6ZrV9/ZFvgrG+CJPbFEfxojfHRZ48 -x3evZKiT3/Zpg4Jg8klCNO1aAFSFHBY2kgxc+qatv9s= ------END CERTIFICATE----- -# "AffirmTrust Premium" -# 70 A7 3F 7F 37 6B 60 07 42 48 90 45 34 B1 14 82 -# D5 BF 0E 69 8E CC 49 8D F5 25 77 EB F2 E9 3B 9A ------BEGIN CERTIFICATE----- -MIIFRjCCAy6gAwIBAgIIbYwURrGmCu4wDQYJKoZIhvcNAQEMBQAwQTELMAkGA1UE -BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1UcnVz -dCBQcmVtaXVtMB4XDTEwMDEyOTE0MTAzNloXDTQwMTIzMTE0MTAzNlowQTELMAkG -A1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1U -cnVzdCBQcmVtaXVtMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBLf -qV/+Qd3d9Z+K4/as4Tx4mrzY8H96oDMq3I0gW64tb+eT2TZwamjPjlGjhVtnBKAQ -JG9dKILBl1fYSCkTtuG+kU3fhQxTGJoeJKJPj/CihQvL9Cl/0qRY7iZNyaqoe5rZ -+jjeRFcV5fiMyNlI4g0WJx0eyIOFJbe6qlVBzAMiSy2RjYvmia9mx+n/K+k8rNrS -s8PhaJyJ+HoAVt70VZVs+7pk3WKL3wt3MutizCaam7uqYoNMtAZ6MMgpv+0GTZe5 -HMQxK9VfvFMSF5yZVylmd2EhMQcuJUmdGPLu8ytxjLW6OQdJd/zvLpKQBY0tL3d7 -70O/Nbua2Plzpyzy0FfuKE4mX4+QaAkvuPjcBukumj5Rp9EixAqnOEhss/n/fauG -V+O61oV4d7pD6kh/9ti+I20ev9E2bFhc8e6kGVQa9QPSdubhjL08s9NIS+LI+H+S -qHZGnEJlPqQewQcDWkYtuJfzt9WyVSHvutxMAJf7FJUnM7/oQ0dG0giZFmA7mn7S -5u046uwBHjxIVkkJx0w3AJ6IDsBz4W9m6XJHMD4Q5QsDyZpCAGzFlH5hxIrff4Ia -C1nEWTJ3s7xgaVY5/bQGeyzWZDbZvUjthB9+pSKPKrhC9IK31FOQeE4tGv2Bb0TX -OwF0lkLgAOIua+rF7nKsu7/+6qqo+Nz2snmKtmcCAwEAAaNCMEAwHQYDVR0OBBYE -FJ3AZ6YMItkm9UWrpmVSESfYRaxjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/ -BAQDAgEGMA0GCSqGSIb3DQEBDAUAA4ICAQCzV00QYk465KzquByvMiPIs0laUZx2 -KI15qldGF9X1Uva3ROgIRL8YhNILgM3FEv0AVQVhh0HctSSePMTYyPtwni94loMg -Nt58D2kTiKV1NpgIpsbfrM7jWNa3Pt668+s0QNiigfV4Py/VpfzZotReBA4Xrf5B -8OWycvpEgjNC6C1Y91aMYj+6QrCcDFx+LmUmXFNPALJ4fqENmS2NuB2OosSw/WDQ -MKSOyARiqcTtNd56l+0OOF6SL5Nwpamcb6d9Ex1+xghIsV5n61EIJenmJWtSKZGc -0jlzCFfemQa0W50QBuHCAKi4HEoCChTQwUHK+4w1IX2COPKpVJEZNZOUbWo6xbLQ -u4mGk+ibyQ86p3q4ofB4Rvr8Ny/lioTz3/4E2aFooC8k4gmVBtWVyuEklut89pMF -u+1z6S3RdTnX5yTb2E5fQ4+e0BQ5v1VwSJlXMbSc7kqYA5YwH2AG7hsj/oFgIxpH -YoWlzBk0gG+zrBrjn/B7SK3VAdlntqlyk+otZrWyuOQ9PLLvTIzq6we/qzWaVYa8 -GKa1qF60g2xraUDTn9zxw2lrueFtCfTxqlB2Cnp9ehehVZZCmTEJ3WARjQUwfuaO -RtGdFNrHF+QFlozEJLUbzxQHskD4o55BhrwE0GuWyCqANP2/7waj3VjFhT0+j/6e -KeC2uAloGRwYQw== ------END CERTIFICATE----- -# "AffirmTrust Premium ECC" -# BD 71 FD F6 DA 97 E4 CF 62 D1 64 7A DD 25 81 B0 -# 7D 79 AD F8 39 7E B4 EC BA 9C 5E 84 88 82 14 23 ------BEGIN CERTIFICATE----- -MIIB/jCCAYWgAwIBAgIIdJclisc/elQwCgYIKoZIzj0EAwMwRTELMAkGA1UEBhMC -VVMxFDASBgNVBAoMC0FmZmlybVRydXN0MSAwHgYDVQQDDBdBZmZpcm1UcnVzdCBQ -cmVtaXVtIEVDQzAeFw0xMDAxMjkxNDIwMjRaFw00MDEyMzExNDIwMjRaMEUxCzAJ -BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJt -VHJ1c3QgUHJlbWl1bSBFQ0MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQNMF4bFZ0D -0KF5Nbc6PJJ6yhUczWLznCZcBz3lVPqj1swS6vQUX+iOGasvLkjmrBhDeKzQN8O9 -ss0s5kfiGuZjuD0uL3jET9v0D6RoTFVya5UdThhClXjMNzyR4ptlKymjQjBAMB0G -A1UdDgQWBBSaryl6wBE1NSZRMADDav5A1a7WPDAPBgNVHRMBAf8EBTADAQH/MA4G -A1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNnADBkAjAXCfOHiFBar8jAQr9HX/Vs -aobgxCd05DhT1wV/GzTjxi+zygk8N53X57hG8f2h4nECMEJZh0PUUd+60wkyWs6I -flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ== ------END CERTIFICATE----- -# "Amazon Root CA 1" -# 8E CD E6 88 4F 3D 87 B1 12 5B A3 1A C3 FC B1 3D -# 70 16 DE 7F 57 CC 90 4F E1 CB 97 C6 AE 98 19 6E ------BEGIN CERTIFICATE----- -MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF -ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6 -b24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL -MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv -b3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj -ca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM -9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw -IFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6 -VOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L -93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm -jgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC -AYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA -A4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI -U5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs -N+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv -o/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU -5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy -rqXRfboQnoZsG4q5WTP468SQvvG5 ------END CERTIFICATE----- -# "Amazon Root CA 2" -# 1B A5 B2 AA 8C 65 40 1A 82 96 01 18 F8 0B EC 4F -# 62 30 4D 83 CE C4 71 3A 19 C3 9C 01 1E A4 6D B4 ------BEGIN CERTIFICATE----- -MIIFQTCCAymgAwIBAgITBmyf0pY1hp8KD+WGePhbJruKNzANBgkqhkiG9w0BAQwF -ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6 -b24gUm9vdCBDQSAyMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTEL -MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv -b3QgQ0EgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK2Wny2cSkxK -gXlRmeyKy2tgURO8TW0G/LAIjd0ZEGrHJgw12MBvIITplLGbhQPDW9tK6Mj4kHbZ -W0/jTOgGNk3Mmqw9DJArktQGGWCsN0R5hYGCrVo34A3MnaZMUnbqQ523BNFQ9lXg -1dKmSYXpN+nKfq5clU1Imj+uIFptiJXZNLhSGkOQsL9sBbm2eLfq0OQ6PBJTYv9K -8nu+NQWpEjTj82R0Yiw9AElaKP4yRLuH3WUnAnE72kr3H9rN9yFVkE8P7K6C4Z9r -2UXTu/Bfh+08LDmG2j/e7HJV63mjrdvdfLC6HM783k81ds8P+HgfajZRRidhW+me -z/CiVX18JYpvL7TFz4QuK/0NURBs+18bvBt+xa47mAExkv8LV/SasrlX6avvDXbR -8O70zoan4G7ptGmh32n2M8ZpLpcTnqWHsFcQgTfJU7O7f/aS0ZzQGPSSbtqDT6Zj -mUyl+17vIWR6IF9sZIUVyzfpYgwLKhbcAS4y2j5L9Z469hdAlO+ekQiG+r5jqFoz -7Mt0Q5X5bGlSNscpb/xVA1wf+5+9R+vnSUeVC06JIglJ4PVhHvG/LopyboBZ/1c6 -+XUyo05f7O0oYtlNc/LMgRdg7c3r3NunysV+Ar3yVAhU/bQtCSwXVEqY0VThUWcI -0u1ufm8/0i2BWSlmy5A5lREedCf+3euvAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMB -Af8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSwDPBMMPQFWAJI/TPlUq9LhONm -UjANBgkqhkiG9w0BAQwFAAOCAgEAqqiAjw54o+Ci1M3m9Zh6O+oAA7CXDpO8Wqj2 -LIxyh6mx/H9z/WNxeKWHWc8w4Q0QshNabYL1auaAn6AFC2jkR2vHat+2/XcycuUY -+gn0oJMsXdKMdYV2ZZAMA3m3MSNjrXiDCYZohMr/+c8mmpJ5581LxedhpxfL86kS -k5Nrp+gvU5LEYFiwzAJRGFuFjWJZY7attN6a+yb3ACfAXVU3dJnJUH/jWS5E4ywl -7uxMMne0nxrpS10gxdr9HIcWxkPo1LsmmkVwXqkLN1PiRnsn/eBG8om3zEK2yygm -btmlyTrIQRNg91CMFa6ybRoVGld45pIq2WWQgj9sAq+uEjonljYE1x2igGOpm/Hl -urR8FLBOybEfdF849lHqm/osohHUqS0nGkWxr7JOcQ3AWEbWaQbLU8uz/mtBzUF+ -fUwPfHJ5elnNXkoOrJupmHN5fLT0zLm4BwyydFy4x2+IoZCn9Kr5v2c69BoVYh63 -n749sSmvZ6ES8lgQGVMDMBu4Gon2nL2XA46jCfMdiyHxtN/kHNGfZQIG6lzWE7OE -76KlXIx3KadowGuuQNKotOrN8I1LOJwZmhsoVLiJkO/KdYE+HvJkJMcYr07/R54H -9jVlpNMKVv/1F2Rs76giJUmTtt8AF9pYfl3uxRuw0dFfIRDH+fO6AgonB8Xx1sfT -4PsJYGw= ------END CERTIFICATE----- -# "Amazon Root CA 3" -# 18 CE 6C FE 7B F1 4E 60 B2 E3 47 B8 DF E8 68 CB -# 31 D0 2E BB 3A DA 27 15 69 F5 03 43 B4 6D B3 A4 ------BEGIN CERTIFICATE----- -MIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5 -MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g -Um9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG -A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg -Q0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl -ui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j -QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr -ttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr -BqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM -YyRIHN8wfdVoOw== ------END CERTIFICATE----- -# "Amazon Root CA 4" -# E3 5D 28 41 9E D0 20 25 CF A6 90 38 CD 62 39 62 -# 45 8D A5 C6 95 FB DE A3 C2 2B 0B FB 25 89 70 92 ------BEGIN CERTIFICATE----- -MIIB8jCCAXigAwIBAgITBmyf18G7EEwpQ+Vxe3ssyBrBDjAKBggqhkjOPQQDAzA5 -MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g -Um9vdCBDQSA0MB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG -A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg -Q0EgNDB2MBAGByqGSM49AgEGBSuBBAAiA2IABNKrijdPo1MN/sGKe0uoe0ZLY7Bi -9i0b2whxIdIA6GO9mif78DluXeo9pcmBqqNbIJhFXRbb/egQbeOc4OO9X4Ri83Bk -M6DLJC9wuoihKqB1+IGuYgbEgds5bimwHvouXKNCMEAwDwYDVR0TAQH/BAUwAwEB -/zAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFNPsxzplbszh2naaVvuc84ZtV+WB -MAoGCCqGSM49BAMDA2gAMGUCMDqLIfG9fhGt0O9Yli/W651+kI0rz2ZVwyzjKKlw -CkcO8DdZEv8tmZQoTipPNU0zWgIxAOp1AE47xDqUEpHJWEadIRNyp4iciuRMStuW -1KyLa2tJElMzrdfkviT8tQp21KW8EA== ------END CERTIFICATE----- -# "ANF Global Root CA" -# E3 26 8F 61 06 BA 8B 66 5A 1A 96 2D DE A1 45 9D -# 2A 46 97 2F 1F 24 40 32 9B 39 0B 89 57 49 AD 45 ------BEGIN CERTIFICATE----- -MIIIGDCCBgCgAwIBAgIGAT8vMXfmMA0GCSqGSIb3DQEBCwUAMIIBCjELMAkGA1UE -BhMCRVMxEjAQBgNVBAgMCUJhcmNlbG9uYTFYMFYGA1UEBwxPQmFyY2Vsb25hIChz -ZWUgY3VycmVudCBhZGRyZXNzIGF0IGh0dHA6Ly93d3cuYW5mLmVzL2VzL2FkZHJl -c3MtZGlyZWNjaW9uLmh0bWwgKTEnMCUGA1UECgweQU5GIEF1dG9yaWRhZCBkZSBD -ZXJ0aWZpY2FjaW9uMRcwFQYDVQQLDA5BTkYgQ2xhc2UgMSBDQTEaMBgGCSqGSIb3 -DQEJARYLaW5mb0BhbmYuZXMxEjAQBgNVBAUTCUc2MzI4NzUxMDEbMBkGA1UEAwwS -QU5GIEdsb2JhbCBSb290IENBMB4XDTEzMDYxMDE3NDUzOFoXDTMzMDYwNTE3NDUz -OFowggEKMQswCQYDVQQGEwJFUzESMBAGA1UECAwJQmFyY2Vsb25hMVgwVgYDVQQH -DE9CYXJjZWxvbmEgKHNlZSBjdXJyZW50IGFkZHJlc3MgYXQgaHR0cDovL3d3dy5h -bmYuZXMvZXMvYWRkcmVzcy1kaXJlY2Npb24uaHRtbCApMScwJQYDVQQKDB5BTkYg -QXV0b3JpZGFkIGRlIENlcnRpZmljYWNpb24xFzAVBgNVBAsMDkFORiBDbGFzZSAx -IENBMRowGAYJKoZIhvcNAQkBFgtpbmZvQGFuZi5lczESMBAGA1UEBRMJRzYzMjg3 -NTEwMRswGQYDVQQDDBJBTkYgR2xvYmFsIFJvb3QgQ0EwggIiMA0GCSqGSIb3DQEB -AQUAA4ICDwAwggIKAoICAQDHPi9xy4wynbcUbWjorVUgQKeUAVh937J7P37XmsfH -ZLOBZKIIlhhCtRwnDlg7x+BUvtJOTkIbEGMujDygUQ2s3HDYr5I41hTyM2Pl0cq2 -EuSGEbPIHb3dEX8NAguFexM0jqNjrreN3hM2/+TOkAxSdDJP2aMurlySC5zwl47K -ZLHtcVrkZnkDa0o5iN24hJT4vBDT4t2q9khQ+qb1D8KgCOb02r1PxWXu3vfd6Ha2 -mkdB97iGuEh5gO2n4yOmFS5goFlVA2UdPbbhJsb8oKVKDd+YdCKGQDCkQyG4AjmC -YiNm3UPG/qtftTH5cWri67DlLtm6fyUFOMmO6NSh0RtR745pL8GyWJUanyq/Q4bF -HQB21E+WtTsCaqjGaoFcrBunMypmCd+jUZXl27TYENRFbrwNdAh7m2UztcIyb+Sg -VJFyfvVsBQNvnp7GPimVxXZNc4VpxEXObRuPWQN1oZN/90PcZVqTia/SHzEyTryL -ckhiLG3jZiaFZ7pTZ5I9wti9Pn+4kOHvE3Y/4nEnUo4mTxPX9pOlinF+VCiybtV2 -u1KSlc+YaIM7VmuyndDZCJRXm3v0/qTE7t5A5fArZl9lvibigMbWB8fpD+c1GpGH -Eo8NRY0lkaM+DkIqQoaziIsz3IKJrfdKaq9bQMSlIfameKBZ8fNYTBZrH9KZAIhz -YwIDAQABo4IBfjCCAXowHQYDVR0OBBYEFIf6nt9SdnXsSUogb1twlo+d77sXMB8G -A1UdIwQYMBaAFIf6nt9SdnXsSUogb1twlo+d77sXMA8GA1UdEwEB/wQFMAMBAf8w -DgYDVR0PAQH/BAQDAgEGMIIBFQYDVR0RBIIBDDCCAQiCEWh0dHA6Ly93d3cuYW5m -LmVzgQtpbmZvQGFuZi5lc6SB5TCB4jE0MDIGA1UECQwrR3JhbiBWaWEgZGUgbGVz -IENvcnRzIENhdGFsYW5lcy4gOTk2LiAwODAxODESMBAGA1UEBwwJQmFyY2Vsb25h -MScwJQYDVQQKDB5BTkYgQXV0b3JpZGFkIGRlIENlcnRpZmljYWNpb24xEjAQBgNV -BAUTCUc2MzI4NzUxMDFZMFcGA1UECwxQSW5zY3JpdGEgZW4gZWwgTWluaXN0ZXJp -byBkZWwgSW50ZXJpb3IgZGUgRXNwYcOxYSBjb24gZWwgbnVtZXJvIG5hY2lvbmFs -IDE3MS40NDMwDQYJKoZIhvcNAQELBQADggIBAIgR9tFTZ9BCYg+HViMxOfF0MHN2 -Pe/eC128ARdS+GH8A4thtbqiH/SOYbWofO/0zssHhNKa5iQEj45lCAb8BANpWJMD -nWkPr6jq2+50a6d0MMgSS2l1rvjSF+3nIrEuicshHXSTi3q/vBLKr7uGKMVFaM68 -XAropIwk6ndlA0JseARSPsbetv7ALESMIZAxlHV1TcctYHd0bB3c/Jz+PLszJQqs -Cg/kBPo2D111OXZkIY8W/fJuG9veR783khAK2gUnC0zLLCNsYzEbdGt8zUmBsAsM -cGxqGm6B6vDXd65OxWqw13xdq/24+5R8Ng1PF9tvfjZkUFBF30CxjWur7P90WiKI -G7IGfr6BE1NgXlhEQQu4F+HizB1ypEPzGWltecXQ4yOzO+H0WfFTjLTYX6VSveyW -DQV18ixF8M4tHP/SwNE+yyv2b2JJ3/3RpxjtFlLk+opJ574x0gD/dMJuWTH0JqVY -3PbRfE1jIxFpk164Qz/Xp7H7w7f6xh+tQCkBs3PUYmnGIZcPwq44Q6JHlCNsKx4K -hxfggTvRCk4w79cUID45c2qDsRCqTPoOo/cbOpcfVhbH9LdMORpmuLwNogRZEUSE -fWpqR9q+0kcQf4zGSWIURIyDrogdpDgoHDxktqgMgc+qA4ZE2WQl1D8hmev53A46 -lUSrWUiWfDXtK3ux ------END CERTIFICATE----- -# "Apple Root CA" -# B0 B1 73 0E CB C7 FF 45 05 14 2C 49 F1 29 5E 6E -# DA 6B CA ED 7E 2C 68 C5 BE 91 B5 A1 10 01 F0 24 ------BEGIN CERTIFICATE----- -MIIEuzCCA6OgAwIBAgIBAjANBgkqhkiG9w0BAQUFADBiMQswCQYDVQQGEwJVUzET -MBEGA1UEChMKQXBwbGUgSW5jLjEmMCQGA1UECxMdQXBwbGUgQ2VydGlmaWNhdGlv -biBBdXRob3JpdHkxFjAUBgNVBAMTDUFwcGxlIFJvb3QgQ0EwHhcNMDYwNDI1MjE0 -MDM2WhcNMzUwMjA5MjE0MDM2WjBiMQswCQYDVQQGEwJVUzETMBEGA1UEChMKQXBw -bGUgSW5jLjEmMCQGA1UECxMdQXBwbGUgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkx -FjAUBgNVBAMTDUFwcGxlIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw -ggEKAoIBAQDkkakJH5HbHkdQ6wXtXnmELes2oldMVeyLGYne+Uts9QerIjAC6Bg+ -+FAJ039BqJj50cpmnCRrEdCju+QbKsMflZ56DKRHi1vUFjczy8QPTc4UadHJGXL1 -XQ7Vf1+b8iUDulWPTV0N8WQ1IxVLFVkds5T39pyez1C6wVhQZ48ItCD3y6wsIG9w -tj8BMIy3Q88PnT3zK0koGsj+zrW5DtleHNbLPbU6rfQPDgCSC7EhFi501TwN22IW -q6NxkkdTVcGvL0Gz+PvjcM3mo0xFfh9Ma1CWQYnEdGILEINBhzOKgbEwWOxaBDKM -aLOPHd5lc/9nXmW8Sdh2nzMUZaF3lMktAgMBAAGjggF6MIIBdjAOBgNVHQ8BAf8E -BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUK9BpR5R2Cf70a40uQKb3 -R01/CF4wHwYDVR0jBBgwFoAUK9BpR5R2Cf70a40uQKb3R01/CF4wggERBgNVHSAE -ggEIMIIBBDCCAQAGCSqGSIb3Y2QFATCB8jAqBggrBgEFBQcCARYeaHR0cHM6Ly93 -d3cuYXBwbGUuY29tL2FwcGxlY2EvMIHDBggrBgEFBQcCAjCBthqBs1JlbGlhbmNl -IG9uIHRoaXMgY2VydGlmaWNhdGUgYnkgYW55IHBhcnR5IGFzc3VtZXMgYWNjZXB0 -YW5jZSBvZiB0aGUgdGhlbiBhcHBsaWNhYmxlIHN0YW5kYXJkIHRlcm1zIGFuZCBj -b25kaXRpb25zIG9mIHVzZSwgY2VydGlmaWNhdGUgcG9saWN5IGFuZCBjZXJ0aWZp -Y2F0aW9uIHByYWN0aWNlIHN0YXRlbWVudHMuMA0GCSqGSIb3DQEBBQUAA4IBAQBc -NplMLXi37Yyb3PN3m/J20ncwT8EfhYOFG5k9RzfyqZtAjizUsZAS2L70c5vu0mQP -y3lPNNiiPvl4/2vIB+x9OYOLUyDTOMSxv5pPCmv/K/xZpwUJfBdAVhEedNO3iyM7 -R6PVbyTi69G3cN8PReEnyvFteO3ntRcXqNx+IjXKJdXZD9Zr1KIkIxH3oayPc4Fg -xhtbCS+SsvhESPBgOJ4V9T0mZyCKM2r3DYLP3uujL/lTaltkwGMzd/c6ByxW69oP -IQ7aunMZT7XZNn/Bh1XZp5m5MkL72NVxnn6hUrcbvZNCJBIqxw8dtk2cXmPIS4AX -UKqK1drk/NAJBzewdXUh ------END CERTIFICATE----- -# "Apple Root CA - G2" -# C2 B9 B0 42 DD 57 83 0E 7D 11 7D AC 55 AC 8A E1 -# 94 07 D3 8E 41 D8 8F 32 15 BC 3A 89 04 44 A0 50 ------BEGIN CERTIFICATE----- -MIIFkjCCA3qgAwIBAgIIAeDltYNno+AwDQYJKoZIhvcNAQEMBQAwZzEbMBkGA1UE -AwwSQXBwbGUgUm9vdCBDQSAtIEcyMSYwJAYDVQQLDB1BcHBsZSBDZXJ0aWZpY2F0 -aW9uIEF1dGhvcml0eTETMBEGA1UECgwKQXBwbGUgSW5jLjELMAkGA1UEBhMCVVMw -HhcNMTQwNDMwMTgxMDA5WhcNMzkwNDMwMTgxMDA5WjBnMRswGQYDVQQDDBJBcHBs -ZSBSb290IENBIC0gRzIxJjAkBgNVBAsMHUFwcGxlIENlcnRpZmljYXRpb24gQXV0 -aG9yaXR5MRMwEQYDVQQKDApBcHBsZSBJbmMuMQswCQYDVQQGEwJVUzCCAiIwDQYJ -KoZIhvcNAQEBBQADggIPADCCAgoCggIBANgREkhI2imKScUcx+xuM23+TfvgHN6s -XuI2pyT5f1BrTM65MFQn5bPW7SXmMLYFN14UIhHF6Kob0vuy0gmVOKTvKkmMXT5x -ZgM4+xb1hYjkWpIMBDLyyED7Ul+f9sDx47pFoFDVEovy3d6RhiPw9bZyLgHaC/Yu -OQhfGaFjQQscp5TBhsRTL3b2CtcM0YM/GlMZ81fVJ3/8E7j4ko380yhDPLVoACVd -J2LT3VXdRCCQgzWTxb+4Gftr49wIQuavbfqeQMpOhYV4SbHXw8EwOTKrfl+q04tv -ny0aIWhwZ7Oj8ZhBbZF8+NfbqOdfIRqMM78xdLe40fTgIvS/cjTf94FNcX1RoeKz -8NMoFnNvzcytN31O661A4T+B/fc9Cj6i8b0xlilZ3MIZgIxbdMYs0xBTJh0UT8TU -gWY8h2czJxQI6bR3hDRSj4n4aJgXv8O7qhOTH11UL6jHfPsNFL4VPSQ08prcdUFm -IrQB1guvkJ4M6mL4m1k8COKWNORj3rw31OsMiANDC1CvoDTdUE0V+1ok2Az6DGOe -HwOx4e7hqkP0ZmUoNwIx7wHHHtHMn23KVDpA287PT0aLSmWaasZobNfMmRtHsHLD -d4/E92GcdB/O/WuhwpyUgquUoue9G7q5cDmVF8Up8zlYNPXEpMZ7YLlmQ1A/bmH8 -DvmGqmAMQ0uVAgMBAAGjQjBAMB0GA1UdDgQWBBTEmRNsGAPCe8CjoA1/coB6HHcm -jTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQwF -AAOCAgEAUabz4vS4PZO/Lc4Pu1vhVRROTtHlznldgX/+tvCHM/jvlOV+3Gp5pxy+ -8JS3ptEwnMgNCnWefZKVfhidfsJxaXwU6s+DDuQUQp50DhDNqxq6EWGBeNjxtUVA -eKuowM77fWM3aPbn+6/Gw0vsHzYmE1SGlHKy6gLti23kDKaQwFd1z4xCfVzmMX3z -ybKSaUYOiPjjLUKyOKimGY3xn83uamW8GrAlvacp/fQ+onVJv57byfenHmOZ4VxG -/5IFjPoeIPmGlFYl5bRXOJ3riGQUIUkhOb9iZqmxospvPyFgxYnURTbImHy99v6Z -SYA7LNKmp4gDBDEZt7Y6YUX6yfIjyGNzv1aJMbDZfGKnexWoiIqrOEDCzBL/FePw -N983csvMmOa/orz6JopxVtfnJBtIRD6e/J/JzBrsQzwBvDR4yGn1xuZW7AYJNpDr -FEobXsmII9oDMJELuDY++ee1KG++P+w8j2Ud5cAeh6Squpj9kuNsJnfdBrRkBof0 -Tta6SqoWqPQFZ2aWuuJVecMsXUmPgEkrihLHdoBR37q9ZV0+N0djMenl9MU/S60E -inpxLK8JQzcPqOMyT/RFtm2XNuyE9QoB6he7hY1Ck3DDUOUUi78/w0EP3SIEIwiK -um1xRKtzCTrJ+VKACd+66eYWyi4uTLLT3OUEVLLUNIAytbwPF+E= ------END CERTIFICATE----- -# "Apple Root CA - G3" -# 63 34 3A BF B8 9A 6A 03 EB B5 7E 9B 3F 5F A7 BE -# 7C 4F 5C 75 6F 30 17 B3 A8 C4 88 C3 65 3E 91 79 ------BEGIN CERTIFICATE----- -MIICQzCCAcmgAwIBAgIILcX8iNLFS5UwCgYIKoZIzj0EAwMwZzEbMBkGA1UEAwwS -QXBwbGUgUm9vdCBDQSAtIEczMSYwJAYDVQQLDB1BcHBsZSBDZXJ0aWZpY2F0aW9u -IEF1dGhvcml0eTETMBEGA1UECgwKQXBwbGUgSW5jLjELMAkGA1UEBhMCVVMwHhcN -MTQwNDMwMTgxOTA2WhcNMzkwNDMwMTgxOTA2WjBnMRswGQYDVQQDDBJBcHBsZSBS -b290IENBIC0gRzMxJjAkBgNVBAsMHUFwcGxlIENlcnRpZmljYXRpb24gQXV0aG9y -aXR5MRMwEQYDVQQKDApBcHBsZSBJbmMuMQswCQYDVQQGEwJVUzB2MBAGByqGSM49 -AgEGBSuBBAAiA2IABJjpLz1AcqTtkyJygRMc3RCV8cWjTnHcFBbZDuWmBSp3ZHtf -TjjTuxxEtX/1H7YyYl3J6YRbTzBPEVoA/VhYDKX1DyxNB0cTddqXl5dvMVztK517 -IDvYuVTZXpmkOlEKMaNCMEAwHQYDVR0OBBYEFLuw3qFYM4iapIqZ3r6966/ayySr -MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMAoGCCqGSM49BAMDA2gA -MGUCMQCD6cHEFl4aXTQY2e3v9GwOAEZLuN+yRhHFD/3meoyhpmvOwgPUnPWTxnS4 -at+qIxUCMG1mihDK1A3UT82NQz60imOlM27jbdoXt2QfyFMm+YhidDkLF1vLUagM -6BgD56KyKA== ------END CERTIFICATE----- -# "Apple Root Certificate Authority" -# 0D 83 B6 11 B6 48 A1 A7 5E B8 55 84 00 79 53 75 -# CA D9 2E 26 4E D8 E9 D7 A7 57 C1 F5 EE 2B B2 2D ------BEGIN CERTIFICATE----- -MIIFujCCBKKgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBhjELMAkGA1UEBhMCVVMx -HTAbBgNVBAoTFEFwcGxlIENvbXB1dGVyLCBJbmMuMS0wKwYDVQQLEyRBcHBsZSBD -b21wdXRlciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxKTAnBgNVBAMTIEFwcGxlIFJv -b3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5MB4XDTA1MDIxMDAwMTgxNFoXDTI1MDIx -MDAwMTgxNFowgYYxCzAJBgNVBAYTAlVTMR0wGwYDVQQKExRBcHBsZSBDb21wdXRl -ciwgSW5jLjEtMCsGA1UECxMkQXBwbGUgQ29tcHV0ZXIgQ2VydGlmaWNhdGUgQXV0 -aG9yaXR5MSkwJwYDVQQDEyBBcHBsZSBSb290IENlcnRpZmljYXRlIEF1dGhvcml0 -eTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOSRqQkfkdseR1DrBe1e -eYQt6zaiV0xV7IsZid75S2z1B6siMALoGD74UAnTf0GomPnRymacJGsR0KO75Bsq -wx+VnnoMpEeLW9QWNzPLxA9NzhRp0ckZcvVdDtV/X5vyJQO6VY9NXQ3xZDUjFUsV -WR2zlPf2nJ7PULrBWFBnjwi0IPfLrCwgb3C2PwEwjLdDzw+dPfMrSSgayP7OtbkO -2V4c1ss9tTqt9A8OAJILsSEWLnTVPA3bYharo3GSR1NVwa8vQbP4++NwzeajTEV+ -H0xrUJZBicR0YgsQg0GHM4qBsTBY7FoEMoxos48d3mVz/2deZbxJ2HafMxRloXeU -yS0CAwEAAaOCAi8wggIrMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/ -MB0GA1UdDgQWBBQr0GlHlHYJ/vRrjS5ApvdHTX8IXjAfBgNVHSMEGDAWgBQr0GlH -lHYJ/vRrjS5ApvdHTX8IXjCCASkGA1UdIASCASAwggEcMIIBGAYJKoZIhvdjZAUB -MIIBCTBBBggrBgEFBQcCARY1aHR0cHM6Ly93d3cuYXBwbGUuY29tL2NlcnRpZmlj -YXRlYXV0aG9yaXR5L3Rlcm1zLmh0bWwwgcMGCCsGAQUFBwICMIG2GoGzUmVsaWFu -Y2Ugb24gdGhpcyBjZXJ0aWZpY2F0ZSBieSBhbnkgcGFydHkgYXNzdW1lcyBhY2Nl -cHRhbmNlIG9mIHRoZSB0aGVuIGFwcGxpY2FibGUgc3RhbmRhcmQgdGVybXMgYW5k -IGNvbmRpdGlvbnMgb2YgdXNlLCBjZXJ0aWZpY2F0ZSBwb2xpY3kgYW5kIGNlcnRp -ZmljYXRpb24gcHJhY3RpY2Ugc3RhdGVtZW50cy4wRAYDVR0fBD0wOzA5oDegNYYz -aHR0cHM6Ly93d3cuYXBwbGUuY29tL2NlcnRpZmljYXRlYXV0aG9yaXR5L3Jvb3Qu -Y3JsMFUGCCsGAQUFBwEBBEkwRzBFBggrBgEFBQcwAoY5aHR0cHM6Ly93d3cuYXBw -bGUuY29tL2NlcnRpZmljYXRlYXV0aG9yaXR5L2Nhc2lnbmVycy5odG1sMA0GCSqG -SIb3DQEBBQUAA4IBAQCd2i0oWC99dgS5BNM+zrdmY06PL9T+S61yvaM5xlJNBZhS -9YlRASR5vhoy9+VEi0tEBzmC1lrKtCBe2a4VXR2MHTK/ODFiSF3H4ZCx+CRA+F9Y -m1FdV53B5f88zHIhbsTp6aF31ywXJsM/65roCwO66bNKcuszCVut5mIxauivL9Wv -Hld2j383LS4CXN1jyfJxuCZA3xWNdUQ/eb3mHZnhQyw+rW++uaT+DjUZUWOxw961 -kj5ReAFziqQjyqSI8R5cH0EWLX6VCqrpiUGYGxrdyyC/R14MJsVVNU3GMIuZZxTH -CR+6R8faAQmHJEKVvRNgGQrv6n8Obs3BREM6StXj ------END CERTIFICATE----- -# "Atos TrustedRoot 2011" -# F3 56 BE A2 44 B7 A9 1E B3 5D 53 CA 9A D7 86 4A -# CE 01 8E 2D 35 D5 F8 F9 6D DF 68 A6 F4 1A A4 74 ------BEGIN CERTIFICATE----- -MIIDdzCCAl+gAwIBAgIIXDPLYixfszIwDQYJKoZIhvcNAQELBQAwPDEeMBwGA1UE -AwwVQXRvcyBUcnVzdGVkUm9vdCAyMDExMQ0wCwYDVQQKDARBdG9zMQswCQYDVQQG -EwJERTAeFw0xMTA3MDcxNDU4MzBaFw0zMDEyMzEyMzU5NTlaMDwxHjAcBgNVBAMM -FUF0b3MgVHJ1c3RlZFJvb3QgMjAxMTENMAsGA1UECgwEQXRvczELMAkGA1UEBhMC -REUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCVhTuXbyo7LjvPpvMp -Nb7PGKw+qtn4TaA+Gke5vJrf8v7MPkfoepbCJI419KkM/IL9bcFyYie96mvr54rM -VD6QUM+A1JX76LWC1BTFtqlVJVfbsVD2sGBkWXppzwO3bw2+yj5vdHLqqjAqc2K+ -SZFhyBH+DgMq92og3AIVDV4VavzjgsG1xZ1kCWyjWZgHJ8cblithdHFsQ/H3NYkQ -4J7sVaE3IqKHBAUsR320HLliKWYoyrfhk/WklAOZuXCFteZI6o1Q/NnezG8HDt0L -cp2AMBYHlT8oDv3FdU9T1nSatCQujgKRz3bFmx5VdJx4IbHwLfELn8LVlhgf8FQi -eowHAgMBAAGjfTB7MB0GA1UdDgQWBBSnpQaxLKYJYO7Rl+lwrrw7GWzbITAPBgNV -HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKelBrEspglg7tGX6XCuvDsZbNshMBgG -A1UdIAQRMA8wDQYLKwYBBAGwLQMEAQEwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3 -DQEBCwUAA4IBAQAmdzTblEiGKkGdLD4GkGDEjKwLVLgfuXvTBznk+j57sj1O7Z8j -vZfza1zv7v1Apt+hk6EKhqzvINB5Ab149xnYJDE0BAGmuhWawyfc2E8PzBhj/5kP -DpFrdRbhIfzYJsdHt6bPWHJxfrrhTZVHO8mvbaG0weyJ9rQPOLXiZNwlz6bb65pc -maHFCN795trV1lpFDMS3wrUU77QR/w4VtfX128a961qn8FYiqTxlVMYVqL2Gns2D -lmh6cYGJ4Qvh6hEbaAjMaZ7snkGeRDImeuKHCnE96+RapNLbxc3G3mB/ufNPRJLv -KrcYPqcZ2Qt9sTdBQrC6YB3y/gkRsPCHe6ed ------END CERTIFICATE----- -# "Autoridad de Certificacion Firmaprofesional CIF A62634068" -# 04 04 80 28 BF 1F 28 64 D4 8F 9A D4 D8 32 94 36 -# 6A 82 88 56 55 3F 3B 14 30 3F 90 14 7F 5D 40 EF ------BEGIN CERTIFICATE----- -MIIGFDCCA/ygAwIBAgIIU+w77vuySF8wDQYJKoZIhvcNAQEFBQAwUTELMAkGA1UE -BhMCRVMxQjBABgNVBAMMOUF1dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIEZpcm1h -cHJvZmVzaW9uYWwgQ0lGIEE2MjYzNDA2ODAeFw0wOTA1MjAwODM4MTVaFw0zMDEy -MzEwODM4MTVaMFExCzAJBgNVBAYTAkVTMUIwQAYDVQQDDDlBdXRvcmlkYWQgZGUg -Q2VydGlmaWNhY2lvbiBGaXJtYXByb2Zlc2lvbmFsIENJRiBBNjI2MzQwNjgwggIi -MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKlmuO6vj78aI14H9M2uDDUtd9 -thDIAl6zQyrET2qyyhxdKJp4ERppWVevtSBC5IsP5t9bpgOSL/UR5GLXMnE42QQM -cas9UX4PB99jBVzpv5RvwSmCwLTaUbDBPLutN0pcyvFLNg4kq7/DhHf9qFD0sefG -L9ItWY16Ck6WaVICqjaY7Pz6FIMMNx/Jkjd/14Et5cS54D40/mf0PmbR0/RAz15i -NA9wBj4gGFrO93IbJWyTdBSTo3OxDqqHECNZXyAFGUftaI6SEspd/NYrspI8IM/h -X68gvqB2f3bl7BqGYTM+53u0P6APjqK5am+5hyZvQWyIplD9amML9ZMWGxmPsu2b -m8mQ9QEM3xk9Dz44I8kvjwzRAv4bVdZO0I08r0+k8/6vKtMFnXkIoctXMbScyJCy -Z/QYFpM6/EfY0XiWMR+6KwxfXZmtY4laJCB22N/9q06mIqqdXuYnin1oKaPnirja -EbsXLZmdEyRG98Xi2J+Of8ePdG1asuhy9azuJBCtLxTa/y2aRnFHvkLfuwHb9H/T -KI8xWVvTyQKmtFLKbpf7Q8UIJm+K9Lv9nyiqDdVF8xM6HdjAeI9BZzwelGSuewvF -6NkBiDkal4ZkQdU7hwxu+g/GvUgUvzlN1J5Bto+WHWOWk9mVBngxaJ43BjuAiUVh -OSPHG0SjFeUc+JIwuwIDAQABo4HvMIHsMBIGA1UdEwEB/wQIMAYBAf8CAQEwDgYD -VR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRlzeurNR4APn7VdMActHNHDhpkLzCBpgYD -VR0gBIGeMIGbMIGYBgRVHSAAMIGPMC8GCCsGAQUFBwIBFiNodHRwOi8vd3d3LmZp -cm1hcHJvZmVzaW9uYWwuY29tL2NwczBcBggrBgEFBQcCAjBQHk4AUABhAHMAZQBv -ACAAZABlACAAbABhACAAQgBvAG4AYQBuAG8AdgBhACAANAA3ACAAQgBhAHIAYwBl -AGwAbwBuAGEAIAAwADgAMAAxADcwDQYJKoZIhvcNAQEFBQADggIBABd9oPm03cXF -661LJLWhAqvdpYhKsg9VSytXjDvlMd3+xDLx51tkljYyGOylMnfX40S2wBEqgLk9 -am58m9Ot/MPWo+ZkKXzR4Tgegiv/J2Wv+xYVxC5xhOW1//qkR71kMrv2JYSiJ0L1 -ILDCExARzRAVukKQKtJE4ZYm6zFIEv0q2skGz3QeqUvVhyj5eTSSPi5E6PaPT481 -PyWzOdxjKpBrIF/EUhJOlywqrJ2X3kjyo2bbwtKDlaZmp54lD+kLM5FlClrD2VQS -3a/DTg4fJl4N3LON7NWBcN7STyQF82xO9UxJZo3R/9ILJUFI/lGExkKvgATP0H5k -SeTy36LssUzAKh3ntLFlosS88Zj0qnAHY7S42jtM+kAiMFsRpvAFDsYCA0irhpuF -3dvd6qJ2gHN99ZwExEWN57kci57q13XRcrHedUTnQn3iV2t93Jm8PYMo6oCTjcVM -ZcFwgbg4/EMxsvYDNEeyrPsiBsse3RdHHF9mudMaotoRsaS8I8nkvof/uZS2+F0g -StRf571oe2XyFR7SOqkt6dhrJKyXWERHrVkY8SFlcN7ONGCoQPHzPKTDKCOM/icz -Q0CgFzzr6juwcqajuUpLXhZI9LK8yIySxZ2frHI2vDSANGupi5LAuBft7HZT9SQB -jLMi6Et8Vcad+qMUu2WFbm5PEn4KPJ2V ------END CERTIFICATE----- -# "Autoridad de Certificacion Raiz del Estado Venezolano" -# 0E D3 FF AB 6C 14 9C 8B 4E 71 05 8E 86 68 D4 29 -# AB FD A6 81 C2 FF F5 08 20 76 41 F0 D7 51 A3 E5 ------BEGIN CERTIFICATE----- -MIIJmzCCB4OgAwIBAgIBATANBgkqhkiG9w0BAQwFADCCAR4xPjA8BgNVBAMTNUF1 -dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIFJhaXogZGVsIEVzdGFkbyBWZW5lem9s -YW5vMQswCQYDVQQGEwJWRTEQMA4GA1UEBxMHQ2FyYWNhczEZMBcGA1UECBMQRGlz -dHJpdG8gQ2FwaXRhbDE2MDQGA1UEChMtU2lzdGVtYSBOYWNpb25hbCBkZSBDZXJ0 -aWZpY2FjaW9uIEVsZWN0cm9uaWNhMUMwQQYDVQQLEzpTdXBlcmludGVuZGVuY2lh -IGRlIFNlcnZpY2lvcyBkZSBDZXJ0aWZpY2FjaW9uIEVsZWN0cm9uaWNhMSUwIwYJ -KoZIhvcNAQkBFhZhY3JhaXpAc3VzY2VydGUuZ29iLnZlMB4XDTEwMTIyMjE4MDgy -MVoXDTMwMTIxNzIzNTk1OVowggEeMT4wPAYDVQQDEzVBdXRvcmlkYWQgZGUgQ2Vy -dGlmaWNhY2lvbiBSYWl6IGRlbCBFc3RhZG8gVmVuZXpvbGFubzELMAkGA1UEBhMC -VkUxEDAOBgNVBAcTB0NhcmFjYXMxGTAXBgNVBAgTEERpc3RyaXRvIENhcGl0YWwx -NjA0BgNVBAoTLVNpc3RlbWEgTmFjaW9uYWwgZGUgQ2VydGlmaWNhY2lvbiBFbGVj -dHJvbmljYTFDMEEGA1UECxM6U3VwZXJpbnRlbmRlbmNpYSBkZSBTZXJ2aWNpb3Mg -ZGUgQ2VydGlmaWNhY2lvbiBFbGVjdHJvbmljYTElMCMGCSqGSIb3DQEJARYWYWNy -YWl6QHN1c2NlcnRlLmdvYi52ZTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoC -ggIBAME77xNS8ZlW47RsBeEaaRZhJoZ4rw785UAFCuPZOAVMqNS1wMYqzy95q6Gk -UO81ER/ugiQX/KMcq/4HBn83fwdYWxPZfwBfK7BP2p/JsFgzYeFP0BXOLmvoJIzl -Jb6FW+1MPwGBjuaZGFImWZsSmGUclb51mRYMZETh9/J5CLThR1exStxHQptwSzra -zNFpkQY/zmj7+YZNA9yDoroVFv6sybYOZ7OxNDo7zkSLo45I7gMwtxqWZ8VkJZkC -8+p0dX6mkhUT0QAV64Zc9HsZiH/oLhEkXjhrgZ28cF73MXIqLx1fyM4kPH1yOJi/ -R72nMwL7D+Sd6mZgI035TxuHXc2/uOwXfKrrTjaJDz8Jp6DdessOkxIgkKXRjP+F -K3ze3n4NUIRGhGRtyvEjK95/2g02t6PeYiYVGur6ruS49n0RAaSS0/LJb6XzaAAe -0mmO2evnEqxIKwy2mZRNPfAVW1l3wCnWiUwryBU6OsbFcFFrQm+00wOicXvOTHBM -aiCVAVZTb9RSLyi+LJ1llzJZO3pq3IRiiBj38Nooo+2ZNbMEciSgmig7YXaUcmud -SVQvLSL+Yw+SqawyezwZuASbp7d/0rutQ59d81zlbMt3J7yB567rT2IqIydQ8qBW -k+fmXzghX+/FidYsh/aK+zZ7Wy68kKHuzEw1Vqkat5DGs+VzAgMBAAGjggLeMIIC -2jASBgNVHRMBAf8ECDAGAQH/AgECMDcGA1UdEgQwMC6CD3N1c2NlcnRlLmdvYi52 -ZaAbBgVghl4CAqASDBBSSUYtRy0yMDAwNDAzNi0wMB0GA1UdDgQWBBStuyIdxuDS -Aaj9dlBSk+2YwU2u0zCCAVAGA1UdIwSCAUcwggFDgBStuyIdxuDSAaj9dlBSk+2Y -wU2u06GCASakggEiMIIBHjE+MDwGA1UEAxM1QXV0b3JpZGFkIGRlIENlcnRpZmlj -YWNpb24gUmFpeiBkZWwgRXN0YWRvIFZlbmV6b2xhbm8xCzAJBgNVBAYTAlZFMRAw -DgYDVQQHEwdDYXJhY2FzMRkwFwYDVQQIExBEaXN0cml0byBDYXBpdGFsMTYwNAYD -VQQKEy1TaXN0ZW1hIE5hY2lvbmFsIGRlIENlcnRpZmljYWNpb24gRWxlY3Ryb25p -Y2ExQzBBBgNVBAsTOlN1cGVyaW50ZW5kZW5jaWEgZGUgU2VydmljaW9zIGRlIENl -cnRpZmljYWNpb24gRWxlY3Ryb25pY2ExJTAjBgkqhkiG9w0BCQEWFmFjcmFpekBz -dXNjZXJ0ZS5nb2IudmWCAQEwDgYDVR0PAQH/BAQDAgEGMDcGA1UdEQQwMC6CD3N1 -c2NlcnRlLmdvYi52ZaAbBgVghl4CAqASDBBSSUYtRy0yMDAwNDAzNi0wMFQGA1Ud -HwRNMEswJKAioCCGHmhodHA6Ly93d3cuc3VzY2VydGUuZ29iLnZlL2xjcjAjoCGg -H4YdbGRhcDovL2FjcmFpei5zdXNjZXJ0ZS5nb2IudmUwNwYIKwYBBQUHAQEEKzAp -MCcGCCsGAQUFBzABhhtoaHRwOi8vb2NzcC5zdXNjZXJ0ZS5nb2IudmUwQAYDVR0g -BDkwNzA1BgVghl4BAjAsMCoGCCsGAQUFBwIBFh5odHRwOi8vd3d3LnN1c2NlcnRl -LmdvYi52ZS9kcGMwDQYJKoZIhvcNAQEMBQADggIBAK4qy/zmZ9zBwfW3yOYtLcBT -Oy4szJyPz7/RhNH3bPVH7HbDTGpi6JZ4YXdXMBeJE5qBF4a590Kgj8Rlnltt+Rbo -OFQOU1UDqKuTdBsA//Zry5899fmn8jBUkg4nh09jhHHbLlaUScdz704Zz2+UVg7i -s/r3Legxap60KzmdrmTAE9VKte1TQRgavQwVX5/2mO/J+SCas//UngI+h8SyOucq -mjudYEgBrZaodUsagUfn/+AzFNrGLy+al+5nZeHb8JnCfLHWS0M9ZyhgoeO/czyn -99+5G93VWNv4zfc4KiavHZKrkn8F9pg0ycIZh+OwPT/RE2zq4gTazBMlP3ACIe/p -olkNaOEa8KvgzW96sjBZpMW49zFmyINYkcj+uaNCJrVGsXgdBmkuRGJNWFZ9r0cG -woIaxViFBypsz045r1ESfYPlfDOavBhZ/giR/Xocm9CHkPRY2BApMMR0DUCyGETg -Ql+L3kfdTKzuDjUp2DM9FqysQmaM81YDZufWkMhlZPfHwC7KbNougoLroa5Umeos -bqAXWmk46SwIdWRPLLqbUpDTKooynZKpSYIkkotdgJoVZUUCY+RCO8jsVPEU6ece -SxztNUm5UOta1OJPMwSAKRHOo3ilVb9c6lAixDdvV8MeNbqe6asM1mpCHWbJ/0rg -5Ls9Cxx8hracyp0ev7b0 ------END CERTIFICATE----- -# "Baltimore CyberTrust Root" -# 16 AF 57 A9 F6 76 B0 AB 12 60 95 AA 5E BA DE F2 -# 2A B3 11 19 D6 44 AC 95 CD 4B 93 DB F3 F2 6A EB ------BEGIN CERTIFICATE----- -MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ -RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD -VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX -DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y -ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy -VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr -mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr -IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK -mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu -XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy -dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye -jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1 -BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3 -DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92 -9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx -jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0 -Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz -ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS -R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp ------END CERTIFICATE----- -# "Belgium Root CA2" -# 9F 97 44 46 3B E1 37 14 75 4E 1A 3B EC F9 8C 08 -# CC 20 5E 4A B3 20 28 F4 E2 83 0C 4A 1B 27 75 B8 ------BEGIN CERTIFICATE----- -MIIDjjCCAnagAwIBAgIIKv++n6Lw6YcwDQYJKoZIhvcNAQEFBQAwKDELMAkGA1UE -BhMCQkUxGTAXBgNVBAMTEEJlbGdpdW0gUm9vdCBDQTIwHhcNMDcxMDA0MTAwMDAw -WhcNMjExMjE1MDgwMDAwWjAoMQswCQYDVQQGEwJCRTEZMBcGA1UEAxMQQmVsZ2l1 -bSBSb290IENBMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMZzQh6S -/3UPi790hqc/7bIYLS2X+an7mEoj39WN4IzGMhwWLQdC1i22bi+n9fzGhYJdld61 -IgDMqFNAn68KNaJ6x+HK92AQZw6nUHMXU5WfIp8MXW+2QbyM69odRr2nlL/zGsvU -+40OHjPIltfsjFPekx40HopQcSZYtF3CiInaYNKJIT/e1wEYNm7hLHADBGXvmAYr -XR5i3FVr/mZkIV/4L+HXmymvb82fqgxG0YjFnaKVn6w/Fa7yYd/vw2uaItgscf1Y -HewApDgglVrH1Tdjuk+bqv5WRi5j2Qsj1Yr6tSPwiRuhFA0m2kHwOI8w7QUmecFL -TqG4flVSOmlGhHUCAwEAAaOBuzCBuDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/ -BAUwAwEB/zBCBgNVHSAEOzA5MDcGBWA4CQEBMC4wLAYIKwYBBQUHAgEWIGh0dHA6 -Ly9yZXBvc2l0b3J5LmVpZC5iZWxnaXVtLmJlMB0GA1UdDgQWBBSFiuv0xbu+DlkD -lN7WgAEV4xCcOTARBglghkgBhvhCAQEEBAMCAAcwHwYDVR0jBBgwFoAUhYrr9MW7 -vg5ZA5Te1oABFeMQnDkwDQYJKoZIhvcNAQEFBQADggEBAFHYhd27V2/MoGy1oyCc -UwnzSgEMdL8rs5qauhjyC4isHLMzr87lEwEnkoRYmhC598wUkmt0FoqW6FHvv/pK -JaeJtmMrXZRY0c8RcrYeuTlBFk0pvDVTC9rejg7NqZV3JcqUWumyaa7YwBO+mPyW -nIR/VRPmPIfjvCCkpDZoa01gZhz5v6yAlGYuuUGK02XThIAC71AdXkbc98m6tTR8 -KvPG2F9fVJ3bTc0R5/0UAoNmXsimABKgX77OFP67H6dh96tK8QYUn8pJQsKpvO2F -sauBQeYNxUJpU4c5nUwfAA4+Bw11V0SoU7Q2dmSZ3G7rPUZuFF1eR1ONeE3gJ7uO -hXY= ------END CERTIFICATE----- -# "Buypass Class 2 Root CA" -# 9A 11 40 25 19 7C 5B B9 5D 94 E6 3D 55 CD 43 79 -# 08 47 B6 46 B2 3C DF 11 AD A4 A0 0E FF 15 FB 48 ------BEGIN CERTIFICATE----- -MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd -MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg -Q2xhc3MgMiBSb290IENBMB4XDTEwMTAyNjA4MzgwM1oXDTQwMTAyNjA4MzgwM1ow -TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw -HgYDVQQDDBdCdXlwYXNzIENsYXNzIDIgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB -BQADggIPADCCAgoCggIBANfHXvfBB9R3+0Mh9PT1aeTuMgHbo4Yf5FkNuud1g1Lr -6hxhFUi7HQfKjK6w3Jad6sNgkoaCKHOcVgb/S2TwDCo3SbXlzwx87vFKu3MwZfPV -L4O2fuPn9Z6rYPnT8Z2SdIrkHJasW4DptfQxh6NR/Md+oW+OU3fUl8FVM5I+GC91 -1K2GScuVr1QGbNgGE41b/+EmGVnAJLqBcXmQRFBoJJRfuLMR8SlBYaNByyM21cHx -MlAQTn/0hpPshNOOvEu/XAFOBz3cFIqUCqTqc/sLUegTBxj6DvEr0VQVfTzh97QZ -QmdiXnfgolXsttlpF9U6r0TtSsWe5HonfOV116rLJeffawrbD02TTqigzXsu8lkB -arcNuAeBfos4GzjmCleZPe4h6KP1DBbdi+w0jpwqHAAVF41og9JwnxgIzRFo1clr -Us3ERo/ctfPYV3Me6ZQ5BL/T3jjetFPsaRyifsSP5BtwrfKi+fv3FmRmaZ9JUaLi -FRhnBkp/1Wy1TbMz4GHrXb7pmA8y1x1LPC5aAVKRCfLf6o3YBkBjqhHk/sM3nhRS -P/TizPJhk9H9Z2vXUq6/aKtAQ6BXNVN48FP4YUIHZMbXb5tMOA1jrGKvNouicwoN -9SG9dKpN6nIDSdvHXx1iY8f93ZHsM+71bbRuMGjeyNYmsHVee7QHIJihdjK4TWxP -AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMmAd+BikoL1Rpzz -uvdMw964o605MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAU18h -9bqwOlI5LJKwbADJ784g7wbylp7ppHR/ehb8t/W2+xUbP6umwHJdELFx7rxP462s -A20ucS6vxOOto70MEae0/0qyexAQH6dXQbLArvQsWdZHEIjzIVEpMMpghq9Gqx3t -OluwlN5E40EIosHsHdb9T7bWR9AUC8rmyrV7d35BH16Dx7aMOZawP5aBQW9gkOLo -+fsicdl9sz1Gv7SEr5AcD48Saq/v7h56rgJKihcrdv6sVIkkLE8/trKnToyokZf7 -KcZ7XC25y2a2t6hbElGFtQl+Ynhw/qlqYLYdDnkM/crqJIByw5c/8nerQyIKx+u2 -DISCLIBrQYoIwOula9+ZEsuK1V6ADJHgJgg2SMX6OBE1/yWDLfJ6v9r9jv6ly0Us -H8SIU653DtmadsWOLB2jutXsMq7Aqqz30XpN69QH4kj3Io6wpJ9qzo6ysmD0oyLQ -I+uUWnpp3Q+/QFesa1lQ2aOZ4W7+jQF5JyMV3pKdewlNWudLSDBaGOYKbeaP4NK7 -5t98biGCwWg5TbSYWGZizEqQXsP6JwSxeRV0mcy+rSDeJmAc61ZRpqPq5KM/p/9h -3PFaTWwyI0PurKju7koSCTxdccK+efrCh2gdC/1cacwG0Jp9VJkqyTkaGa9LKkPz -Y11aWOIv4x3kqdbQCtCev9eBCfHJxyYNrJgWVqA= ------END CERTIFICATE----- -# "Buypass Class 3 Root CA" -# ED F7 EB BC A2 7A 2A 38 4D 38 7B 7D 40 10 C6 66 -# E2 ED B4 84 3E 4C 29 B4 AE 1D 5B 93 32 E6 B2 4D ------BEGIN CERTIFICATE----- -MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd -MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg -Q2xhc3MgMyBSb290IENBMB4XDTEwMTAyNjA4Mjg1OFoXDTQwMTAyNjA4Mjg1OFow -TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw -HgYDVQQDDBdCdXlwYXNzIENsYXNzIDMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB -BQADggIPADCCAgoCggIBAKXaCpUWUOOV8l6ddjEGMnqb8RB2uACatVI2zSRHsJ8Y -ZLya9vrVediQYkwiL944PdbgqOkcLNt4EemOaFEVcsfzM4fkoF0LXOBXByow9c3E -N3coTRiR5r/VUv1xLXA+58bEiuPwKAv0dpihi4dVsjoT/Lc+JzeOIuOoTyrvYLs9 -tznDDgFHmV0ST9tD+leh7fmdvhFHJlsTmKtdFoqwNxxXnUX/iJY2v7vKB3tvh2PX -0DJq1l1sDPGzbjniazEuOQAnFN44wOwZZoYS6J1yFhNkUsepNxz9gjDthBgd9K5c -/3ATAOux9TN6S9ZV+AWNS2mw9bMoNlwUxFFzTWsL8TQH2xc519woe2v1n/MuwU8X -KhDzzMro6/1rqy6any2CbgTUUgGTLT2G/H783+9CHaZr77kgxve9oKeV/afmiSTY -zIw0bOIjL9kSGiG5VZFvC5F5GQytQIgLcOJ60g7YaEi7ghM5EFjp2CoHxhLbWNvS -O1UQRwUVZ2J+GGOmRj8JDlQyXr8NYnon74Do29lLBlo3WiXQCBJ31G8JUJc9yB3D -34xFMFbG02SrZvPAXpacw8Tvw3xrizp5f7NJzz3iiZ+gMEuFuZyUJHmPfWupRWgP -K9Dx2hzLabjKSWJtyNBjYt1gD1iqj6G8BaVmos8bdrKEZLFMOVLAMLrwjEsCsLa3 -AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEe4zf/lb+74suwv -Tg75JbCOPGvDMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAACAj -QTUEkMJAYmDv4jVM1z+s4jSQuKFvdvoWFqRINyzpkMLyPPgKn9iB5btb2iUspKdV -cSQy9sgL8rxq+JOssgfCX5/bzMiKqr5qb+FJEMwx14C7u8jYog5kV+qi9cKpMRXS -IGrs/CIBKM+GuIAeqcwRpTzyFrNHnfzSgCHEy9BHcEGhyoMZCCxt8l13nIoUE9Q2 -HJLw5QY33KbmkJs4j1xrG0aGQ0JfPgEHU1RdZX33inOhmlRaHylDFCfChQ+1iHsa -O5S3HWCntZznKWlXWpuTekMwGwPXYshApqr8ZORK15FTAaggiG6cX0S5y2CBNOxv -033aSF/rtJC8LakcC6wc1aJoIIAE1vyxjy+7SjENSoYc6+I2KSb12tjE8nVhz36u -dmNKekBlk4f4HoCMhuWG1o8O/FMsYOgWYRqiPkN7zTlgVGr18okmAWiDSKIz6MkE -kbIRNBE+6tBDGR8Dk5AM/1E9V/RBbuHLoL7ryWPNbczk+DaqaJ3tvV2XcEQNtg41 -3OEMXbugUZTLfhbrES+jkkXITHHZvMmZUldGL1DPvTVp9D0VzgalLA8+9oG6lLvD -u79leNKGef9JOxqDDPDeeOzI8k1MGt6CKfjBWtrt7uYnXuhF0J0cUahoq0Tj0Itq -4/g7u9xN12TyUb7mqqta6THuBrxzvxNiCp/HuZc= ------END CERTIFICATE----- -# "CA Disig Root R1" -# F9 6F 23 F4 C3 E7 9C 07 7A 46 98 8D 5A F5 90 06 -# 76 A0 F0 39 CB 64 5D D1 75 49 B2 16 C8 24 40 CE ------BEGIN CERTIFICATE----- -MIIFaTCCA1GgAwIBAgIJAMMDmu5QkG4oMA0GCSqGSIb3DQEBBQUAMFIxCzAJBgNV -BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu -MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIxMB4XDTEyMDcxOTA5MDY1NloXDTQy -MDcxOTA5MDY1NlowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx -EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjEw -ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCqw3j33Jijp1pedxiy3QRk -D2P9m5YJgNXoqqXinCaUOuiZc4yd39ffg/N4T0Dhf9Kn0uXKE5Pn7cZ3Xza1lK/o -OI7bm+V8u8yN63Vz4STN5qctGS7Y1oprFOsIYgrY3LMATcMjfF9DCCMyEtztDK3A -fQ+lekLZWnDZv6fXARz2m6uOt0qGeKAeVjGu74IKgEH3G8muqzIm1Cxr7X1r5OJe -IgpFy4QxTaz+29FHuvlglzmxZcfe+5nkCiKxLU3lSCZpq+Kq8/v8kiky6bM+TR8n -oc2OuRf7JT7JbvN32g0S9l3HuzYQ1VTW8+DiR0jm3hTaYVKvJrT1cU/J19IG32PK -/yHoWQbgCNWEFVP3Q+V8xaCJmGtzxmjOZd69fwX3se72V6FglcXM6pM6vpmumwKj -rckWtc7dXpl4fho5frLABaTAgqWjR56M6ly2vGfb5ipN0gTco65F97yLnByn1tUD -3AjLLhbKXEAz6GfDLuemROoRRRw1ZS0eRWEkG4IupZ0zXWX4Qfkuy5Q/H6MMMSRE -7cderVC6xkGbrPAXZcD4XW9boAo0PO7X6oifmPmvTiT6l7Jkdtqr9O3jw2Dv1fkC -yC2fg69naQanMVXVz0tv/wQFx1isXxYb5dKj6zHbHzMVTdDypVP1y+E9Tmgt2BLd -qvLmTZtJ5cUoobqwWsagtQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud -DwEB/wQEAwIBBjAdBgNVHQ4EFgQUiQq0OJMa5qvum5EY+fU8PjXQ04IwDQYJKoZI -hvcNAQEFBQADggIBADKL9p1Kyb4U5YysOMo6CdQbzoaz3evUuii+Eq5FLAR0rBNR -xVgYZk2C2tXck8An4b58n1KeElb21Zyp9HWc+jcSjxyT7Ff+Bw+r1RL3D65hXlaA -SfX8MPWbTx9BLxyE04nH4toCdu0Jz2zBuByDHBb6lM19oMgY0sidbvW9adRtPTXo -HqJPYNcHKfyyo6SdbhWSVhlMCrDpfNIZTUJG7L399ldb3Zh+pE3McgODWF3vkzpB -emOqfDqo9ayk0d2iLbYq/J8BjuIQscTK5GfbVSUZP/3oNn6z4eGBrxEWi1CXYBmC -AMBrTXO40RMHPuq2MU/wQppt4hF05ZSsjYSVPCGvxdpHyN85YmLLW1AL14FABZyb -7bq2ix4Eb5YgOe2kfSnbSM6C3NQCjR0EMVrHS/BsYVLXtFHCgWzN4funodKSds+x -DzdYpPJScWc/DIh4gInByLUfkmO+p3qKViwaqKactV2zY9ATIKHrkWzQjX2v3wvk -F7mGnjixlAxYjOBVqjtjbZqJYLhkKpLGN/R+Q0O3c+gB53+XD9fyexn9GtePyfqF -a3qdnom2piiZk4hA9z7NUaPK6u95RyG1/jLix8NRb76AdPCkwzryT+lf3xkK8jsT -Q6wxpLPn6/wY1gGp8yqPNg7rtLG8t0zJa7+h89n07eLw4+1knj0vllJPgFOL ------END CERTIFICATE----- -# "CA Disig Root R2" -# E2 3D 4A 03 6D 7B 70 E9 F5 95 B1 42 20 79 D2 B9 -# 1E DF BB 1F B6 51 A0 63 3E AA 8A 9D C5 F8 07 03 ------BEGIN CERTIFICATE----- -MIIFaTCCA1GgAwIBAgIJAJK4iNuwisFjMA0GCSqGSIb3DQEBCwUAMFIxCzAJBgNV -BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu -MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIyMB4XDTEyMDcxOTA5MTUzMFoXDTQy -MDcxOTA5MTUzMFowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx -EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjIw -ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCio8QACdaFXS1tFPbCw3Oe -NcJxVX6B+6tGUODBfEl45qt5WDza/3wcn9iXAng+a0EE6UG9vgMsRfYvZNSrXaNH -PWSb6WiaxswbP7q+sos0Ai6YVRn8jG+qX9pMzk0DIaPY0jSTVpbLTAwAFjxfGs3I -x2ymrdMxp7zo5eFm1tL7A7RBZckQrg4FY8aAamkw/dLukO8NJ9+flXP04SXabBbe -QTg06ov80egEFGEtQX6sx3dOy1FU+16SGBsEWmjGycT6txOgmLcRK7fWV8x8nhfR -yyX+hk4kLlYMeE2eARKmK6cBZW58Yh2EhN/qwGu1pSqVg8NTEQxzHQuyRpDRQjrO -QG6Vrf/GlK1ul4SOfW+eioANSW1z4nuSHsPzwfPrLgVv2RvPN3YEyLRa5Beny912 -H9AZdugsBbPWnDTYltxhh5EF5EQIM8HauQhl1K6yNg3ruji6DOWbnuuNZt2Zz9aJ -QfYEkoopKW1rOhzndX0CcQ7zwOe9yxndnWCywmZgtrEE7snmhrmaZkCo5xHtgUUD -i/ZnWejBBhG93c+AAk9lQHhcR1DIm+YfgXvkRKhbhZri3lrVx/k6RGZL5DJUfORs -nLMOPReisjQS1n6yqEm70XooQL6iFh/f5DcfEXP7kAplQ6INfPgGAVUzfbANuPT1 -rqVCV3w2EYx7XsQDnYx5nQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud -DwEB/wQEAwIBBjAdBgNVHQ4EFgQUtZn4r7CU9eMg1gqtzk5WpC5uQu0wDQYJKoZI -hvcNAQELBQADggIBACYGXnDnZTPIgm7ZnBc6G3pmsgH2eDtpXi/q/075KMOYKmFM -tCQSin1tERT3nLXK5ryeJ45MGcipvXrA1zYObYVybqjGom32+nNjf7xueQgcnYqf -GopTpti72TVVsRHFqQOzVju5hJMiXn7B9hJSi+osZ7z+Nkz1uM/Rs0mSO9MpDpkb -lvdhuDvEK7Z4bLQjb/D907JedR+Zlais9trhxTF7+9FGs9K8Z7RiVLoJ92Owk6Ka -+elSLotgEqv89WBW7xBci8QaQtyDW2QOy7W81k/BfDxujRNt+3vrMNDcTa/F1bal -TFtxyegxvug4BkihGuLq0t4SOVga/4AOgnXmt8kHbA7v/zjxmHHEt38OFdAlab0i -nSvtBfZGR6ztwPDUO+Ls7pZbkBNOHlY667DvlruWIxG68kOGdGSVyCh13x01utI3 -gzhTODY7z2zp+WsO0PsE6E9312UBeIYMej4hYvF/Y3EMyZ9E26gnonW+boE+18Dr -G5gPcFw0sorMwIUY6256s/daoQe/qUKS82Ail+QUoQebTnbAjn39pCXHR+3/H3Os -zMOl6W8KjptlwlCFtaOgUxLMVYdh84GuEEZhvUQhuMI9dM9+JDX6HAcOmz0iyu8x -L4ysEr3vQCj8KWefshNPZiTEUxnpHikV7+ZtsH8tZ/3zbBt1RqPlShfppNcL ------END CERTIFICATE----- -# "Certigna" -# E3 B6 A2 DB 2E D7 CE 48 84 2F 7A C5 32 41 C7 B7 -# 1D 54 14 4B FB 40 C1 1F 3F 1D 0B 42 F5 EE A1 2D ------BEGIN CERTIFICATE----- -MIIDqDCCApCgAwIBAgIJAP7c4wEPyUj/MA0GCSqGSIb3DQEBBQUAMDQxCzAJBgNV -BAYTAkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hMB4X -DTA3MDYyOTE1MTMwNVoXDTI3MDYyOTE1MTMwNVowNDELMAkGA1UEBhMCRlIxEjAQ -BgNVBAoMCURoaW15b3RpczERMA8GA1UEAwwIQ2VydGlnbmEwggEiMA0GCSqGSIb3 -DQEBAQUAA4IBDwAwggEKAoIBAQDIaPHJ1tazNHUmgh7stL7qXOEm7RFHYeGifBZ4 -QCHkYJ5ayGPhxLGWkv8YbWkj4Sti993iNi+RB7lIzw7sebYs5zRLcAglozyHGxny -gQcPOJAZ0xH+hrTy0V4eHpbNgGzOOzGTtvKg0KmVEn2lmsxryIRWijOp5yIVUxbw -zBfsV1/pogqYCd7jX5xv3EjjhQsVWqa6n6xI4wmy9/Qy3l40vhx4XUJbzg4ij02Q -130yGLMLLGq/jj8UEYkgDncUtT2UCIf3JR7VsmAA7G8qKCVuKj4YYxclPz5EIBb2 -JsglrgVKtOdjLPOMFlN+XPsRGgjBRmKfIrjxwo1p3Po6WAbfAgMBAAGjgbwwgbkw -DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGu3+QTmQtCRZvgHyUtVF9lo53BEw -ZAYDVR0jBF0wW4AUGu3+QTmQtCRZvgHyUtVF9lo53BGhOKQ2MDQxCzAJBgNVBAYT -AkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hggkA/tzj -AQ/JSP8wDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIABzANBgkqhkiG -9w0BAQUFAAOCAQEAhQMeknH2Qq/ho2Ge6/PAD/Kl1NqV5ta+aDY9fm4fTIrv0Q8h -bV6lUmPOEvjvKtpv6zf+EwLHyzs+ImvaYS5/1HI93TDhHkxAGYwP15zRgzB7mFnc -fca5DClMoTOi62c6ZYTTluLtdkVwj7Ur3vkj1kluPBS1xp81HlDQwY9qcEQCYsuu -HWhBp6pX6FOqB9IG9tUUBguRA3UsbHK1YZWaDYu5Def131TN3ubY1gkIl2PlwS6w -t0QmwCbAr1UwnjvVNioZBPRcHv/PLLf/0P2HQBHVESO7SMAhqaQoLf0V+LBOK/Qw -WyH8EZE0vkHve52Xdf+XlcCWWC/qu0bXu+TZLg== ------END CERTIFICATE----- -# "Certinomis - Autorité Racine" -# FC BF E2 88 62 06 F7 2B 27 59 3C 8B 07 02 97 E1 -# 2D 76 9E D1 0E D7 93 07 05 A8 09 8E FF C1 4D 17 ------BEGIN CERTIFICATE----- -MIIFnDCCA4SgAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJGUjET -MBEGA1UEChMKQ2VydGlub21pczEXMBUGA1UECxMOMDAwMiA0MzM5OTg5MDMxJjAk -BgNVBAMMHUNlcnRpbm9taXMgLSBBdXRvcml0w6kgUmFjaW5lMB4XDTA4MDkxNzA4 -Mjg1OVoXDTI4MDkxNzA4Mjg1OVowYzELMAkGA1UEBhMCRlIxEzARBgNVBAoTCkNl -cnRpbm9taXMxFzAVBgNVBAsTDjAwMDIgNDMzOTk4OTAzMSYwJAYDVQQDDB1DZXJ0 -aW5vbWlzIC0gQXV0b3JpdMOpIFJhY2luZTCCAiIwDQYJKoZIhvcNAQEBBQADggIP -ADCCAgoCggIBAJ2Fn4bT46/HsmtuM+Cet0I0VZ35gb5j2CN2DpdUzZlMGvE5x4jY -F1AMnmHawE5V3udauHpOd4cN5bjr+p5eex7Ezyh0x5P1FMYiKAT5kcOrJ3NqDi5N -8y4oH3DfVS9O7cdxbwlyLu3VMpfQ8Vh30WC8Tl7bmoT2R2FFK/ZQpn9qcSdIhDWe -rP5pqZ56XjUl+rSnSTV3lqc2W+HN3yNw2F1MpQiD8aYkOBOo7C+ooWfHpi2GR+6K -/OybDnT0K0kCe5B1jPyZOQE51kqJ5Z52qz6WKDgmi92NjMD2AR5vpTESOH2VwnHu -7XSu5DaiQ3XV8QCb4uTXzEIDS3h65X27uK4uIJPT5GHfceF2Z5c/tt9qc1pkIuVC -28+BA5PY9OMQ4HL2AHCs8MF6DwV/zzRpRbWT5BnbUhYjBYkOjUjkJW+zeL9i9Qf6 -lSTClrLooyPCXQP8w9PlfMl1I9f09bze5N/NgL+RiH2nE7Q5uiy6vdFrzPOlKO1E -nn1So2+WLhl+HPNbxxaOu2B9d2ZHVIIAEWBsMsGoOBvrbpgT1u449fCfDu/+MYHB -0iSVL1N6aaLwD4ZFjliCK0wi1F6g530mJ0jfJUaNSih8hp75mxpZuWW/Bd22Ql09 -5gBIgl4g9xGC3srYn+Y3RyYe63j3YcNBZFgCQfna4NH4+ej9Uji29YnfAgMBAAGj -WzBZMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBQN -jLZh2kS40RR9w759XkjwzspqsDAXBgNVHSAEEDAOMAwGCiqBegFWAgIAAQEwDQYJ -KoZIhvcNAQEFBQADggIBACQ+YAZ+He86PtvqrxyaLAEL9MW12Ukx9F1BjYkMTv9s -ov3/4gbIOZ/xWqndIlgVqIrTseYyCYIDbNc/CMf4uboAbbnW/FIyXaR/pDGUu7ZM -OH8oMDX/nyNTt7buFHAAQCvaR6s0fl6nVjBhK4tDrP22iCj1a7Y+YEq6QpA0Z43q -619FVDsXrIvkxmUP7tCMXWY5zjKn2BCXwH40nJ+U8/aGH88bc62UeYdocMMzpXDn -2NU4lG9jeeu/Cg4I58UvD0KgKxRA/yHgBcUn4YQRE7rWhh1BCxMjidPJC+iKunqj -o3M3NYB9Ergzd0A4wPpeMNLytqOx1qKVl4GbUu1pTP+A5FPbVFsDbVRfsbjvJL1v -nxHDx2TCDyhihWZeGnuyt++uNckZM6i4J9szVb9o4XVIRFb7zdNIu0eJOqxp9YDG -5ERQL1TEqkPFMTFYvZbF6nVsmnWxTfj3l/+WFvKXTej28xH5On2KOG4Ey+HTRRWq -pdEdnV1j6CTmNhTih60bWfVEm/vXd3wfAXBioSAaosUaKPQhA+4u2cGA6rnZgtZb -dsLLO7XSAPCjDuGtbkD326C00EauFddEwk01+dIL8hf2rGbVJLJP0RyZwG71fet0 -BLj5TXcJ17TPBzAJ8bgAVtkXFhYKK4bfjwEZGuW7gmP/vgt2Fl43N+bYdJeimUV5 ------END CERTIFICATE----- -# "Certinomis - Root CA" -# 2A 99 F5 BC 11 74 B7 3C BB 1D 62 08 84 E0 1C 34 -# E5 1C CB 39 78 DA 12 5F 0E 33 26 88 83 BF 41 58 ------BEGIN CERTIFICATE----- -MIIFkjCCA3qgAwIBAgIBATANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJGUjET -MBEGA1UEChMKQ2VydGlub21pczEXMBUGA1UECxMOMDAwMiA0MzM5OTg5MDMxHTAb -BgNVBAMTFENlcnRpbm9taXMgLSBSb290IENBMB4XDTEzMTAyMTA5MTcxOFoXDTMz -MTAyMTA5MTcxOFowWjELMAkGA1UEBhMCRlIxEzARBgNVBAoTCkNlcnRpbm9taXMx -FzAVBgNVBAsTDjAwMDIgNDMzOTk4OTAzMR0wGwYDVQQDExRDZXJ0aW5vbWlzIC0g -Um9vdCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANTMCQosP5L2 -fxSeC5yaah1AMGT9qt8OHgZbn1CF6s2Nq0Nn3rD6foCWnoR4kkjW4znuzuRZWJfl -LieY6pOod5tK8O90gC3rMB+12ceAnGInkYjwSond3IjmFPnVAy//ldu9n+ws+hQV -WZUKxkd8aRi5pwP5ynapz8dvtF4F/u7BUrJ1Mofs7SlmO/NKFoL21prbcpjp3vDF -TKWrteoB4owuZH9kb/2jJZOLyKIOSY008B/sWEUuNKqEUL3nskoTuLAPrjhdsKkb -5nPJWqHZZkCqqU2mNAKthH6yI8H7KsZn9DS2sJVqM09xRLWtwHkziOC/7aOgFLSc -CbAK42C++PhmiM1b8XcF4LVzbsF9Ri6OSyemzTUK/eVNfaoqoynHWmgE6OXWk6Ri -wsXm9E/G+Z8ajYJJGYrKWUM66A0ywfRMEwNvbqY/kXPLynNvEiCL7sCCeN5LLsJJ -wx3tFvYk9CcbXFcx3FXuqB5vbKziRcxXV4p1VxngtViZSTYxPDMBbRZKzbgqg4SG -m/lg0h9tkQPTYKbVPZrdd5A9NaSfD171UkRpucC63M9933zZxKyGIjK8e2uR73r4 -F2iw4lNVYC2vPsKD2NkJK/DAZNuHi5HMkesE/Xa0lZrmFAYb1TQdvtj/dBxThZng -WVJKYe2InmtJiUZ+IFrZ50rlau7SZRFDAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIB -BjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTvkUz1pcMw6C8I6tNxIqSSaHh0 -2TAfBgNVHSMEGDAWgBTvkUz1pcMw6C8I6tNxIqSSaHh02TANBgkqhkiG9w0BAQsF -AAOCAgEAfj1U2iJdGlg+O1QnurrMyOMaauo++RLrVl89UM7g6kgmJs95Vn6RHJk/ -0KGRHCwPT5iVWVO90CLYiF2cN/z7ZMF4jIuaYAnq1fohX9B0ZedQxb8uuQsLrbWw -F6YSjNRieOpWauwK0kDDPAUwPk2Ut59KA9N9J0u2/kTO+hkzGm2kQtHdzMjI1xZS -g081lLMSVX3l4kLr5JyTCcBMWwerx20RoFAXlCOotQqSD7J6wWAsOMwaplv/8gzj -qh8c3LigkyfeY+N/IZ865Z764BNqdeuWXGKRlI5nU7aJ+BIJy29SWwNyhlCVCNSN -h4YVH5Uk2KRvms6knZtt0rJ2BobGVgjF6wnaNsIbW0G+YSrjcOa4pvi2WsS9Iff/ -ql+hbHY5ZtbqTFXhADObE5hjyW/QASAJN1LnDE8+zbz1X5YnpyACleAu6AdBBR8V -btaw5BngDwKTACdyxYvRVB9dSsNAl35VpnzBMwQUAR1JIGkLGZOdblgi90AMRgwj -Y/M50n92Uaf0yKHxDHYiI0ZSKS3io0EHVmmY0gUJvGnHWmHNj4FgFU2A3ZDifcRQ -8ow7bkrHxuaAKzyBvBGAFhAn1/DNP3nMcyrDflOR1m749fPH0FFNjkulW+YZFzvW -gQncItzujrnEj1PhZ7szuIgVRs/taTX/dQ1G885x4cVrhkIGuUE= ------END CERTIFICATE----- -# "Certplus Root CA G1" -# 15 2A 40 2B FC DF 2C D5 48 05 4D 22 75 B3 9C 7F -# CA 3E C0 97 80 78 B0 F0 EA 76 E5 61 A6 C7 43 3E ------BEGIN CERTIFICATE----- -MIIFazCCA1OgAwIBAgISESBVg+QtPlRWhS2DN7cs3EYRMA0GCSqGSIb3DQEBDQUA -MD4xCzAJBgNVBAYTAkZSMREwDwYDVQQKDAhDZXJ0cGx1czEcMBoGA1UEAwwTQ2Vy -dHBsdXMgUm9vdCBDQSBHMTAeFw0xNDA1MjYwMDAwMDBaFw0zODAxMTUwMDAwMDBa -MD4xCzAJBgNVBAYTAkZSMREwDwYDVQQKDAhDZXJ0cGx1czEcMBoGA1UEAwwTQ2Vy -dHBsdXMgUm9vdCBDQSBHMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB -ANpQh7bauKk+nWT6VjOaVj0W5QOVsjQcmm1iBdTYj+eJZJ+622SLZOZ5KmHNr49a -iZFluVj8tANfkT8tEBXgfs+8/H9DZ6itXjYj2JizTfNDnjl8KvzsiNWI7nC9hRYt -6kuJPKNxQv4c/dMcLRC4hlTqQ7jbxofaqK6AJc96Jh2qkbBIb6613p7Y1/oA/caP -0FG7Yn2ksYyy/yARujVjBYZHYEMzkPZHogNPlk2dT8Hq6pyi/jQu3rfKG3akt62f -6ajUeD94/vI4CTYd0hYCyOwqaK/1jpTvLRN6HkJKHRUxrgwEV/xhc/MxVoYxgKDE -EW4wduOU8F8ExKyHcomYxZ3MVwia9Az8fXoFOvpHgDm2z4QTd28n6v+WZxcIbekN -1iNQMLAVdBM+5S//Ds3EC0pd8NgAM0lm66EYfFkuPSi5YXHLtaW6uOrc4nBvCGrc -h2c0798wct3zyT8j/zXhviEpIDCB5BmlIOklynMxdCm+4kLV87ImZsdo/Rmz5yCT -mehd4F6H50boJZwKKSTUzViGUkAksnsPmBIgJPaQbEfIDbsYIC7Z/fyL8inqh3SV -4EJQeIQEQWGw9CEjjy3LKCHyamz0GqbFFLQ3ZU+V/YDI+HLlJWvEYLF7bY5KinPO -WftwenMGE9nTdDckQQoRb5fc5+R+ob0V8rqHDz1oihYHAgMBAAGjYzBhMA4GA1Ud -DwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSowcCbkahDFXxd -Bie0KlHYlwuBsTAfBgNVHSMEGDAWgBSowcCbkahDFXxdBie0KlHYlwuBsTANBgkq -hkiG9w0BAQ0FAAOCAgEAnFZvAX7RvUz1isbwJh/k4DgYzDLDKTudQSk0YcbX8ACh -66Ryj5QXvBMsdbRX7gp8CXrc1cqh0DQT+Hern+X+2B50ioUHj3/MeXrKls3N/U/7 -/SMNkPX0XtPGYX2eEeAC7gkE2Qfdpoq3DIMku4NQkv5gdRE+2J2winq14J2by5BS -S7CTKtQ+FjPlnsZlFT5kOwQ/2wyPX1wdaR+v8+khjPPvl/aatxm2hHSco1S1cE5j -2FddUyGbQJJD+tZ3VTNPZNX70Cxqjm0lpu+F6ALEUz65noe8zDUa3qHpimOHZR4R -Kttjd5cUvpoUmRGywO6wT/gUITJDT5+rosuoD6o7BlXGEilXCNQ314cnrUlZp5Gr -RHpejXDbl85IULFzk/bwg2D5zfHhMf1bfHEhYxQUqq/F3pN+aLHsIqKqkHWetUNy -6mSjhEv9DKgma3GX7lZjZuhCVPnHHd/Qj1vfyDBviP4NxDMcU6ij/UgQ8uQKTuEV -V/xuZDDCVRHc6qnNSlSsKWNEz0pAoNZoWRsz+e86i9sgktxChL8Bq4fA1SCC28a5 -g4VCXA9DO2pJNdWY9BW/+mGBDAkgGNLQFwzLSABQ6XaCjGTXOqAHVcweMcDvOrRl -++O/QmueD6i9a5jc2NvLi6Td11n0bt3+qsOR0C5CB8AMTVPNJLFMWx5R9N/pkvo= ------END CERTIFICATE----- -# "Certplus Root CA G2" -# 6C C0 50 41 E6 44 5E 74 69 6C 4C FB C9 F8 0F 54 -# 3B 7E AB BB 44 B4 CE 6F 78 7C 6A 99 71 C4 2F 17 ------BEGIN CERTIFICATE----- -MIICHDCCAaKgAwIBAgISESDZkc6uo+jF5//pAq/Pc7xVMAoGCCqGSM49BAMDMD4x -CzAJBgNVBAYTAkZSMREwDwYDVQQKDAhDZXJ0cGx1czEcMBoGA1UEAwwTQ2VydHBs -dXMgUm9vdCBDQSBHMjAeFw0xNDA1MjYwMDAwMDBaFw0zODAxMTUwMDAwMDBaMD4x -CzAJBgNVBAYTAkZSMREwDwYDVQQKDAhDZXJ0cGx1czEcMBoGA1UEAwwTQ2VydHBs -dXMgUm9vdCBDQSBHMjB2MBAGByqGSM49AgEGBSuBBAAiA2IABM0PW1aC3/BFGtat -93nwHcmsltaeTpwftEIRyoa/bfuFo8XlGVzX7qY/aWfYeOKmycTbLXku54uNAm8x -Ik0G42ByRZ0OQneezs/lf4WbGOT8zC5y0xaTTsqZY1yhBSpsBqNjMGEwDgYDVR0P -AQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNqDYwJ5jtpMxjwj -FNiPwyCrKGBZMB8GA1UdIwQYMBaAFNqDYwJ5jtpMxjwjFNiPwyCrKGBZMAoGCCqG -SM49BAMDA2gAMGUCMHD+sAvZ94OX7PNVHdTcswYO/jOYnYs5kGuUIe22113WTNch -p+e/IQ8rzfcq3IUHnQIxAIYUFuXcsGXCwI4Un78kFmjlvPl5adytRSv3tjFzzAal -U5ORGpOucGpnutee5WEaXw== ------END CERTIFICATE----- -# "certSIGN ROOT CA" -# EA A9 62 C4 FA 4A 6B AF EB E4 15 19 6D 35 1C CD -# 88 8D 4F 53 F3 FA 8A E6 D7 C4 66 A9 4E 60 42 BB ------BEGIN CERTIFICATE----- -MIIDODCCAiCgAwIBAgIGIAYFFnACMA0GCSqGSIb3DQEBBQUAMDsxCzAJBgNVBAYT -AlJPMREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBD -QTAeFw0wNjA3MDQxNzIwMDRaFw0zMTA3MDQxNzIwMDRaMDsxCzAJBgNVBAYTAlJP -MREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBDQTCC -ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALczuX7IJUqOtdu0KBuqV5Do -0SLTZLrTk+jUrIZhQGpgV2hUhE28alQCBf/fm5oqrl0Hj0rDKH/v+yv6efHHrfAQ -UySQi2bJqIirr1qjAOm+ukbuW3N7LBeCgV5iLKECZbO9xSsAfsT8AzNXDe3i+s5d -RdY4zTW2ssHQnIFKquSyAVwdj1+ZxLGt24gh65AIgoDzMKND5pCCrlUoSe1b16kQ -OA7+j0xbm0bqQfWwCHTD0IgztnzXdN/chNFDDnU5oSVAKOp4yw4sLjmdjItuFhwv -JoIQ4uNllAoEwF73XVv4EOLQunpL+943AAAaWyjj0pxzPjKHmKHJUS/X3qwzs08C -AwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0O -BBYEFOCMm9slSbPxfIbWskKHC9BroNnkMA0GCSqGSIb3DQEBBQUAA4IBAQA+0hyJ -LjX8+HXd5n9liPRyTMks1zJO890ZeUe9jjtbkw9QSSQTaxQGcu8J06Gh40CEyecY -MnQ8SG4Pn0vU9x7Tk4ZkVJdjclDVVc/6IJMCopvDI5NOFlV2oHB5bc0hH88vLbwZ -44gx+FkagQnIl6Z0x2DEW8xXjrJ1/RsCCdtZb3KTafcxQdaIOL+Hsr0Wefmq5L6I -Jd1hJyMctTEHBDa0GpC9oHRxUIltvBTjD4au8as+x6AJzKNI0eDbZOeStc+vckNw -i/nDhDwTqn6Sm1dTk/pwwpEOMfmbZ13pljheX7NzTogVZ96edhBiIL5VaZVDADlN -9u6wWk5JRFRYX0KD ------END CERTIFICATE----- -# "Certum CA" -# D8 E0 FE BC 1D B2 E3 8D 00 94 0F 37 D2 7D 41 34 -# 4D 99 3E 73 4B 99 D5 65 6D 97 78 D4 D8 14 36 24 ------BEGIN CERTIFICATE----- -MIIDDDCCAfSgAwIBAgIDAQAgMA0GCSqGSIb3DQEBBQUAMD4xCzAJBgNVBAYTAlBM -MRswGQYDVQQKExJVbml6ZXRvIFNwLiB6IG8uby4xEjAQBgNVBAMTCUNlcnR1bSBD -QTAeFw0wMjA2MTExMDQ2MzlaFw0yNzA2MTExMDQ2MzlaMD4xCzAJBgNVBAYTAlBM -MRswGQYDVQQKExJVbml6ZXRvIFNwLiB6IG8uby4xEjAQBgNVBAMTCUNlcnR1bSBD -QTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM6xwS7TT3zNJc4YPk/E -jG+AanPIW1H4m9LcuwBcsaD8dQPugfCI7iNS6eYVM42sLQnFdvkrOYCJ5JdLkKWo -ePhzQ3ukYbDYWMzhbGZ+nPMJXlVjhNWo7/OxLjBos8Q82KxujZlakE403Daaj4GI -ULdtlkIJ89eVgw1BS7Bqa/j8D35in2fE7SZfECYPCE/wpFcozo+47UX2bu4lXapu -Ob7kky/ZR6By6/qmW6/KUz/iDsaWVhFu9+lmqSbYf5VT7QqFiLpPKaVCjF62/IUg -AKpoC6EahQGcxEZjgoi2IrHu/qpGWX7PNSzVttpd90gzFFS269lvzs2I1qsb2pY7 -HVkCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEA -uI3O7+cUus/usESSbLQ5PqKEbq24IXfS1HeCh+YgQYHu4vgRt2PRFze+GXYkHAQa -TOs9qmdvLdTN/mUxcMUbpgIKumB7bVjCmkn+YzILa+M6wKyrO7Do0wlRjBCDxjTg -xSvgGrZgFCdsMneMvLJymM/NzD+5yCRCFNZX/OYmQ6kd5YCQzgNUKD73P9P4Te1q -CjqTE5s7FCMTY5w/0YcneeVMUeMBrYVdGjux1XMQpNPyvG5k9VpWkKjHDkx0Dy5x -O/fIR/RpbxXyEV6DHpx8Uq79AtoSqFlnGNu8cN2bsWntgM6JQEhqDjXKKWYVIZQs -6GAqm4VKQPNriiTsBhYscw== ------END CERTIFICATE----- -# "Certum Trusted Network CA" -# 5C 58 46 8D 55 F5 8E 49 7E 74 39 82 D2 B5 00 10 -# B6 D1 65 37 4A CF 83 A7 D4 A3 2D B7 68 C4 40 8E ------BEGIN CERTIFICATE----- -MIIDuzCCAqOgAwIBAgIDBETAMA0GCSqGSIb3DQEBBQUAMH4xCzAJBgNVBAYTAlBM -MSIwIAYDVQQKExlVbml6ZXRvIFRlY2hub2xvZ2llcyBTLkEuMScwJQYDVQQLEx5D -ZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxIjAgBgNVBAMTGUNlcnR1bSBU -cnVzdGVkIE5ldHdvcmsgQ0EwHhcNMDgxMDIyMTIwNzM3WhcNMjkxMjMxMTIwNzM3 -WjB+MQswCQYDVQQGEwJQTDEiMCAGA1UEChMZVW5pemV0byBUZWNobm9sb2dpZXMg -Uy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MSIw -IAYDVQQDExlDZXJ0dW0gVHJ1c3RlZCBOZXR3b3JrIENBMIIBIjANBgkqhkiG9w0B -AQEFAAOCAQ8AMIIBCgKCAQEA4/t9o3K6wvDJFIf1awFO4W5AB7ptJ11/91sts1rH -UV+rpDKmYYe2bg+G0jACl/jXaVehGDldamR5xgFZrDwxSjh80gTSSyjoIF87B6LM -TXPb865Px1bVWqeWifrzq2jUI4ZZJ88JJ7ysbnKDHDBy3+Ci6dLhdHUZvSqeexVU -BBvXQzmtVSjF4hq79MDkrjhJM8x2hZ85RdKknvISjFH4fOQtf/WsX+sWn7Et0brM -kUJ3TCXJkDhv2/DM+44el1k+1WBO5gUo7Ul5E0u6SNsv+XLTOcr+H9g0cvW0QM8x -AcPs3hEtF10fuFDRXhmnad4HMyjKUJX5p1TLVIZQRan5SQIDAQABo0IwQDAPBgNV -HRMBAf8EBTADAQH/MB0GA1UdDgQWBBQIds3LB/8k9sXN7buQvOKEN0Z19zAOBgNV -HQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQEFBQADggEBAKaorSLOAT2mo/9i0Eidi15y -sHhE49wcrwn9I0j6vSrEuVUEtRCjjSfeC4Jj0O7eDDd5QVsisrCaQVymcODU0HfL -I9MA4GxWL+FpDQ3Zqr8hgVDZBqWo/5U30Kr+4rP1mS1FhIrlQgnXdAIv94nYmem8 -J9RHjboNRhx3zxSkHLmkMcScKHQDNP8zGSal6Q10tz6XxnboJ5ajZt3hrvJBW8qY -VoNzcOSGGtIxQbovvi0TWnZvTuhOgQ4/WwMioBK+ZlgRSssDxLQqKi2WF+A5VLxI -03YnnZotBqbJ7DnSq9ufmgsnAjUpsUCV5/nonFWIGUbWtzT1fs45mtk48VH3Tyw= ------END CERTIFICATE----- -# "Certum Trusted Network CA 2" -# B6 76 F2 ED DA E8 77 5C D3 6C B0 F6 3C D1 D4 60 -# 39 61 F4 9E 62 65 BA 01 3A 2F 03 07 B6 D0 B8 04 ------BEGIN CERTIFICATE----- -MIIF0jCCA7qgAwIBAgIQIdbQSk8lD8kyN/yqXhKN6TANBgkqhkiG9w0BAQ0FADCB -gDELMAkGA1UEBhMCUEwxIjAgBgNVBAoTGVVuaXpldG8gVGVjaG5vbG9naWVzIFMu -QS4xJzAlBgNVBAsTHkNlcnR1bSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEkMCIG -A1UEAxMbQ2VydHVtIFRydXN0ZWQgTmV0d29yayBDQSAyMCIYDzIwMTExMDA2MDgz -OTU2WhgPMjA0NjEwMDYwODM5NTZaMIGAMQswCQYDVQQGEwJQTDEiMCAGA1UEChMZ -VW5pemV0byBUZWNobm9sb2dpZXMgUy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRp -ZmljYXRpb24gQXV0aG9yaXR5MSQwIgYDVQQDExtDZXJ0dW0gVHJ1c3RlZCBOZXR3 -b3JrIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC9+Xj45tWA -DGSdhhuWZGc/IjoedQF97/tcZ4zJzFxrqZHmuULlIEub2pt7uZld2ZuAS9eEQCsn -0+i6MLs+CRqnSZXvK0AkwpfHp+6bJe+oCgCXhVqqndwpyeI1B+twTUrWwbNWuKFB -OJvR+zF/j+Bf4bE/D44WSWDXBo0Y+aomEKsq09DRZ40bRr5HMNUuctHFY9rnY3lE -fktjJImGLjQ/KUxSiyqnwOKRKIm5wFv5HdnnJ63/mgKXwcZQkpsCLL2puTRZCr+E -Sv/f/rOf69me4Jgj7KZrdxYq28ytOxykh9xGc14ZYmhFV+SQgkK7QtbwYeDBoz1m -o130GO6IyY0XRSmZMnUCMe4pJshrAua1YkV/NxVaI2iJ1D7eTiew8EAMvE0Xy02i -sx7QBlrd9pPPV3WZ9fqGGmd4s7+W/jTcvedSVuWz5XV710GRBdxdaeOVDUO5/IOW -OZV7bIBaTxNyxtd9KXpEulKkKtVBRgkg/iKgtlswjbyJDNXXcPiHUv3a76xRLgez -Tv7QCdpw75j6VuZt27VXS9zlLCUVyJ4ueE742pyehizKV/Ma5ciSixqClnrDvFAS -adgOWkaLOusm+iPJtrCBvkIApPjW/jAux9JG9uWOdf3yzLnQh1vMBhBgu4M1t15n -3kfsmUjxpKEV/q2MYo45VU85FrmxY53/twIDAQABo0IwQDAPBgNVHRMBAf8EBTAD -AQH/MB0GA1UdDgQWBBS2oVQ5AsOgP46KvPrU+Bym0ToO/TAOBgNVHQ8BAf8EBAMC -AQYwDQYJKoZIhvcNAQENBQADggIBAHGlDs7k6b8/ONWJWsQCYftMxRQXLYtPU2sQ -F/xlhMcQSZDe28cmk4gmb3DWAl45oPePq5a1pRNcgRRtDoGCERuKTsZPpd1iHkTf -CVn0W3cLN+mLIMb4Ck4uWBzrM9DPhmDJ2vuAL55MYIR4PSFk1vtBHxgP58l1cb29 -XN40hz5BsA72udY/CROWFC/emh1auVbONTqwX3BNXuMp8SMoclm2q8KMZiYcdywm -djWLKKdpoPk79SPdhRB0yZADVpHnr7pH1BKXESLjokmUbOe3lEu6LaTaM4tMpkT/ -WjzGHWTYtTHkpjx6qFcL2+1hGsvxznN3Y6SHb0xRONbkX8eftoEq5IVIeVheO/jb -AoJnwTnbw3RLPTYe+SmTiGhbqEQZIfCn6IENLOiTNrQ3ssqwGyZ6miUfmpqAnksq -P/ujmv5zMnHCnsZy4YpoJ/HkD7TETKVhk/iXEAcqMCWpuchxuO9ozC1+9eB+D4Ko -b7a6bINDd82Kkhehnlt4Fj1F4jNy3eFmypnTycUm/Q1oBEauttmbjL4ZvrHG8hnj -XALKLNhvSgfZyTXaQHXyxKcZb55CEJh15pWLYLztxRLXis7VmFxWlgPF7ncGNf/P -5O4/E2Hu29othfDNrp2yGAlFw5Khchf8R7agCyzxxN5DaAhqXzvwdmP7zAYspsbi -DrW5viSP ------END CERTIFICATE----- -# "CFCA EV ROOT" -# 5C C3 D7 8E 4E 1D 5E 45 54 7A 04 E6 87 3E 64 F9 -# 0C F9 53 6D 1C CC 2E F8 00 F3 55 C4 C5 FD 70 FD ------BEGIN CERTIFICATE----- -MIIFjTCCA3WgAwIBAgIEGErM1jANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJD -TjEwMC4GA1UECgwnQ2hpbmEgRmluYW5jaWFsIENlcnRpZmljYXRpb24gQXV0aG9y -aXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJPT1QwHhcNMTIwODA4MDMwNzAxWhcNMjkx -MjMxMDMwNzAxWjBWMQswCQYDVQQGEwJDTjEwMC4GA1UECgwnQ2hpbmEgRmluYW5j -aWFsIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJP -T1QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDXXWvNED8fBVnVBU03 -sQ7smCuOFR36k0sXgiFxEFLXUWRwFsJVaU2OFW2fvwwbwuCjZ9YMrM8irq93VCpL -TIpTUnrD7i7es3ElweldPe6hL6P3KjzJIx1qqx2hp/Hz7KDVRM8Vz3IvHWOX6Jn5 -/ZOkVIBMUtRSqy5J35DNuF++P96hyk0g1CXohClTt7GIH//62pCfCqktQT+x8Rgp -7hZZLDRJGqgG16iI0gNyejLi6mhNbiyWZXvKWfry4t3uMCz7zEasxGPrb382KzRz -EpR/38wmnvFyXVBlWY9ps4deMm/DGIq1lY+wejfeWkU7xzbh72fROdOXW3NiGUgt -hxwG+3SYIElz8AXSG7Ggo7cbcNOIabla1jj0Ytwli3i/+Oh+uFzJlU9fpy25IGvP -a931DfSCt/SyZi4QKPaXWnuWFo8BGS1sbn85WAZkgwGDg8NNkt0yxoekN+kWzqot -aK8KgWU6cMGbrU1tVMoqLUuFG7OA5nBFDWteNfB/O7ic5ARwiRIlk9oKmSJgamNg -TnYGmE69g60dWIolhdLHZR4tjsbftsbhf4oEIRUpdPA+nJCdDC7xij5aqgwJHsfV -PKPtl8MeNPo4+QgO48BdK4PRVmrJtqhUUy54Mmc9gn900PvhtgVguXDbjgv5E1hv -cWAQUhC5wUEJ73IfZzF4/5YFjQIDAQABo2MwYTAfBgNVHSMEGDAWgBTj/i39KNAL -tbq2osS/BqoFjJP7LzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAd -BgNVHQ4EFgQU4/4t/SjQC7W6tqLEvwaqBYyT+y8wDQYJKoZIhvcNAQELBQADggIB -ACXGumvrh8vegjmWPfBEp2uEcwPenStPuiB/vHiyz5ewG5zz13ku9Ui20vsXiObT -ej/tUxPQ4i9qecsAIyjmHjdXNYmEwnZPNDatZ8POQQaIxffu2Bq41gt/UP+TqhdL -jOztUmCypAbqTuv0axn96/Ua4CUqmtzHQTb3yHQFhDmVOdYLO6Qn+gjYXB74BGBS -ESgoA//vU2YApUo0FmZ8/Qmkrp5nGm9BC2sGE5uPhnEFtC+NiWYzKXZUmhH4J/qy -P5Hgzg0b8zAarb8iXRvTvyUFTeGSGn+ZnzxEk8rUQElsgIfXBDrDMlI1Dlb4pd19 -xIsNER9Tyx6yF7Zod1rg1MvIB671Oi6ON7fQAUtDKXeMOZePglr4UeWJoBjnaH9d -Ci77o0cOPaYjesYBx4/IXr9tgFa+iiS6M+qf4TIRnvHST4D2G0CvOJ4RUHlzEhLN -5mydLIhyPDCBBpEi6lmt2hkuIsKNuYyH4Ga8cyNfIWRjgEj1oDwYPZTISEEdQLpe -/v5WOaHIz16eGWRGENoXkbcFgKyLmZJ956LYBws2J+dIeWCKw9cTXPhyQN9Ky8+Z -AAoACxGV2lZFA4gKn2fQ1XmxqI1AbQ3CekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ -5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su ------END CERTIFICATE----- -# "Chambers of Commerce Root" -# 0C 25 8A 12 A5 67 4A EF 25 F2 8B A7 DC FA EC EE -# A3 48 E5 41 E6 F5 CC 4E E6 3B 71 B3 61 60 6A C3 ------BEGIN CERTIFICATE----- -MIIEvTCCA6WgAwIBAgIBADANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJFVTEn -MCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgyNzQzMjg3MSMwIQYDVQQL -ExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEiMCAGA1UEAxMZQ2hhbWJlcnMg -b2YgQ29tbWVyY2UgUm9vdDAeFw0wMzA5MzAxNjEzNDNaFw0zNzA5MzAxNjEzNDRa -MH8xCzAJBgNVBAYTAkVVMScwJQYDVQQKEx5BQyBDYW1lcmZpcm1hIFNBIENJRiBB -ODI3NDMyODcxIzAhBgNVBAsTGmh0dHA6Ly93d3cuY2hhbWJlcnNpZ24ub3JnMSIw -IAYDVQQDExlDaGFtYmVycyBvZiBDb21tZXJjZSBSb290MIIBIDANBgkqhkiG9w0B -AQEFAAOCAQ0AMIIBCAKCAQEAtzZV5aVdGDDg2olUkfzIx1L4L1DZ77F1c2VHfRtb -unXF/KGIJPov7coISjlUxFF6tdpg6jg8gbLL8bvZkSM/SAFwdakFKq0fcfPJVD0d -BmpAPrMMhe5cG3nCYsS4No41XQEMIwRHNaqbYE6gZj3LJgqcQKH0XZi/caulAGgq -7YN6D6IUtdQis4CwPAxaUWktWBiP7Zme8a7ileb2R6jWDA+wWFjbw2Y3npuRVDM3 -0pQcakjJyfKl2qUMI/cjDpwyVV5xnIQFUZot/eZOKjRa3spAN2cMVCFVd9oKDMyX -roDclDZK9D7ONhMeU+SsTjoF7Nuucpw4i9A5O4kKPnf+dQIBA6OCAUQwggFAMBIG -A1UdEwEB/wQIMAYBAf8CAQwwPAYDVR0fBDUwMzAxoC+gLYYraHR0cDovL2NybC5j -aGFtYmVyc2lnbi5vcmcvY2hhbWJlcnNyb290LmNybDAdBgNVHQ4EFgQU45T1sU3p -26EpW1eLTXYGduHRooowDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIA -BzAnBgNVHREEIDAegRxjaGFtYmVyc3Jvb3RAY2hhbWJlcnNpZ24ub3JnMCcGA1Ud -EgQgMB6BHGNoYW1iZXJzcm9vdEBjaGFtYmVyc2lnbi5vcmcwWAYDVR0gBFEwTzBN -BgsrBgEEAYGHLgoDATA+MDwGCCsGAQUFBwIBFjBodHRwOi8vY3BzLmNoYW1iZXJz -aWduLm9yZy9jcHMvY2hhbWJlcnNyb290Lmh0bWwwDQYJKoZIhvcNAQEFBQADggEB -AAxBl8IahsAifJ/7kPMa0QOx7xP5IV8EnNrJpY0nbJaHkb5BkAFyk+cefV/2icZd -p0AJPaxJRUXcLo0waLIJuvvDL8y6C98/d3tGfToSJI6WjzwFCm/SlCgdbQzALogi -1djPHRPH8EjX1wWnz8dHnjs8NMiAT9QUu/wNUPf6s+xCX6ndbcj0dc97wXImsQEc -XCz9ek60AcUFV7nnPKoF2YjpB0ZBzu9Bga5Y34OirsrXdx/nADydb47kMgkdTXg0 -eDQ8lJsm7U9xxhl6vSAiSFr+S30Dt+dYvsYyTnQeaN2oaFuzPu5ifdmA6Ap1erfu -tGWaIZDgqtCYvDi1czyL+Nw= ------END CERTIFICATE----- -# "Chambers of Commerce Root - 2008" -# 06 3E 4A FA C4 91 DF D3 32 F3 08 9B 85 42 E9 46 -# 17 D8 93 D7 FE 94 4E 10 A7 93 7E E2 9D 96 93 C0 ------BEGIN CERTIFICATE----- -MIIHTzCCBTegAwIBAgIJAKPaQn6ksa7aMA0GCSqGSIb3DQEBBQUAMIGuMQswCQYD -VQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3VycmVudCBhZGRyZXNzIGF0 -IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAGA1UEBRMJQTgyNzQzMjg3 -MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xKTAnBgNVBAMTIENoYW1iZXJz -IG9mIENvbW1lcmNlIFJvb3QgLSAyMDA4MB4XDTA4MDgwMTEyMjk1MFoXDTM4MDcz -MTEyMjk1MFowga4xCzAJBgNVBAYTAkVVMUMwQQYDVQQHEzpNYWRyaWQgKHNlZSBj -dXJyZW50IGFkZHJlc3MgYXQgd3d3LmNhbWVyZmlybWEuY29tL2FkZHJlc3MpMRIw -EAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoTEkFDIENhbWVyZmlybWEgUy5BLjEp -MCcGA1UEAxMgQ2hhbWJlcnMgb2YgQ29tbWVyY2UgUm9vdCAtIDIwMDgwggIiMA0G -CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCvAMtwNyuAWko6bHiUfaN/Gh/2NdW9 -28sNRHI+JrKQUrpjOyhYb6WzbZSm891kDFX29ufyIiKAXuFixrYp4YFs8r/lfTJq -VKAyGVn+H4vXPWCGhSRv4xGzdz4gljUha7MI2XAuZPeEklPWDrCQiorjh40G072Q -DuKZoRuGDtqaCrsLYVAGUvGef3bsyw/QHg3PmTA9HMRFEFis1tPo1+XqxQEHd9ZR -5gN/ikilTWh1uem8nk4ZcfUyS5xtYBkL+8ydddy/Js2Pk3g5eXNeJQ7KXOt3EgfL -ZEFHcpOrUMPrCXZkNNI5t3YRCQ12RcSprj1qr7V9ZS+UWBDsXHyvfuK2GNnQm05a -Sd+pZgvMPMZ4fKecHePOjlO+Bd5gD2vlGts/4+EhySnB8esHnFIbAURRPHsl18Tl -UlRdJQfKFiC4reRB7noI/plvg6aRArBsNlVq5331lubKgdaX8ZSD6e2wsWsSaR6s -+12pxZjptFtYer49okQ6Y1nUCyXeG0+95QGezdIp1Z8XGQpvvwyQ0wlf2eOKNcx5 -Wk0ZN5K3xMGtr/R5JJqyAQuxr1yW84Ay+1w9mPGgP0revq+ULtlVmhduYJ1jbLhj -ya6BXBg14JC7vjxPNyK5fuvPnnchpj04gftI2jE9K+OJ9dC1vX7gUMQSibMjmhAx -hduub+84Mxh2EQIDAQABo4IBbDCCAWgwEgYDVR0TAQH/BAgwBgEB/wIBDDAdBgNV -HQ4EFgQU+SSsD7K1+HnA+mCIG8TZTQKeFxkwgeMGA1UdIwSB2zCB2IAU+SSsD7K1 -+HnA+mCIG8TZTQKeFxmhgbSkgbEwga4xCzAJBgNVBAYTAkVVMUMwQQYDVQQHEzpN -YWRyaWQgKHNlZSBjdXJyZW50IGFkZHJlc3MgYXQgd3d3LmNhbWVyZmlybWEuY29t -L2FkZHJlc3MpMRIwEAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoTEkFDIENhbWVy -ZmlybWEgUy5BLjEpMCcGA1UEAxMgQ2hhbWJlcnMgb2YgQ29tbWVyY2UgUm9vdCAt -IDIwMDiCCQCj2kJ+pLGu2jAOBgNVHQ8BAf8EBAMCAQYwPQYDVR0gBDYwNDAyBgRV -HSAAMCowKAYIKwYBBQUHAgEWHGh0dHA6Ly9wb2xpY3kuY2FtZXJmaXJtYS5jb20w -DQYJKoZIhvcNAQEFBQADggIBAJASryI1wqM58C7e6bXpeHxIvj99RZJe6dqxGfwW -PJ+0W2aeaufDuV2I6A+tzyMP3iU6XsxPpcG1Lawk0lgH3qLPaYRgM+gQDROpI9CF -5Y57pp49chNyM/WqfcZjHwj0/gF/JM8rLFQJ3uIrbZLGOU8W6jx+ekbURWpGqOt1 -glanq6B8aBMz9p0w8G8nOSQjKpD9kCk18pPfNKXG9/jvjA9iSnyu0/VU+I22mlaH -FoI6M6taIgj3grrqLuBHmrS1RaMFO9ncLkVAO+rcf+g769HsJtg1pDDFOqxXnrN2 -pSB7+R5KBWIBpih1YJeSDW4+TTdDDZIVnBgizVGZoCkaPF+KMjNbMMeJL0eYD6MD -xvbxrN8y8NmBGuScvfaAFPDRLLmF9dijscilIeUcE5fuDr3fKanvNFNb0+RqE4QG -tjICxFKuItLcsiFCGtpA8CnJ7AoMXOLQusxI0zcKzBIKinmwPQN/aUv0NCB9szTq -jktk9T79syNnFQ0EuPAtwQlRPLJsFfClI9eDdOTlLsn+mCdCxqvGnrDQWzilm1De -fhiYtUU79nm06PcaewaD+9CL2rvHvRirCG88gGtAPxkZumWK5r7VXNM21+9AUiRg -OGcEMeyP84LG3rlV8zsxkVrctQgVrXYlCg17LofiDKYGvCYQbTed7N14jHyAxfDZ -d0jQ ------END CERTIFICATE----- -# "Cisco Root CA 2048" -# 83 27 BC 8C 9D 69 94 7B 3D E3 C2 75 11 53 72 67 -# F5 9C 21 B9 FA 7B 61 3F AF BC CD 53 B7 02 40 00 ------BEGIN CERTIFICATE----- -MIIDQzCCAiugAwIBAgIQX/h7KCtU3I1CoxW1aMmt/zANBgkqhkiG9w0BAQUFADA1 -MRYwFAYDVQQKEw1DaXNjbyBTeXN0ZW1zMRswGQYDVQQDExJDaXNjbyBSb290IENB -IDIwNDgwHhcNMDQwNTE0MjAxNzEyWhcNMjkwNTE0MjAyNTQyWjA1MRYwFAYDVQQK -Ew1DaXNjbyBTeXN0ZW1zMRswGQYDVQQDExJDaXNjbyBSb290IENBIDIwNDgwggEg -MA0GCSqGSIb3DQEBAQUAA4IBDQAwggEIAoIBAQCwmrmrp68Kd6ficba0ZmKUeIhH -xmJVhEAyv8CrLqUccda8bnuoqrpu0hWISEWdovyD0My5jOAmaHBKeN8hF570YQXJ -FcjPFto1YYmUQ6iEqDGYeJu5Tm8sUxJszR2tKyS7McQr/4NEb7Y9JHcJ6r8qqB9q -VvYgDxFUl4F1pyXOWWqCZe+36ufijXWLbvLdT6ZeYpzPEApk0E5tzivMW/VgpSdH -jWn0f84bcN5wGyDWbs2mAag8EtKpP6BrXruOIIt6keO1aO6g58QBdKhTCytKmg9l -Eg6CTY5j/e/rmxrbU6YTYK/CfdfHbBcl1HP7R2RQgYCUTOG/rksc35LtLgXfAgED -o1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUJ/PI -FR5umgIJFq0roIlgX9p7L6owEAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQEF -BQADggEBAJ2dhISjQal8dwy3U8pORFBi71R803UXHOjgxkhLtv5MOhmBVrBW7hmW -Yqpao2TB9k5UM8Z3/sUcuuVdJcr18JOagxEu5sv4dEX+5wW4q+ffy0vhN4TauYuX -cB7w4ovXsNgOnbFp1iqRe6lJT37mjpXYgyc81WhJDtSd9i7rp77rMKSsH0T8lasz -Bvt9YAretIpjsJyp8qS5UwGH0GikJ3+r/+n6yUA4iGe0OcaEb1fJU9u6ju7AQ7L4 -CYNu/2bPPu8Xs1gYJQk0XuPL1hS27PKSb3TkL4Eq1ZKR4OCXPDJoBYVL0fdX4lId -kxpUnwVwwEpxYB5DC2Ae/qPOgRnhCzU= ------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 ------BEGIN CERTIFICATE----- -MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB -gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G -A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV -BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw -MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl -YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P -RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0 -aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3 -UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI -2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8 -Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp -+2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+ -DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O -nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW -/zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g -PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u -QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY -SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv -IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/ -RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4 -zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd -BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB -ZQ== ------END CERTIFICATE----- -# "COMODO ECC Certification Authority" -# 17 93 92 7A 06 14 54 97 89 AD CE 2F 8F 34 F7 F0 -# B6 6D 0F 3A E3 A3 B8 4D 21 EC 15 DB BA 4F AD C7 ------BEGIN CERTIFICATE----- -MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL -MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE -BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT -IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw -MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy -ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N -T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv -biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR -FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J -cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW -BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/ -BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm -fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv -GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY= ------END CERTIFICATE----- -# "COMODO RSA Certification Authority" -# 52 F0 E1 C4 E5 8E C6 29 29 1B 60 31 7F 07 46 71 -# B8 5D 7E A8 0D 5B 07 27 34 63 53 4B 32 B4 02 34 ------BEGIN CERTIFICATE----- -MIIF2DCCA8CgAwIBAgIQTKr5yttjb+Af907YWwOGnTANBgkqhkiG9w0BAQwFADCB -hTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G -A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNV -BAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMTE5 -MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgT -EkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMR -Q09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNh -dGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCR -6FSS0gpWsawNJN3Fz0RndJkrN6N9I3AAcbxT38T6KhKPS38QVr2fcHK3YX/JSw8X -pz3jsARh7v8Rl8f0hj4K+j5c+ZPmNHrZFGvnnLOFoIJ6dq9xkNfs/Q36nGz637CC -9BR++b7Epi9Pf5l/tfxnQ3K9DADWietrLNPtj5gcFKt+5eNu/Nio5JIk2kNrYrhV -/erBvGy2i/MOjZrkm2xpmfh4SDBF1a3hDTxFYPwyllEnvGfDyi62a+pGx8cgoLEf -Zd5ICLqkTqnyg0Y3hOvozIFIQ2dOciqbXL1MGyiKXCJ7tKuY2e7gUYPDCUZObT6Z -+pUX2nwzV0E8jVHtC7ZcryxjGt9XyD+86V3Em69FmeKjWiS0uqlWPc9vqv9JWL7w -qP/0uK3pN/u6uPQLOvnoQ0IeidiEyxPx2bvhiWC4jChWrBQdnArncevPDt09qZah -SL0896+1DSJMwBGB7FY79tOi4lu3sgQiUpWAk2nojkxl8ZEDLXB0AuqLZxUpaVIC -u9ffUGpVRr+goyhhf3DQw6KqLCGqR84onAZFdr+CGCe01a60y1Dma/RMhnEw6abf -Fobg2P9A3fvQQoh/ozM6LlweQRGBY84YcWsr7KaKtzFcOmpH4MN5WdYgGq/yapiq -crxXStJLnbsQ/LBMQeXtHT1eKJ2czL+zUdqnR+WEUwIDAQABo0IwQDAdBgNVHQ4E -FgQUu69+Aj36pvE8hI6t7jiY7NkyMtQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB -/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAArx1UaEt65Ru2yyTUEUAJNMnMvl -wFTPoCWOAvn9sKIN9SCYPBMtrFaisNZ+EZLpLrqeLppysb0ZRGxhNaKatBYSaVqM -4dc+pBroLwP0rmEdEBsqpIt6xf4FpuHA1sj+nq6PK7o9mfjYcwlYRm6mnPTXJ9OV -2jeDchzTc+CiR5kDOF3VSXkAKRzH7JsgHAckaVd4sjn8OoSgtZx8jb8uk2Intzna -FxiuvTwJaP+EmzzV1gsD41eeFPfR60/IvYcjt7ZJQ3mFXLrrkguhxuhoqEwWsRqZ -CuhTLJK7oQkYdQxlqHvLI7cawiiFwxv/0Cti76R7CZGYZ4wUAc1oBmpjIXUDgIiK -boHGhfKppC3n9KUkEEeDys30jXlYsQab5xoq2Z0B15R97QNKyvDb6KkBPvVWmcke -jkk9u+UJueBPSZI9FoJAzMxZxuY67RIuaTxslbH9qh17f4a+Hg4yRvv7E491f0yL -S0Zj/gA0QHDBw7mh3aZw4gSzQbzpgJHqZJx64SIDqZxubw5lT2yHh17zbqD5daWb -QOhTsiedSrnAdyGN/4fy3ryM7xfft0kL0fJuMAsaDk527RH89elWsn2/x20Kk4yl -0MC2Hb46TpSi125sC8KKfPog88Tk5c0NqMuRkrF8hey1FGlmDoLnzc7ILaZRfyHB -NVOFBkpdn627G190 ------END CERTIFICATE----- -# "ComSign CA" -# AE 44 57 B4 0D 9E DA 96 67 7B 0D 3C 92 D5 7B 51 -# 77 AB D7 AC 10 37 95 83 56 D1 E0 94 51 8B E5 F2 ------BEGIN CERTIFICATE----- -MIIDkzCCAnugAwIBAgIQFBOWgxRVjOp7Y+X8NId3RDANBgkqhkiG9w0BAQUFADA0 -MRMwEQYDVQQDEwpDb21TaWduIENBMRAwDgYDVQQKEwdDb21TaWduMQswCQYDVQQG -EwJJTDAeFw0wNDAzMjQxMTMyMThaFw0yOTAzMTkxNTAyMThaMDQxEzARBgNVBAMT -CkNvbVNpZ24gQ0ExEDAOBgNVBAoTB0NvbVNpZ24xCzAJBgNVBAYTAklMMIIBIjAN -BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA8ORUaSvTx49qROR+WCf4C9DklBKK -8Rs4OC8fMZwG1Cyn3gsqrhqg455qv588x26i+YtkbDqthVVRVKU4VbirgwTyP2Q2 -98CNQ0NqZtH3FyrV7zb6MBBC11PN+fozc0yz6YQgitZBJzXkOPqUm7h65HkfM/sb -2CEJKHxNGGleZIp6GZPKfuzzcuc3B1hZKKxC+cX/zT/npfo4sdAMx9lSGlPWgcxC -ejVb7Us6eva1jsz/D3zkYDaHL63woSV9/9JLEYhwVKZBqGdTUkJe5DSe5L6j7Kpi -Xd3DTKaCQeQzC6zJMw9kglcq/QytNuEMrkvF7zuZ2SOzW120V+x0cAwqTwIDAQAB -o4GgMIGdMAwGA1UdEwQFMAMBAf8wPQYDVR0fBDYwNDAyoDCgLoYsaHR0cDovL2Zl -ZGlyLmNvbXNpZ24uY28uaWwvY3JsL0NvbVNpZ25DQS5jcmwwDgYDVR0PAQH/BAQD -AgGGMB8GA1UdIwQYMBaAFEsBmz5WGmU2dst7l6qSBe4y5ygxMB0GA1UdDgQWBBRL -AZs+VhplNnbLe5eqkgXuMucoMTANBgkqhkiG9w0BAQUFAAOCAQEA0Nmlfv4pYEWd -foPPbrxHbvUanlR2QnG0PFg/LUAlQvaBnPGJEMgOqnhPOAlXsDzACPw1jvFIUY0M -cXS6hMTXcpuEfDhOZAYnKuGntewImbQKDdSFc8gS4TXt8QUxHXOZDOuWyt3T5oWq -8Ir7dcHyCTxlZWTzTNity4hp8+SDtwy9F1qWF8pb/627HOkthIDYIb6FUtnUdLlp -hbpN7Sgy6/lhSuTENh4Z3G+EER+V9YMoGKgzkkMn3V0TBEVPh9VGzT2ouvDzuFYk -Res3x+F2T3I5GN9+dHLHcy056mDmrRGiVod7w2ia/viMcKjfZTL0pECMocJEAw6U -AGegcQCCSA== ------END CERTIFICATE----- -# "ComSign Global Root CA" -# 26 05 87 5A FC C1 76 B2 D6 6D D6 6A 99 5D 7F 8D -# 5E BB 86 CE 12 0D 0E 7E 9E 7C 6E F2 94 A2 7D 4C ------BEGIN CERTIFICATE----- -MIIGATCCA+mgAwIBAgIRAI9hcRW6eVgXjH0ROqzW264wDQYJKoZIhvcNAQELBQAw -RTEfMB0GA1UEAxMWQ29tU2lnbiBHbG9iYWwgUm9vdCBDQTEVMBMGA1UEChMMQ29t -U2lnbiBMdGQuMQswCQYDVQQGEwJJTDAeFw0xMTA3MTgxMDI0NTRaFw0zNjA3MTYx -MDI0NTVaMEUxHzAdBgNVBAMTFkNvbVNpZ24gR2xvYmFsIFJvb3QgQ0ExFTATBgNV -BAoTDENvbVNpZ24gTHRkLjELMAkGA1UEBhMCSUwwggIiMA0GCSqGSIb3DQEBAQUA -A4ICDwAwggIKAoICAQCyKClzKh3rm6n1nvigmV/VU1D4hSwYW2ro3VqpzpPo0Ph3 -3LguqjXd5juDwN4mpxTpD99d7Xu5X6KGTlMVtfN+bTbA4t3x7DU0Zqn0BE5XuOgs -3GLH41Vmr5wox1bShVpM+IsjcN4E/hMnDtt/Bkb5s33xCG+ohz5dlq0gA9qfr/g4 -O9lkHZXTCeYrmVzd/il4x79CqNvGkdL3um+OKYl8rg1dPtD8UsytMaDgBAopKR+W -igc16QJzCbvcinlETlrzP/Ny76BWPnAQgaYBULax/Q5thVU+N3sEOKp6uviTdD+X -O6i96gARU4H0xxPFI75PK/YdHrHjfjQevXl4J37FJfPMSHAbgPBhHC+qn/014DOx -46fEGXcdw2BFeIIIwbj2GH70VyJWmuk/xLMCHHpJ/nIF8w25BQtkPpkwESL6esaU -b1CyB4Vgjyf16/0nRiCAKAyC/DY/Yh+rDWtXK8c6QkXD2XamrVJo43DVNFqGZzbf -5bsUXqiVDOz71AxqqK+p4ek9374xPNMJ2rB5MLPAPycwI0bUuLHhLy6nAIFHLhut -TNI+6Y/soYpi5JSaEjcY7pxI8WIkUAzr2r+6UoT0vAdyOt7nt1y8844a7szo/aKf -woziHl2O1w6ZXUC30K+ptXVaOiW79pBDcbLZ9ZdbONhS7Ea3iH4HJNwktrBJLQID -AQABo4HrMIHoMA8GA1UdEwEB/wQFMAMBAf8wgYQGA1UdHwR9MHswPKA6oDiGNmh0 -dHA6Ly9mZWRpci5jb21zaWduLmNvLmlsL2NybC9jb21zaWduZ2xvYmFscm9vdGNh -LmNybDA7oDmgN4Y1aHR0cDovL2NybDEuY29tc2lnbi5jby5pbC9jcmwvY29tc2ln -bmdsb2JhbHJvb3RjYS5jcmwwDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBQCRZPY -DUhirGm6rgZbPvuqJpFQsTAfBgNVHSMEGDAWgBQCRZPYDUhirGm6rgZbPvuqJpFQ -sTANBgkqhkiG9w0BAQsFAAOCAgEAk1V5V9701xsfy4mfX+tP9Ln5e9h3N+QMwUfj -kr+k3e8iXOqADjTpUHeBkEee5tJq09ZLp/43F5tZ2eHdYq2ZEX7iWHCnOQet6Yw9 -SU1TahsrGDA6JJD9sdPFnNZooGsU1520e0zNB0dNWwxrWAmu4RsBxvEpWCJbvzQL -dOfyX85RWwli81OiVMBc5XvJ1mxsIIqli45oRynKtsWP7E+b0ISJ1n+XFLdQo/Nm -WA/5sDfT0F5YPzWdZymudMbXitimxC+n4oQE4mbQ4Zm718Iwg3pP9gMMcSc7Qc1J -kJHPH9O7gVubkKHuSYj9T3Ym6c6egL1pb4pz/uT7cT26Fiopc/jdqbe2EAfoJZkv -hlp/zdzOoXTWjiKNA5zmgWnZn943FuE9KMRyKtyi/ezJXCh8ypnqLIKxeFfZl69C -BwJsPXUTuqj8Fic0s3aZmmr7C4jXycP+Q8V+akMEIoHAxcd960b4wVWKqOcI/kZS -Q0cYqWOY1LNjznRt9lweWEfwDBL3FhrHOmD4++1N3FkkM4W+Q1b2WOL24clDMj+i -2n9Iw0lc1llHMSMvA5D0vpsXZpOgcCVahfXczQKi9wQ3oZyonJeWx4/rXdMtagAB -VBYGFuMEUEQtybI+eIbnp5peO2WAAblQI4eTy/jMVowe5tfMEXovV3sz9ULgmGb3 -DscLP1I= ------END CERTIFICATE----- -# "ComSign Secured CA" -# 50 79 41 C7 44 60 A0 B4 70 86 22 0D 4E 99 32 57 -# 2A B5 D1 B5 BB CB 89 80 AB 1C B1 76 51 A8 44 D2 ------BEGIN CERTIFICATE----- -MIIDqzCCApOgAwIBAgIRAMcoRwmzuGxFjB36JPU2TukwDQYJKoZIhvcNAQEFBQAw -PDEbMBkGA1UEAxMSQ29tU2lnbiBTZWN1cmVkIENBMRAwDgYDVQQKEwdDb21TaWdu -MQswCQYDVQQGEwJJTDAeFw0wNDAzMjQxMTM3MjBaFw0yOTAzMTYxNTA0NTZaMDwx -GzAZBgNVBAMTEkNvbVNpZ24gU2VjdXJlZCBDQTEQMA4GA1UEChMHQ29tU2lnbjEL -MAkGA1UEBhMCSUwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDGtWhf -HZQVw6QIVS3joFd67+l0Kru5fFdJGhFeTymHDEjWaueP1H5XJLkGieQcPOqs49oh -gHMhCu95mGwfCP+hUH3ymBvJVG8+pSjsIQQPRbsHPaHA+iqYHU4Gk/v1iDurX8sW -v+bznkqH7Rnqwp9D5PGBpX8QTz7RSmKtUxvLg/8HZaWSLWapW7ha9B20IZFKF3ue -Mv5WJDmyVIRD9YTC2LxBkMyd1mja6YJQqTtoz7VdApRgFrFD2UNd3V2Hbuq7s8lr -9gOUCXDeFhF6K+h2j0kQmHe5Y1yLM5d19guMsqtb3nQgJT/j8xH5h2iGNXHDHYwt -6+UarA9z1YJZQIDTAgMBAAGjgacwgaQwDAYDVR0TBAUwAwEB/zBEBgNVHR8EPTA7 -MDmgN6A1hjNodHRwOi8vZmVkaXIuY29tc2lnbi5jby5pbC9jcmwvQ29tU2lnblNl -Y3VyZWRDQS5jcmwwDgYDVR0PAQH/BAQDAgGGMB8GA1UdIwQYMBaAFMFL7XC29z58 -ADsAj8c+DkWfHl3sMB0GA1UdDgQWBBTBS+1wtvc+fAA7AI/HPg5Fnx5d7DANBgkq -hkiG9w0BAQUFAAOCAQEAFs/ukhNQq3sUnjO2QiBq1BW9Cav8cujvR3qQrFHBZE7p -iL1DRYHjZiM/EoZNGeQFsOY3wo3aBijJD4mkU6l1P7CW+6tMM1X5eCZGbxs2mPtC -dsGCuY7e+0X5YxtiOzkGynd6qDwJz2w2PQ8KRUtpFhpFfTMDZflScZAmlaxMDPWL -kz/MdXSFmLr/YnpNH4n+rr2UAJm/EaXc4HnFFgt9AmEd6oX5AhVP51qJThRv4zdL -hfXBPGHg/QVBspJ/wx2g0K5SZGBrGMYmnNj1ZOQ2GmKfig8+/21OGVZOIJFsnzQz -OjRXUDpvgV4GxvU+fE6OK85lBi5d0ipTdF7Tbieejw== ------END CERTIFICATE----- -# "D-TRUST Root CA 3 2013" -# A1 A8 6D 04 12 1E B8 7F 02 7C 66 F5 33 03 C2 8E -# 57 39 F9 43 FC 84 B3 8A D6 AF 00 90 35 DD 94 57 ------BEGIN CERTIFICATE----- -MIIEDjCCAvagAwIBAgIDD92sMA0GCSqGSIb3DQEBCwUAMEUxCzAJBgNVBAYTAkRF -MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxHzAdBgNVBAMMFkQtVFJVU1QgUm9vdCBD -QSAzIDIwMTMwHhcNMTMwOTIwMDgyNTUxWhcNMjgwOTIwMDgyNTUxWjBFMQswCQYD -VQQGEwJERTEVMBMGA1UECgwMRC1UcnVzdCBHbWJIMR8wHQYDVQQDDBZELVRSVVNU -IFJvb3QgQ0EgMyAyMDEzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA -xHtCkoIf7O1UmI4SwMoJ35NuOpNcG+QQd55OaYhs9uFp8vabomGxvQcgdJhl8Ywm -CM2oNcqANtFjbehEeoLDbF7eu+g20sRoNoyfMr2EIuDcwu4QRjltr5M5rofmw7wJ -ySxrZ1vZm3Z1TAvgu8XXvD558l++0ZBX+a72Zl8xv9Ntj6e6SvMjZbu376Ml1wrq -WLbviPr6ebJSWNXwrIyhUXQplapRO5AyA58ccnSQ3j3tYdLl4/1kR+W5t0qp9x+u -loYErC/jpIF3t1oW/9gPP/a3eMykr/pbPBJbqFKJcu+I89VEgYaVI5973bzZNO98 -lDyqwEHC451QGsDkGSL8swIDAQABo4IBBTCCAQEwDwYDVR0TAQH/BAUwAwEB/zAd -BgNVHQ4EFgQUP5DIfccVb/Mkj6nDL0uiDyGyL+cwDgYDVR0PAQH/BAQDAgEGMIG+ -BgNVHR8EgbYwgbMwdKByoHCGbmxkYXA6Ly9kaXJlY3RvcnkuZC10cnVzdC5uZXQv -Q049RC1UUlVTVCUyMFJvb3QlMjBDQSUyMDMlMjAyMDEzLE89RC1UcnVzdCUyMEdt -YkgsQz1ERT9jZXJ0aWZpY2F0ZXJldm9jYXRpb25saXN0MDugOaA3hjVodHRwOi8v -Y3JsLmQtdHJ1c3QubmV0L2NybC9kLXRydXN0X3Jvb3RfY2FfM18yMDEzLmNybDAN -BgkqhkiG9w0BAQsFAAOCAQEADlkOWOR0SCNEzzQhtZwUGq2aS7eziG1cqRdw8Cqf -jXv5e4X6xznoEAiwNStfzwLS05zICx7uBVSuN5MECX1sj8J0vPgclL4xAUAt8yQg -t4RVLFzI9XRKEBmLo8ftNdYJSNMOwLo5qLBGArDbxohZwr78e7Erz35ih1WWzAFv -m2chlTWL+BD8cRu3SzdppjvW7IvuwbDzJcmPkn2h6sPKRL8mpXSSnON065102ctN -h9j8tGlsi6BDB2B4l+nZk3zCRrybN1Kj7Yo8E6l7U0tJmhEFLAtuVqwfLoJs4Gln -tQ5tLdnkwBXxP/oYcuEVbSdbLTAoK59ImmQrme/ydUlfXA== ------END CERTIFICATE----- -# "D-TRUST Root Class 3 CA 2 2009" -# 49 E7 A4 42 AC F0 EA 62 87 05 00 54 B5 25 64 B6 -# 50 E4 F4 9E 42 E3 48 D6 AA 38 E0 39 E9 57 B1 C1 ------BEGIN CERTIFICATE----- -MIIEMzCCAxugAwIBAgIDCYPzMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNVBAYTAkRF -MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMMHkQtVFJVU1QgUm9vdCBD -bGFzcyAzIENBIDIgMjAwOTAeFw0wOTExMDUwODM1NThaFw0yOTExMDUwODM1NTha -ME0xCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMM -HkQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgMjAwOTCCASIwDQYJKoZIhvcNAQEB -BQADggEPADCCAQoCggEBANOySs96R+91myP6Oi/WUEWJNTrGa9v+2wBoqOADER03 -UAifTUpolDWzU9GUY6cgVq/eUXjsKj3zSEhQPgrfRlWLJ23DEE0NkVJD2IfgXU42 -tSHKXzlABF9bfsyjxiupQB7ZNoTWSPOSHjRGICTBpFGOShrvUD9pXRl/RcPHAY9R -ySPocq60vFYJfxLLHLGvKZAKyVXMD9O0Gu1HNVpK7ZxzBCHQqr0ME7UAyiZsxGsM -lFqVlNpQmvH/pStmMaTJOKDfHR+4CS7zp+hnUquVH+BGPtikw8paxTGA6Eian5Rp -/hnd2HN8gcqW3o7tszIFZYQ05ub9VxC1X3a/L7AQDcUCAwEAAaOCARowggEWMA8G -A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFP3aFMSfMN4hvR5COfyrYyNJ4PGEMA4G -A1UdDwEB/wQEAwIBBjCB0wYDVR0fBIHLMIHIMIGAoH6gfIZ6bGRhcDovL2RpcmVj -dG9yeS5kLXRydXN0Lm5ldC9DTj1ELVRSVVNUJTIwUm9vdCUyMENsYXNzJTIwMyUy -MENBJTIwMiUyMDIwMDksTz1ELVRydXN0JTIwR21iSCxDPURFP2NlcnRpZmljYXRl -cmV2b2NhdGlvbmxpc3QwQ6BBoD+GPWh0dHA6Ly93d3cuZC10cnVzdC5uZXQvY3Js -L2QtdHJ1c3Rfcm9vdF9jbGFzc18zX2NhXzJfMjAwOS5jcmwwDQYJKoZIhvcNAQEL -BQADggEBAH+X2zDI36ScfSF6gHDOFBJpiBSVYEQBrLLpME+bUMJm2H6NMLVwMeni -acfzcNsgFYbQDfC+rAF1hM5+n02/t2A7nPPKHeJeaNijnZflQGDSNiH+0LS4F9p0 -o3/U37CYAqxva2ssJSRyoWXuJVrl5jLn8t+rSfrzkGkj2wTZ51xY/GXUl77M/C4K -zCUqNQT4YJEVdT1B/yMfGchs64JTBKbkTCJNjYy6zltz7GRUUG3RnFX7acM2w4y8 -PIWmawomDeCTmGCufsYkl4phX5GOZpIJhzbNi5stPvZR1FDUWSi9g/LMKHtThm3Y -Johw1+qRzT65ysCQblrGXnRl11z+o+I= ------END CERTIFICATE----- -# "D-TRUST Root Class 3 CA 2 EV 2009" -# EE C5 49 6B 98 8C E9 86 25 B9 34 09 2E EC 29 08 -# BE D0 B0 F3 16 C2 D4 73 0C 84 EA F1 F3 D3 48 81 ------BEGIN CERTIFICATE----- -MIIEQzCCAyugAwIBAgIDCYP0MA0GCSqGSIb3DQEBCwUAMFAxCzAJBgNVBAYTAkRF -MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNVBAMMIUQtVFJVU1QgUm9vdCBD -bGFzcyAzIENBIDIgRVYgMjAwOTAeFw0wOTExMDUwODUwNDZaFw0yOTExMDUwODUw -NDZaMFAxCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNV -BAMMIUQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgRVYgMjAwOTCCASIwDQYJKoZI -hvcNAQEBBQADggEPADCCAQoCggEBAJnxhDRwui+3MKCOvXwEz75ivJn9gpfSegpn -ljgJ9hBOlSJzmY3aFS3nBfwZcyK3jpgAvDw9rKFs+9Z5JUut8Mxk2og+KbgPCdM0 -3TP1YtHhzRnp7hhPTFiu4h7WDFsVWtg6uMQYZB7jM7K1iXdODL/ZlGsTl28So/6Z -qQTMFexgaDbtCHu39b+T7WYxg4zGcTSHThfqr4uRjRxWQa4iN1438h3Z0S0NL2lR -p75mpoo6Kr3HGrHhFPC+Oh25z1uxav60sUYgovseO3Dvk5h9jHOW8sXvhXCtKSb8 -HgQ+HKDYD8tSg2J87otTlZCpV6LqYQXY+U3EJ/pure3511H3a6UCAwEAAaOCASQw -ggEgMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNOUikxiEyoZLsyvcop9Ntea -HNxnMA4GA1UdDwEB/wQEAwIBBjCB3QYDVR0fBIHVMIHSMIGHoIGEoIGBhn9sZGFw -Oi8vZGlyZWN0b3J5LmQtdHJ1c3QubmV0L0NOPUQtVFJVU1QlMjBSb290JTIwQ2xh -c3MlMjAzJTIwQ0ElMjAyJTIwRVYlMjAyMDA5LE89RC1UcnVzdCUyMEdtYkgsQz1E -RT9jZXJ0aWZpY2F0ZXJldm9jYXRpb25saXN0MEagRKBChkBodHRwOi8vd3d3LmQt -dHJ1c3QubmV0L2NybC9kLXRydXN0X3Jvb3RfY2xhc3NfM19jYV8yX2V2XzIwMDku -Y3JsMA0GCSqGSIb3DQEBCwUAA4IBAQA07XtaPKSUiO8aEXUHL7P+PPoeUSbrh/Yp -3uDx1MYkCenBz1UbtDDZzhr+BlGmFaQt77JLvyAoJUnRpjZ3NOhk31KxEcdzes05 -nsKtjHEh8lprr988TlWvsoRlFIm5d8sqMb7Po23Pb0iUMkZv53GMoKaEGTcH8gNF -CSuGdXzfX2lXANtu2KZyIktQ1HWYVt+3GP9DQ1CuekR78HlR10M9p9OB0/DJT7na -xpeG0ILD5EJt/rDiZE4OJudANCa1CInXCGNjOCd1HjPqbqjdn5lPdE2BiYBL3ZqX -KVwvvoFBuYz/6n1gBp7N1z3TLqMVvKjmJuVvw9y4AyHqnxbxLFS1 ------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 ------BEGIN CERTIFICATE----- -MIIEBDCCAuygAwIBAgIIGHqpqMKWIQwwDQYJKoZIhvcNAQELBQAwYjELMAkGA1UE -BhMCVVMxEzARBgNVBAoTCkFwcGxlIEluYy4xJjAkBgNVBAsTHUFwcGxlIENlcnRp -ZmljYXRpb24gQXV0aG9yaXR5MRYwFAYDVQQDEw1BcHBsZSBSb290IENBMB4XDTEy -MDIwMTIyMTIxNVoXDTI3MDIwMTIyMTIxNVoweTEtMCsGA1UEAwwkRGV2ZWxvcGVy -IElEIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MSYwJAYDVQQLDB1BcHBsZSBDZXJ0 -aWZpY2F0aW9uIEF1dGhvcml0eTETMBEGA1UECgwKQXBwbGUgSW5jLjELMAkGA1UE -BhMCVVMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCJdk8GW5pB7qUj -KwKjX9dzP8A1sIuECj8GJH+nlT/rTw6Tr7QO0Mg+5W0Ysx/oiUe/1wkI5P9WmCkV -55SduTWjCs20wOHiYPTK7Cl4RWlpYGtfipL8niPmOsIiszFPHLrytjRZQu6wqQID -GJEEtrN4LjMfgEUNRW+7Dlpbfzrn2AjXCw4ybfuGNuRsq8QRinCEJqqfRNHxuMZ7 -lBebSPcLWBa6I8WfFTl+yl3DMl8P4FJ/QOq+rAhklVvJGpzlgMofakQcbD7EsCYf -Hex7r16gaj1HqVgSMT8gdihtHRywwk4RaSaLy9bQEYLJTg/xVnTQ2QhLZniiq6yn -4tJMh1nJAgMBAAGjgaYwgaMwHQYDVR0OBBYEFFcX7aLP3HyYoRDg/L6HLSzy4xdU -MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUK9BpR5R2Cf70a40uQKb3R01/ -CF4wLgYDVR0fBCcwJTAjoCGgH4YdaHR0cDovL2NybC5hcHBsZS5jb20vcm9vdC5j -cmwwDgYDVR0PAQH/BAQDAgGGMBAGCiqGSIb3Y2QGAgYEAgUAMA0GCSqGSIb3DQEB -CwUAA4IBAQBCOXRrodzGpI83KoyzHQpEvJUsf7xZuKxh+weQkjK51L87wVA5akR0 -ouxbH3Dlqt1LbBwjcS1f0cWTvu6binBlgp0W4xoQF4ktqM39DHhYSQwofzPuAHob -tHastrW7T9+oG53IGZdKC1ZnL8I+trPEgzrwd210xC4jUe6apQNvYPSlSKcGwrta -4h8fRkV+5Jf1JxC3ICJyb3LaxlB1xT0lj12jAOmfNoxIOY+zO+qQgC6VmmD0eM70 -DgpTPqL6T9geroSVjTK8Vk2J6XgY4KyaQrp6RhuEoonOFOiI0ViL9q5WxCwFKkWv -C9lLqQIPNKyIx2FViUTJJ3MH7oLlTvVw ------END CERTIFICATE----- -# "DigiCert Assured ID Root CA" -# 3E 90 99 B5 01 5E 8F 48 6C 00 BC EA 9D 11 1E E7 -# 21 FA BA 35 5A 89 BC F1 DF 69 56 1E 3D C6 32 5C ------BEGIN CERTIFICATE----- -MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl -MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 -d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv -b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG -EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl -cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi -MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c -JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP -mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+ -wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4 -VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/ -AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB -AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW -BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun -pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC -dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf -fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm -NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx -H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe -+o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g== ------END CERTIFICATE----- -# "DigiCert Assured ID Root G2" -# 7D 05 EB B6 82 33 9F 8C 94 51 EE 09 4E EB FE FA -# 79 53 A1 14 ED B2 F4 49 49 45 2F AB 7D 2F C1 85 ------BEGIN CERTIFICATE----- -MIIDljCCAn6gAwIBAgIQC5McOtY5Z+pnI7/Dr5r0SzANBgkqhkiG9w0BAQsFADBl -MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 -d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv -b3QgRzIwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQG -EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl -cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzIwggEi -MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZ5ygvUj82ckmIkzTz+GoeMVSA -n61UQbVH35ao1K+ALbkKz3X9iaV9JPrjIgwrvJUXCzO/GU1BBpAAvQxNEP4Htecc -biJVMWWXvdMX0h5i89vqbFCMP4QMls+3ywPgym2hFEwbid3tALBSfK+RbLE4E9Hp -EgjAALAcKxHad3A2m67OeYfcgnDmCXRwVWmvo2ifv922ebPynXApVfSr/5Vh88lA -bx3RvpO704gqu52/clpWcTs/1PPRCv4o76Pu2ZmvA9OPYLfykqGxvYmJHzDNw6Yu -YjOuFgJ3RFrngQo8p0Quebg/BLxcoIfhG69Rjs3sLPr4/m3wOnyqi+RnlTGNAgMB -AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQW -BBTOw0q5mVXyuNtgv6l+vVa1lzan1jANBgkqhkiG9w0BAQsFAAOCAQEAyqVVjOPI -QW5pJ6d1Ee88hjZv0p3GeDgdaZaikmkuOGybfQTUiaWxMTeKySHMq2zNixya1r9I -0jJmwYrA8y8678Dj1JGG0VDjA9tzd29KOVPt3ibHtX2vK0LRdWLjSisCx1BL4Gni -lmwORGYQRI+tBev4eaymG+g3NJ1TyWGqolKvSnAWhsI6yLETcDbYz+70CjTVW0z9 -B5yiutkBclzzTcHdDrEcDcRjvq30FPuJ7KJBDkzMyFdA0G4Dqs0MjomZmWzwPDCv -ON9vvKO+KSAnq3T/EyJ43pdSVR6DtVQgA+6uwE9W3jfMw3+qBCe703e4YtsXfJwo -IhNzbM8m9Yop5w== ------END CERTIFICATE----- -# "DigiCert Assured ID Root G3" -# 7E 37 CB 8B 4C 47 09 0C AB 36 55 1B A6 F4 5D B8 -# 40 68 0F BA 16 6A 95 2D B1 00 71 7F 43 05 3F C2 ------BEGIN CERTIFICATE----- -MIICRjCCAc2gAwIBAgIQC6Fa+h3foLVJRK/NJKBs7DAKBggqhkjOPQQDAzBlMQsw -CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu -ZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3Qg -RzMwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQGEwJV -UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu -Y29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzMwdjAQBgcq -hkjOPQIBBgUrgQQAIgNiAAQZ57ysRGXtzbg/WPuNsVepRC0FFfLvC/8QdJ+1YlJf -Zn4f5dwbRXkLzMZTCp2NXQLZqVneAlr2lSoOjThKiknGvMYDOAdfVdp+CW7if17Q -RSAPWXYQ1qAk8C3eNvJsKTmjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/ -BAQDAgGGMB0GA1UdDgQWBBTL0L2p4ZgFUaFNN6KDec6NHSrkhDAKBggqhkjOPQQD -AwNnADBkAjAlpIFFAmsSS3V0T8gj43DydXLefInwz5FyYZ5eEJJZVrmDxxDnOOlY -JjZ91eQ0hjkCMHw2U/Aw5WJjOpnitqM7mzT6HtoQknFekROn3aRukswy1vUhZscv -6pZjamVFkpUBtA== ------END CERTIFICATE----- -# "DigiCert Global Root CA" -# 43 48 A0 E9 44 4C 78 CB 26 5E 05 8D 5E 89 44 B4 -# D8 4F 96 62 BD 26 DB 25 7F 89 34 A4 43 C7 01 61 ------BEGIN CERTIFICATE----- -MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh -MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 -d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD -QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT -MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j -b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG -9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB -CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97 -nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt -43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P -T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4 -gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO -BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR -TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw -DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr -hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg -06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF -PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls -YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk -CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4= ------END CERTIFICATE----- -# "DigiCert Global Root G2" -# CB 3C CB B7 60 31 E5 E0 13 8F 8D D3 9A 23 F9 DE -# 47 FF C3 5E 43 C1 14 4C EA 27 D4 6A 5A B1 CB 5F ------BEGIN CERTIFICATE----- -MIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh -MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 -d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH -MjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT -MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j -b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG -9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI -2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx -1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ -q2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz -tCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ -vIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP -BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV -5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY -1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4 -NeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG -Fdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91 -8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe -pLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl -MrY= ------END CERTIFICATE----- -# "DigiCert Global Root G3" -# 31 AD 66 48 F8 10 41 38 C7 38 F3 9E A4 32 01 33 -# 39 3E 3A 18 CC 02 29 6E F9 7C 2A C9 EF 67 31 D0 ------BEGIN CERTIFICATE----- -MIICPzCCAcWgAwIBAgIQBVVWvPJepDU1w6QP1atFcjAKBggqhkjOPQQDAzBhMQsw -CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu -ZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe -Fw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVTMRUw -EwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x -IDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYF -K4EEACIDYgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FG -fp4tn+6OYwwX7Adw9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPO -Z9wj/wMco+I+o0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAd -BgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNpYim8S8YwCgYIKoZIzj0EAwMDaAAwZQIx -AK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj+Z4y3maTD/HMsQmP3Wyr+mt/ -oAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqpisXRAL34VOKa5Vt8 -sycX ------END CERTIFICATE----- -# "DigiCert High Assurance EV Root CA" -# 74 31 E5 F4 C3 C1 CE 46 90 77 4F 0B 61 E0 54 40 -# 88 3B A9 A0 1E D0 0B A6 AB D7 80 6E D3 B1 18 CF ------BEGIN CERTIFICATE----- -MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs -MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 -d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j -ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL -MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3 -LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug -RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm -+9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW -PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM -xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB -Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3 -hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg -EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF -MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA -FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec -nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z -eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF -hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2 -Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe -vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep -+OkuE6N36B9K ------END CERTIFICATE----- -# "DigiCert Trusted Root G4" -# 55 2F 7B DC F1 A7 AF 9E 6C E6 72 01 7F 4F 12 AB -# F7 72 40 C7 8E 76 1A C2 03 D1 D9 D2 0A C8 99 88 ------BEGIN CERTIFICATE----- -MIIFkDCCA3igAwIBAgIQBZsbV56OITLiOQe9p3d1XDANBgkqhkiG9w0BAQwFADBi -MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 -d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3Qg -RzQwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBiMQswCQYDVQQGEwJV -UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu -Y29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3QgRzQwggIiMA0GCSqG -SIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1KPDAiMGkz7MKnJS7JIT3y -ithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2rsnnyyhHS5F/WBTxSD1If -xp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C8weE5nQ7bXHiLQwb7iDV -ySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBfsXpm7nfISKhmV1efVFiO -DCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGYQJB5w3jHtrHEtWoYOAMQ -jdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8rhsDdV14Ztk6MUSaM0C/ -CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaYdj1ZXUJ2h4mXaXpI8OCi -EhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+wJS00mFt6zPZxd9LBADM -fRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw++hkpjPRiQfhvbfmQ6QY -uKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+NP8m800ERElvlEFDrMcXK -chYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7FwI+isX4KJpn15GkvmB0t -9dmpsh3lGwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB -hjAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wDQYJKoZIhvcNAQEMBQAD -ggIBALth2X2pbL4XxJEbw6GiAI3jZGgPVs93rnD5/ZpKmbnJeFwMDF/k5hQpVgs2 -SV1EY+CtnJYYZhsjDT156W1r1lT40jzBQ0CuHVD1UvyQO7uYmWlrx8GnqGikJ9yd -+SeuMIW59mdNOj6PWTkiU0TryF0Dyu1Qen1iIQqAyHNm0aAFYF/opbSnr6j3bTWc -fFqK1qI4mfN4i/RN0iAL3gTujJtHgXINwBQy7zBZLq7gcfJW5GqXb5JQbZaNaHqa -sjYUegbyJLkJEVDXCLG4iXqEI2FCKeWjzaIgQdfRnGTZ6iahixTXTBmyUEFxPT9N -cCOGDErcgdLMMpSEDQgJlxxPwO5rIHQw0uA5NBCFIRUBCOhVMt5xSdkoF1BN5r5N -0XWs0Mr7QbhDparTwwVETyw2m+L64kW4I1NsBm9nVX9GtUw/bihaeSbSpKhil9Ie -4u1Ki7wb/UdKDd9nZn6yW0HQO+T0O/QEY+nvwlQAUaCKKsnOeMzV6ocEGLPOr0mI -r/OSmbaz5mEP0oUA51Aa5BuVnRmhuZyxm7EAHu/QD09CbMkKvO5D+jpxpchNJqU1 -/YldvIViHTLSoCtU7ZpXwdv6EM8Zt4tKG48BtieVU+i2iW1bvGjUI+iLUaJW+fCm -gKDWHrO8Dw9TdSmq6hN35N6MgSGtBxBHEa2HPQfRdbzP82Z+ ------END CERTIFICATE----- -# "DST Root CA X3" -# 06 87 26 03 31 A7 24 03 D9 09 F1 05 E6 9B CF 0D -# 32 E1 BD 24 93 FF C6 D9 20 6D 11 BC D6 77 07 39 ------BEGIN CERTIFICATE----- -MIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmGLvhAazANBgkqhkiG9w0BAQUFADA/ -MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT -DkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow -PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD -Ew5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB -AN+v6ZdQCINXtMxiZfaQguzH0yxrMMpb7NnDfcdAwRgUi+DoM3ZJKuM/IUmTrE4O -rz5Iy2Xu/NMhD2XSKtkyj4zl93ewEnu1lcCJo6m67XMuegwGMoOifooUMM0RoOEq -OLl5CjH9UL2AZd+3UWODyOKIYepLYYHsUmu5ouJLGiifSKOeDNoJjj4XLh7dIN9b -xiqKqy69cK3FCxolkHRyxXtqqzTWMIn/5WgTe1QLyNau7Fqckh49ZLOMxt+/yUFw -7BZy1SbsOFU5Q9D8/RhcQPGX69Wam40dutolucbY38EVAjqr2m7xPi71XAicPNaD -aeQQmxkqtilX4+U9m5/wAl0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNV -HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFMSnsaR7LHH62+FLkHX/xBVghYkQMA0GCSqG -SIb3DQEBBQUAA4IBAQCjGiybFwBcqR7uKGY3Or+Dxz9LwwmglSBd49lZRNI+DT69 -ikugdB/OEIKcdBodfpga3csTS7MgROSR6cz8faXbauX+5v3gTt23ADq1cEmv8uXr -AvHRAosZy5Q6XkjEGB5YGV8eAlrwDPGxrancWYaLbumR9YbK+rlmM6pZW87ipxZz -R8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5 -JDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo -Ob8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ ------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 ------BEGIN CERTIFICATE----- -MIIGSzCCBDOgAwIBAgIIamg+nFGby1MwDQYJKoZIhvcNAQELBQAwgbIxCzAJBgNV -BAYTAlRSMQ8wDQYDVQQHDAZBbmthcmExQDA+BgNVBAoMN0UtVHXEn3JhIEVCRyBC -aWxpxZ9pbSBUZWtub2xvamlsZXJpIHZlIEhpem1ldGxlcmkgQS7Fni4xJjAkBgNV -BAsMHUUtVHVncmEgU2VydGlmaWthc3lvbiBNZXJrZXppMSgwJgYDVQQDDB9FLVR1 -Z3JhIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTEzMDMwNTEyMDk0OFoXDTIz -MDMwMzEyMDk0OFowgbIxCzAJBgNVBAYTAlRSMQ8wDQYDVQQHDAZBbmthcmExQDA+ -BgNVBAoMN0UtVHXEn3JhIEVCRyBCaWxpxZ9pbSBUZWtub2xvamlsZXJpIHZlIEhp -em1ldGxlcmkgQS7Fni4xJjAkBgNVBAsMHUUtVHVncmEgU2VydGlmaWthc3lvbiBN -ZXJrZXppMSgwJgYDVQQDDB9FLVR1Z3JhIENlcnRpZmljYXRpb24gQXV0aG9yaXR5 -MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA4vU/kwVRHoViVF56C/UY -B4Oufq9899SKa6VjQzm5S/fDxmSJPZQuVIBSOTkHS0vdhQd2h8y/L5VMzH2nPbxH -D5hw+IyFHnSOkm0bQNGZDbt1bsipa5rAhDGvykPL6ys06I+XawGb1Q5KCKpbknSF -Q9OArqGIW66z6l7LFpp3RMih9lRozt6Plyu6W0ACDGQXwLWTzeHxE2bODHnv0ZEo -q1+gElIwcxmOj+GMB6LDu0rw6h8VqO4lzKRG+Bsi77MOQ7osJLjFLFzUHPhdZL3D -k14opz8n8Y4e0ypQBaNV2cvnOVPAmJ6MVGKLJrD3fY185MaeZkJVgkfnsliNZvcH -fC425lAcP9tDJMW/hkd5s3kc91r0E+xs+D/iWR+V7kI+ua2oMoVJl0b+SzGPWsut -dEcf6ZG33ygEIqDUD13ieU/qbIWGvaimzuT6w+Gzrt48Ue7LE3wBf4QOXVGUnhMM -ti6lTPk5cDZvlsouDERVxcr6XQKj39ZkjFqzAQqptQpHF//vkUAqjqFGOjGY5RH8 -zLtJVor8udBhmm9lbObDyz51Sf6Pp+KJxWfXnUYTTjF2OySznhFlhqt/7x3U+Lzn -rFpct1pHXFXOVbQicVtbC/DP3KBhZOqp12gKY6fgDT+gr9Oq0n7vUaDmUStVkhUX -U8u3Zg5mTPj5dUyQ5xJwx0UCAwEAAaNjMGEwHQYDVR0OBBYEFC7j27JJ0JxUeVz6 -Jyr+zE7S6E5UMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAULuPbsknQnFR5 -XPonKv7MTtLoTlQwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4ICAQAF -Nzr0TbdF4kV1JI+2d1LoHNgQk2Xz8lkGpD4eKexd0dCrfOAKkEh47U6YA5n+KGCR -HTAduGN8qOY1tfrTYXbm1gdLymmasoR6d5NFFxWfJNCYExL/u6Au/U5Mh/jOXKqY -GwXgAEZKgoClM4so3O0409/lPun++1ndYYRP0lSWE2ETPo+Aab6TR7U1Q9Jauz1c -77NCR807VRMGsAnb/WP2OogKmW9+4c4bU2pEZiNRCHu8W1Ki/QY3OEBhj0qWuJA3 -+GbHeJAAFS6LrVE1Uweoa2iu+U48BybNCAVwzDk/dr2l02cmAYamU9JgO3xDf1WK -vJUawSg5TB9D0pH0clmKuVb8P7Sd2nCcdlqMQ1DujjByTd//SffGqWfZbawCEeI6 -FiWnWAjLb1NBnEg4R2gz0dfHj9R0IdTDBZB6/86WiLEVKV0jq9BgoRJP3vQXzTLl -yb/IQ639Lo7xr+L0mPoSHyDYwKcMhcWQ9DstliaxLL5Mq+ux0orJ23gTDx4JnW2P -AJ8C2sH6H3p6CcRK5ogql5+Ji/03X186zjhZhkuvcQu02PJwT58yE+Owp1fl2tpD -y4Q08ijE6m30Ku/Ba3ba+367hTzSU8JNvnHhRdH9I2cNE3X7z2VnIp2usAnRCf8d -NL/+I5c30jn6PQ0GC7TbO6Orb1wdtn7os4I07QZcJA== ------END CERTIFICATE----- -# "Echoworx Root CA2" -# 66 39 D1 3C AB 85 DF 1A D9 A2 3C 44 3B 3A 60 90 -# 1E 2B 13 8D 45 6F A7 11 83 57 81 08 88 4E C6 BF ------BEGIN CERTIFICATE----- -MIIE5zCCA8+gAwIBAgIBADANBgkqhkiG9w0BAQUFADCBjTELMAkGA1UEBhMCQ0Ex -EDAOBgNVBAgTB09udGFyaW8xEDAOBgNVBAcTB1Rvcm9udG8xHTAbBgNVBAoTFEVj -aG93b3J4IENvcnBvcmF0aW9uMR8wHQYDVQQLExZDZXJ0aWZpY2F0aW9uIFNlcnZp -Y2VzMRowGAYDVQQDExFFY2hvd29yeCBSb290IENBMjAeFw0wNTEwMDYxMDQ5MTNa -Fw0zMDEwMDcxMDQ5MTNaMIGNMQswCQYDVQQGEwJDQTEQMA4GA1UECBMHT250YXJp -bzEQMA4GA1UEBxMHVG9yb250bzEdMBsGA1UEChMURWNob3dvcnggQ29ycG9yYXRp -b24xHzAdBgNVBAsTFkNlcnRpZmljYXRpb24gU2VydmljZXMxGjAYBgNVBAMTEUVj -aG93b3J4IFJvb3QgQ0EyMIIBIDANBgkqhkiG9w0BAQEFAAOCAQ0AMIIBCAKCAQEA -utU/5BkV15UBf+s+JQruKQxr77s3rjp/RpOtmhHILIiO5gsEWP8MMrfrVEiidjI6 -Qh6ans0KAWc2Dw0/j4qKAQzOSyAZgjcdypNTBZ7muv212DA2Pu41rXqwMrlBrVi/ -KTghfdLlNRu6JrC5y8HarrnRFSKF1Thbzz921kLDRoCi+FVs5eVuK5LvIfkhNAqA -byrTgO3T9zfZgk8upmEkANPDL1+8y7dGPB/d6lk0I5mv8PESKX02TlvwgRSIiTHR -k8++iOPLBWlGp7ZfqTEXkPUZhgrQQvxcrwCUo6mk8TqgxCDP5FgPoHFiPLef5szP -ZLBJDWp7GLyE1PmkQI6WiwIBA6OCAVAwggFMMA8GA1UdEwEB/wQFMAMBAf8wCwYD -VR0PBAQDAgEGMB0GA1UdDgQWBBQ74YEboKs/OyGC1eISrq5QqxSlEzCBugYDVR0j -BIGyMIGvgBQ74YEboKs/OyGC1eISrq5QqxSlE6GBk6SBkDCBjTELMAkGA1UEBhMC -Q0ExEDAOBgNVBAgTB09udGFyaW8xEDAOBgNVBAcTB1Rvcm9udG8xHTAbBgNVBAoT -FEVjaG93b3J4IENvcnBvcmF0aW9uMR8wHQYDVQQLExZDZXJ0aWZpY2F0aW9uIFNl -cnZpY2VzMRowGAYDVQQDExFFY2hvd29yeCBSb290IENBMoIBADBQBgNVHSAESTBH -MEUGCysGAQQB+REKAQMBMDYwNAYIKwYBBQUHAgEWKGh0dHA6Ly93d3cuZWNob3dv -cnguY29tL2NhL3Jvb3QyL2Nwcy5wZGYwDQYJKoZIhvcNAQEFBQADggEBAG+nrPi/ -0RpfEzrj02C6JGPUar4nbjIhcY6N7DWNeqBoUulBSIH/PYGNHYx7/lnJefiixPGE -7TQ5xPgElxb9bK8zoAApO7U33OubqZ7M7DlHnFeCoOoIAZnG1kuwKwD5CXKB2a74 -HzcqNnFW0IsBFCYqrVh/rQgJOzDA8POGbH0DeD0xjwBBooAolkKT+7ZItJF1Pb56 -QpDL9G+16F7GkmnKlAIYT3QTS3yFGYChnJcd+6txUPhKi9sSOOmAIaKHnkH9Scz+ -A2cSi4A3wUYXVatuVNHpRb2lygfH3SuCX9MU8Ure3zBlSU1LALtMqI4JmcQmQpIq -zIzvO2jHyu9PQqo= ------END CERTIFICATE----- -# "EE Certification Centre Root CA" -# 3E 84 BA 43 42 90 85 16 E7 75 73 C0 99 2F 09 79 -# CA 08 4E 46 85 68 1F F1 95 CC BA 8A 22 9B 8A 76 ------BEGIN CERTIFICATE----- -MIIEAzCCAuugAwIBAgIQVID5oHPtPwBMyonY43HmSjANBgkqhkiG9w0BAQUFADB1 -MQswCQYDVQQGEwJFRTEiMCAGA1UECgwZQVMgU2VydGlmaXRzZWVyaW1pc2tlc2t1 -czEoMCYGA1UEAwwfRUUgQ2VydGlmaWNhdGlvbiBDZW50cmUgUm9vdCBDQTEYMBYG -CSqGSIb3DQEJARYJcGtpQHNrLmVlMCIYDzIwMTAxMDMwMTAxMDMwWhgPMjAzMDEy -MTcyMzU5NTlaMHUxCzAJBgNVBAYTAkVFMSIwIAYDVQQKDBlBUyBTZXJ0aWZpdHNl -ZXJpbWlza2Vza3VzMSgwJgYDVQQDDB9FRSBDZXJ0aWZpY2F0aW9uIENlbnRyZSBS -b290IENBMRgwFgYJKoZIhvcNAQkBFglwa2lAc2suZWUwggEiMA0GCSqGSIb3DQEB -AQUAA4IBDwAwggEKAoIBAQDIIMDs4MVLqwd4lfNE7vsLDP90jmG7sWLqI9iroWUy -euuOF0+W2Ap7kaJjbMeMTC55v6kF/GlclY1i+blw7cNRfdCT5mzrMEvhvH2/UpvO -bntl8jixwKIy72KyaOBhU8E2lf/slLo2rpwcpzIP5Xy0xm90/XsY6KxX7QYgSzIw -WFv9zajmofxwvI6Sc9uXp3whrj3B9UiHbCe9nyV0gVWw93X2PaRka9ZP585ArQ/d -MtO8ihJTmMmJ+xAdTX7Nfh9WDSFwhfYggx/2uh8Ej+p3iDXE/+pOoYtNP2MbRMNE -1CV2yreN1x5KZmTNXMWcg+HCCIia7E6j8T4cLNlsHaFLAgMBAAGjgYowgYcwDwYD -VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBLyWj7qVhy/ -zQas8fElyalL1BSZMEUGA1UdJQQ+MDwGCCsGAQUFBwMCBggrBgEFBQcDAQYIKwYB -BQUHAwMGCCsGAQUFBwMEBggrBgEFBQcDCAYIKwYBBQUHAwkwDQYJKoZIhvcNAQEF -BQADggEBAHv25MANqhlHt01Xo/6tu7Fq1Q+e2+RjxY6hUFaTlrg4wCQiZrxTFGGV -v9DHKpY5P30osxBAIWrEr7BSdxjhlthWXePdNl4dp1BUoMUq5KqMlIpPnTX/dqQG -E5Gion0ARD9V04I8GtVbvFZMIi5GQ4okQC3zErg7cBqklrkar4dBGmoYDQZPxz5u -uSlNDUmJEYcyW+ZLBMjkXOZ0c5RdFpgTlf7727FE5TpwrDdr5rMzcijJs1eg9gIW -iAYLtqZLICjU3j2LrTcFU3T+bsy8QxdxXvnFzBqpYe73dgzzcvRyrc9yAjYHR8/v -GVCJYMzpJJUPwssd8m92kMfMdcGWxZ0= ------END CERTIFICATE----- -# "Entrust Root Certification Authority" -# 73 C1 76 43 4F 1B C6 D5 AD F4 5B 0E 76 E7 27 28 -# 7C 8D E5 76 16 C1 E6 E6 14 1A 2B 2C BC 7D 8E 4C ------BEGIN CERTIFICATE----- -MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC -VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0 -Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW -KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl -cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw -NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw -NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy -ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV -BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ -KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo -Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4 -4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9 -KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI -rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi -94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB -sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi -gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo -kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE -vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA -A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t -O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua -AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP -9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/ -eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m -0vdXcDazv/wor3ElhVsT/h5/WrQ8 ------END CERTIFICATE----- -# "Entrust Root Certification Authority - EC1" -# 02 ED 0E B2 8C 14 DA 45 16 5C 56 67 91 70 0D 64 -# 51 D7 FB 56 F0 B2 AB 1D 3B 8E B0 70 E5 6E DF F5 ------BEGIN CERTIFICATE----- -MIIC+TCCAoCgAwIBAgINAKaLeSkAAAAAUNCR+TAKBggqhkjOPQQDAzCBvzELMAkG -A1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3 -d3cuZW50cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDEyIEVu -dHJ1c3QsIEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEzMDEGA1UEAxMq -RW50cnVzdCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRUMxMB4XDTEy -MTIxODE1MjUzNloXDTM3MTIxODE1NTUzNlowgb8xCzAJBgNVBAYTAlVTMRYwFAYD -VQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1c3QubmV0 -L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxMiBFbnRydXN0LCBJbmMuIC0g -Zm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMzAxBgNVBAMTKkVudHJ1c3QgUm9vdCBD -ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEVDMTB2MBAGByqGSM49AgEGBSuBBAAi -A2IABIQTydC6bUF74mzQ61VfZgIaJPRbiWlH47jCffHyAsWfoPZb1YsGGYZPUxBt -ByQnoaD41UcZYUx9ypMn6nQM72+WCf5j7HBdNq1nd67JnXxVRDqiY1Ef9eNi1KlH -Bz7MIKNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O -BBYEFLdj5xrdjekIplWDpOBqUEFlEUJJMAoGCCqGSM49BAMDA2cAMGQCMGF52OVC -R98crlOZF7ZvHH3hvxGU0QOIdeSNiaSKd0bebWHvAvX7td/M/k7//qnmpwIwW5nX -hTcGtXsI/esni0qU+eH6p44mCOh8kmhtc9hvJqwhAriZtyZBWyVgrtBIGu4G ------END CERTIFICATE----- -# "Entrust Root Certification Authority - G2" -# 43 DF 57 74 B0 3E 7F EF 5F E4 0D 93 1A 7B ED F1 -# BB 2E 6B 42 73 8C 4E 6D 38 41 10 3D 3A A7 F3 39 ------BEGIN CERTIFICATE----- -MIIEPjCCAyagAwIBAgIESlOMKDANBgkqhkiG9w0BAQsFADCBvjELMAkGA1UEBhMC -VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50 -cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3Qs -IEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVz -dCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzIwHhcNMDkwNzA3MTcy -NTU0WhcNMzAxMjA3MTc1NTU0WjCBvjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUVu -dHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50cnVzdC5uZXQvbGVnYWwt -dGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3QsIEluYy4gLSBmb3IgYXV0 -aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVzdCBSb290IENlcnRpZmlj -YXRpb24gQXV0aG9yaXR5IC0gRzIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK -AoIBAQC6hLZy254Ma+KZ6TABp3bqMriVQRrJ2mFOWHLP/vaCeb9zYQYKpSfYs1/T -RU4cctZOMvJyig/3gxnQaoCAAEUesMfnmr8SVycco2gvCoe9amsOXmXzHHfV1IWN -cCG0szLni6LVhjkCsbjSR87kyUnEO6fe+1R9V77w6G7CebI6C1XiUJgWMhNcL3hW -wcKUs/Ja5CeanyTXxuzQmyWC48zCxEXFjJd6BmsqEZ+pCm5IO2/b1BEZQvePB7/1 -U1+cPvQXLOZprE4yTGJ36rfo5bs0vBmLrpxR57d+tVOxMyLlbc9wPBr64ptntoP0 -jaWvYkxN4FisZDQSA/i2jZRjJKRxAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAP -BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqciZ60B7vfec7aVHUbI2fkBJmqzAN -BgkqhkiG9w0BAQsFAAOCAQEAeZ8dlsa2eT8ijYfThwMEYGprmi5ZiXMRrEPR9RP/ -jTkrwPK9T3CMqS/qF8QLVJ7UG5aYMzyorWKiAHarWWluBh1+xLlEjZivEtRh2woZ -Rkfz6/djwUAFQKXSt/S1mja/qYh2iARVBCuch38aNzx+LaUa2NSJXsq9rD1s2G2v -1fN2D807iDginWyTmsQ9v4IbZT+mD12q/OWyFcq1rca8PdCE6OoGcrBNOTJ4vz4R -nAuknZoh8/CbCzB428Hch0P+vGOaysXCHMnHjf87ElgI5rY97HosTvuDls4MPGmH -VHOkc8KT/1EQrBVUAdj8BbGJoX90g5pJ19xOe4pIb4tF9g== ------END CERTIFICATE----- -# "Entrust.net Certification Authority (2048)" -# 6D C4 71 72 E0 1C BC B0 BF 62 58 0D 89 5F E2 B8 -# AC 9A D4 F8 73 80 1E 0C 10 B9 C8 37 D2 1E B1 77 ------BEGIN CERTIFICATE----- -MIIEKjCCAxKgAwIBAgIEOGPe+DANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML -RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp -bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5 -IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp -ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0yOTA3 -MjQxNDE1MTJaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3 -LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp -YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG -A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp -MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq -K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe -sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX -MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT -XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/ -HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH -4QIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV -HQ4EFgQUVeSB0RGAvtiJuQijMfmhJAkWuXAwDQYJKoZIhvcNAQEFBQADggEBADub -j1abMOdTmXx6eadNl9cZlZD7Bh/KM3xGY4+WZiT6QBshJ8rmcnPyT/4xmf3IDExo -U8aAghOY+rat2l098c5u9hURlIIM7j+VrxGrD9cv3h8Dj1csHsm7mhpElesYT6Yf -zX1XEC+bBAlahLVu2B064dae0Wx5XnkcFMXj0EyTO2U87d89vqbllRrDtRnDvV5b -u/8j72gZyxKTJ1wDLW8w0B62GqzeWvfRqqgnpv55gcR5mTNXuhKwqeBCbJPKVt7+ -bYQLCIt+jerXmCHG8+c8eS9enNFMFY3h7CI3zJpDC5fcgJCNs2ebb0gIFVbPv/Er -fF6adulZkMV8gzURZVE= ------END CERTIFICATE----- -# "ePKI Root Certification Authority" -# C0 A6 F4 DC 63 A2 4B FD CF 54 EF 2A 6A 08 2A 0A -# 72 DE 35 80 3E 2F F5 FF 52 7A E5 D8 72 06 DF D5 ------BEGIN CERTIFICATE----- -MIIFsDCCA5igAwIBAgIQFci9ZUdcr7iXAF7kBtK8nTANBgkqhkiG9w0BAQUFADBe -MQswCQYDVQQGEwJUVzEjMCEGA1UECgwaQ2h1bmdod2EgVGVsZWNvbSBDby4sIEx0 -ZC4xKjAoBgNVBAsMIWVQS0kgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe -Fw0wNDEyMjAwMjMxMjdaFw0zNDEyMjAwMjMxMjdaMF4xCzAJBgNVBAYTAlRXMSMw -IQYDVQQKDBpDaHVuZ2h3YSBUZWxlY29tIENvLiwgTHRkLjEqMCgGA1UECwwhZVBL -SSBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIICIjANBgkqhkiG9w0BAQEF -AAOCAg8AMIICCgKCAgEA4SUP7o3biDN1Z82tH306Tm2d0y8U82N0ywEhajfqhFAH -SyZbCUNsIZ5qyNUD9WBpj8zwIuQf5/dqIjG3LBXy4P4AakP/h2XGtRrBp0xtInAh -ijHyl3SJCRImHJ7K2RKilTza6We/CKBk49ZCt0Xvl/T29de1ShUCWH2YWEtgvM3X -DZoTM1PRYfl61dd4s5oz9wCGzh1NlDivqOx4UXCKXBCDUSH3ET00hl7lSM2XgYI1 -TBnsZfZrxQWh7kcT1rMhJ5QQCtkkO7q+RBNGMD+XPNjX12ruOzjjK9SXDrkb5wdJ -fzcq+Xd4z1TtW0ado4AOkUPB1ltfFLqfpo0kR0BZv3I4sjZsN/+Z0V0OWQqraffA -sgRFelQArr5T9rXn4fg8ozHSqf4hUmTFpmfwdQcGlBSBVcYn5AGPF8Fqcde+S/uU -WH1+ETOxQvdibBjWzwloPn9s9h6PYq2lY9sJpx8iQkEeb5mKPtf5P0B6ebClAZLS -nT0IFaUQAS2zMnaolQ2zepr7BxB4EW/hj8e6DyUadCrlHJhBmd8hh+iVBmoKs2pH -dmX2Os+PYhcZewoozRrSgx4hxyy/vv9haLdnG7t4TY3OZ+XkwY63I2binZB1NJip -NiuKmpS5nezMirH4JYlcWrYvjB9teSSnUmjDhDXiZo1jDiVN1Rmy5nk3pyKdVDEC -AwEAAaNqMGgwHQYDVR0OBBYEFB4M97Zn8uGSJglFwFU5Lnc/QkqiMAwGA1UdEwQF -MAMBAf8wOQYEZyoHAAQxMC8wLQIBADAJBgUrDgMCGgUAMAcGBWcqAwAABBRFsMLH -ClZ87lt4DJX5GFPBphzYEDANBgkqhkiG9w0BAQUFAAOCAgEACbODU1kBPpVJufGB -uvl2ICO1J2B01GqZNF5sAFPZn/KmsSQHRGoqxqWOeBLoR9lYGxMqXnmbnwoqZ6Yl -PwZpVnPDimZI+ymBV3QGypzqKOg4ZyYr8dW1P2WT+DZdjo2NQCCHGervJ8A9tDkP -JXtoUHRVnAxZfVo9QZQlUgjgRywVMRnVvwdVxrsStZf0X4OFunHB2WyBEXYKCrC/ -gpf36j36+uwtqSiUO1bd0lEursC9CBWMd1I0ltabrNMdjmEPNXubrjlpC2JgQCA2 -j6/7Nu4tCEoduL+bXPjqpRugc6bY+G7gMwRfaKonh+3ZwZCc7b3jajWvY9+rGNm6 -5ulK6lCKD2GTHuItGeIwlDWSXQ62B68ZgI9HkFFLLk3dheLSClIKF5r8GrBQAuUB -o2M3IUxExJtRmREOc5wGj1QupyheRDmHVi03vYVElOEMSyycw5KFNGHLD7ibSkNS -/jQ6fbjpKdx2qcgw+BRxgMYeNkh0IkFch4LoGHGLQYlE535YW6i4jRPpp2zDR+2z -Gp1iro2C6pSe3VkQw63d4k3jMdXH7OjysP6SHhYKGvzZ8/gntsm+HbRsZJB/9OTE -W9c3rkIO3aQab3yIVMUWbuF6aC74Or8NpDyJO3inTmODBCEIZ43ygknQW/2xzQ+D -hNQ+IIX3Sj0rnP0qCglN6oH4EZw= ------END CERTIFICATE----- -# "GDCA TrustAUTH R5 ROOT" -# BF FF 8F D0 44 33 48 7D 6A 8A A6 0C 1A 29 76 7A -# 9F C2 BB B0 5E 42 0F 71 3A 13 B9 92 89 1D 38 93 ------BEGIN CERTIFICATE----- -MIIFiDCCA3CgAwIBAgIIfQmX/vBH6nowDQYJKoZIhvcNAQELBQAwYjELMAkGA1UE -BhMCQ04xMjAwBgNVBAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZ -IENPLixMVEQuMR8wHQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMB4XDTE0 -MTEyNjA1MTMxNVoXDTQwMTIzMTE1NTk1OVowYjELMAkGA1UEBhMCQ04xMjAwBgNV -BAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZIENPLixMVEQuMR8w -HQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMIICIjANBgkqhkiG9w0BAQEF -AAOCAg8AMIICCgKCAgEA2aMW8Mh0dHeb7zMNOwZ+Vfy1YI92hhJCfVZmPoiC7XJj -Dp6L3TQsAlFRwxn9WVSEyfFrs0yw6ehGXTjGoqcuEVe6ghWinI9tsJlKCvLriXBj -TnnEt1u9ol2x8kECK62pOqPseQrsXzrj/e+APK00mxqriCZ7VqKChh/rNYmDf1+u -KU49tm7srsHwJ5uu4/Ts765/94Y9cnrrpftZTqfrlYwiOXnhLQiPzLyRuEH3FMEj -qcOtmkVEs7LXLM3GKeJQEK5cy4KOFxg2fZfmiJqwTTQJ9Cy5WmYqsBebnh52nUpm -MUHfP/vFBu8btn4aRjb3ZGM74zkYI+dndRTVdVeSN72+ahsmUPI2JgaQxXABZG12 -ZuGR224HwGGALrIuL4xwp9E7PLOR5G62xDtw8mySlwnNR30YwPO7ng/Wi64HtloP -zgsMR6flPri9fcebNaBhlzpBdRfMK5Z3KpIhHtmVdiBnaM8Nvd/WHwlqmuLMc3Gk -L30SgLdTMEZeS1SZD2fJpcjyIMGC7J0R38IC+xo70e0gmu9lZJIQDSri3nDxGGeC -jGHeuLzRL5z7D9Ar7Rt2ueQ5Vfj4oR24qoAATILnsn8JuLwwoC8N9VKejveSswoA -HQBUlwbgsQfZxw9cZX08bVlX5O2ljelAU58VS6Bx9hoh49pwBiFYFIeFd3mqgnkC -AwEAAaNCMEAwHQYDVR0OBBYEFOLJQJ9NzuiaoXzPDj9lxSmIahlRMA8GA1UdEwEB -/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQDRSVfg -p8xoWLoBDysZzY2wYUWsEe1jUGn4H3++Fo/9nesLqjJHdtJnJO29fDMylyrHBYZm -DRd9FBUb1Ov9H5r2XpdptxolpAqzkT9fNqyL7FeoPueBihhXOYV0GkLH6VsTX4/5 -COmSdI31R9KrO9b7eGZONn356ZLpBN79SWP8bfsUcZNnL0dKt7n/HipzcEYwv1ry -L3ml4Y0M2fmyYzeMN2WFcGpcWwlyua1jPLHd+PwyvzeG5LuOmCd+uh8W4XAR8gPf -JWIyJyYYMoSf/wA6E7qaTfRPuBRwIrHKK5DOKcFw9C+df/KQHtZa37dG/OaG+svg -IHZ6uqbL9XzeYqWxi+7egmaKTjowHz+Ay60nugxe19CxVsp3cbK1daFQqUBDF8Io -2c9Si1vIY9RCPqAzekYu9wogRlR+ak8x8YF+QnQ4ZXMn7sZ8uI7XpTrXmKGcjBBV -09tL7ECQ8s1uV9JiDnxXk7Gnbc2dg7sq5+W2O3FYrf3RRbxake5TFW/TRQl1brqQ -XR4EzzffHqhmsYzmIGrv/EhOdJhCrylvLmrH+33RZjEizIYAfmaDDEL0vTSSwxrq -T8p+ck0LcIymSLumoRT2+1hEmRSuqguTaaApJUqlyyvdimYHFngVV3Eb7PVHhPOe -MTd61X8kreS8/f3MboPoDKi3QWwH3b08hpcv0g== ------END CERTIFICATE----- -# "GeoTrust Global CA" -# FF 85 6A 2D 25 1D CD 88 D3 66 56 F4 50 12 67 98 -# CF AB AA DE 40 79 9C 72 2D E4 D2 B5 DB 36 A7 3A ------BEGIN CERTIFICATE----- -MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT -MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i -YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG -EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg -R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9 -9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq -fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv -iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU -1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+ -bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW -MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA -ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l -uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn -Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS -tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF -PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un -hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV -5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw== ------END CERTIFICATE----- -# "GeoTrust Primary Certification Authority" -# 37 D5 10 06 C5 12 EA AB 62 64 21 F1 EC 8C 92 01 -# 3F C5 F8 2A E9 8E E5 33 EB 46 19 B8 DE B4 D0 6C ------BEGIN CERTIFICATE----- -MIIDfDCCAmSgAwIBAgIQGKy1av1pthU6Y2yv2vrEoTANBgkqhkiG9w0BAQUFADBY -MQswCQYDVQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjExMC8GA1UEAxMo -R2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEx -MjcwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMFgxCzAJBgNVBAYTAlVTMRYwFAYDVQQK -Ew1HZW9UcnVzdCBJbmMuMTEwLwYDVQQDEyhHZW9UcnVzdCBQcmltYXJ5IENlcnRp -ZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEAvrgVe//UfH1nrYNke8hCUy3f9oQIIGHWAVlqnEQRr+92/ZV+zmEwu3qDXwK9 -AWbK7hWNb6EwnL2hhZ6UOvNWiAAxz9juapYC2e0DjPt1befquFUWBRaa9OBesYjA -ZIVcFU2Ix7e64HXprQU9nceJSOC7KMgD4TCTZF5SwFlwIjVXiIrxlQqD17wxcwE0 -7e9GceBrAqg1cmuXm2bgyxx5X9gaBGgeRwLmnWDiNpcB3841kt++Z8dtd1k7j53W -kBWUvEI0EME5+bEnPn7WinXFsq+W06Lem+SYvn3h6YGttm/81w7a4DSwDRp35+MI -mO9Y+pyEtzavwt+s0vQQBnBxNQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G -A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQULNVQQZcVi/CPNmFbSvtr2ZnJM5IwDQYJ -KoZIhvcNAQEFBQADggEBAFpwfyzdtzRP9YZRqSa+S7iq8XEN3GHHoOo0Hnp3DwQ1 -6CePbJC/kRYkRj5KTs4rFtULUh38H2eiAkUxT87z+gOneZ1TatnaYzr4gNfTmeGl -4b7UVXGYNTq+k+qurUKykG/g/CFNNWMziUnWm07Kx+dOCQD32sfvmWKZd7aVIl6K -oKv0uHiYyjgZmclynnjNS6yvGaBzEi38wkG6gZHaFloxt/m0cYASSJlyc1pZU8Fj -UjPtp8nSOQJw+uCxQmYpqptR7TBUIhRf2asdweSU8Pj1K/fqynhG1riR/aYNKxoU -AT6A8EKglQdebc3MS6RFjasS6LPeWuWgfOgPIh1a6Vk= ------END CERTIFICATE----- -# "GeoTrust Primary Certification Authority - G2" -# 5E DB 7A C4 3B 82 A0 6A 87 61 E8 D7 BE 49 79 EB -# F2 61 1F 7D D7 9B F9 1C 1C 6B 56 6A 21 9E D7 66 ------BEGIN CERTIFICATE----- -MIICrjCCAjWgAwIBAgIQPLL0SAoA4v7rJDteYD7DazAKBggqhkjOPQQDAzCBmDEL -MAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsTMChj -KSAyMDA3IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTE2 -MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0 -eSAtIEcyMB4XDTA3MTEwNTAwMDAwMFoXDTM4MDExODIzNTk1OVowgZgxCzAJBgNV -BAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykgMjAw -NyBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0BgNV -BAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBH -MjB2MBAGByqGSM49AgEGBSuBBAAiA2IABBWx6P0DFUPlrOuHNxFi79KDNlJ9RVcL -So17VDs6bl8VAsBQps8lL33KSLjHUGMcKiEIfJo22Av+0SbFWDEwKCXzXV2juLal -tJLtbCyf691DiaI8S0iRHVDsJt/WYC69IaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBVfNVdRVfslsq0DafwBo/q+EVXVMAoG -CCqGSM49BAMDA2cAMGQCMGSWWaboCd6LuvpaiIjwH5HTRqjySkwCY/tsXzjbLkGT -qQ7mndwxHLKgpxgceeHHNgIwOlavmnRs9vuD4DPTCF+hnMJbn0bWtsuRBmOiBucz -rD6ogRLQy7rQkgu2npaqBA+K ------END CERTIFICATE----- -# "GeoTrust Primary Certification Authority - G3" -# B4 78 B8 12 25 0D F8 78 63 5C 2A A7 EC 7D 15 5E -# AA 62 5E E8 29 16 E2 CD 29 43 61 88 6C D1 FB D4 ------BEGIN CERTIFICATE----- -MIID/jCCAuagAwIBAgIQFaxulBmyeUtB9iepwxgPHzANBgkqhkiG9w0BAQsFADCB -mDELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsT -MChjKSAyMDA4IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25s -eTE2MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhv -cml0eSAtIEczMB4XDTA4MDQwMjAwMDAwMFoXDTM3MTIwMTIzNTk1OVowgZgxCzAJ -BgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykg -MjAwOCBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0 -BgNVBAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg -LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANziXmJYHTNXOTIz -+uvLh4yn1ErdBojqZI4xmKU4kB6Yzy5jK/BGvESyiaHAKAxJcCGVn2TAppMSAmUm -hsalifD614SgcK9PGpc/BkTVyetyEH3kMSj7HGHmKAdEc5IiaacDiGydY8hS2pgn -5whMcD60yRLBxWeDXTPzAxHsatBT4tG6NmCUgLthY2xbF37fQJQeqw3CIShwiP/W -JmxsYAQlTlV+fe+/lEjetx3dcI0FX4ilm/LC7urRQEFtYjgdVgbFA0dRIBn8exAL -DmKudlW/X3e+PkkBUz2YJQN2JFodtNuJ6nnltrM7P7pMKEF/BqxqjsHQ9gUdfeZC -huOl1UcCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw -HQYDVR0OBBYEFMR5yo6hTgMdHNxr2zFblD4/MH8tMA0GCSqGSIb3DQEBCwUAA4IB -AQAtxRPPVoB7eni9n64smefv2t+UXglpp+duaIy9cr5HqQ6XErhK8WTTOd8lNNTB -zU6B8A8ExCSzNJbGpqow32hhc9f5joWJ7w5elShKKiePEI4ufIbEAp7aDHdlDkQN -kv39sxY2+hENHYwOB4lqKVb3cvTdFZx3NWZXqxNT2I7BQMXXExZacse3aQHEerGD -AWh9jUGhlBjBJVz88P6DAod8DQ3PLghcSkANPuyBYeYk28rgDi0Hsj5W3I31QYUH -SJsMC8tJP33st/3LjWeJGqvtux6jAAgIFyqCXDFdRootD4abdNlF+9RAsXqqaC2G -spki4cErx5z481+oghLrGREt ------END CERTIFICATE----- -# "Global Chambersign Root" -# EF 3C B4 17 FC 8E BF 6F 97 87 6C 9E 4E CE 39 DE -# 1E A5 FE 64 91 41 D1 02 8B 7D 11 C0 B2 29 8C ED ------BEGIN CERTIFICATE----- -MIIExTCCA62gAwIBAgIBADANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQGEwJFVTEn -MCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgyNzQzMjg3MSMwIQYDVQQL -ExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEgMB4GA1UEAxMXR2xvYmFsIENo -YW1iZXJzaWduIFJvb3QwHhcNMDMwOTMwMTYxNDE4WhcNMzcwOTMwMTYxNDE4WjB9 -MQswCQYDVQQGEwJFVTEnMCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgy -NzQzMjg3MSMwIQYDVQQLExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEgMB4G -A1UEAxMXR2xvYmFsIENoYW1iZXJzaWduIFJvb3QwggEgMA0GCSqGSIb3DQEBAQUA -A4IBDQAwggEIAoIBAQCicKLQn0KuWxfH2H3PFIP8T8mhtxOviteePgQKkotgVvq0 -Mi+ITaFgCPS3CU6gSS9J1tPfnZdan5QEcOw/Wdm3zGaLmFIoCQLfxS+EjXqXd7/s -QJ0lcqu1PzKY+7e3/HKE5TWH+VX6ox8Oby4o3Wmg2UIQxvi1RMLQQ3/bvOSiPGpV -eAp3qdjqGTK3L/5cPxvusZjsyq16aUXjlg9V9ubtdepl6DJWk0aJqCWKZQbua795 -B9Dxt6/tLE2Su8CoX6dnfQTyFQhwrJLWfQTSM/tMtgsL+xrJxI0DqX5c8lCrEqWh -z0hQpe/SyBoT+rB/sYIcd2oPX9wLlY/vQ37mRQklAgEDo4IBUDCCAUwwEgYDVR0T -AQH/BAgwBgEB/wIBDDA/BgNVHR8EODA2MDSgMqAwhi5odHRwOi8vY3JsLmNoYW1i -ZXJzaWduLm9yZy9jaGFtYmVyc2lnbnJvb3QuY3JsMB0GA1UdDgQWBBRDnDafsJ4w -TcbOX60Qq+UDpfqpFDAOBgNVHQ8BAf8EBAMCAQYwEQYJYIZIAYb4QgEBBAQDAgAH -MCoGA1UdEQQjMCGBH2NoYW1iZXJzaWducm9vdEBjaGFtYmVyc2lnbi5vcmcwKgYD -VR0SBCMwIYEfY2hhbWJlcnNpZ25yb290QGNoYW1iZXJzaWduLm9yZzBbBgNVHSAE -VDBSMFAGCysGAQQBgYcuCgEBMEEwPwYIKwYBBQUHAgEWM2h0dHA6Ly9jcHMuY2hh -bWJlcnNpZ24ub3JnL2Nwcy9jaGFtYmVyc2lnbnJvb3QuaHRtbDANBgkqhkiG9w0B -AQUFAAOCAQEAPDtwkfkEVCeR4e3t/mh/YV3lQWVPMvEYBZRqHN4fcNs+ezICNLUM -bKGKfKX0j//U2K0X1S0E0T9YgOKBWYi+wONGkyT+kL0mojAt6JcmVzWJdJYY9hXi -ryQZVgICsroPFOrGimbBhkVVi76SvpykBMdJPJ7oKXqJ1/6v/2j1pReQvayZzKWG -VwlnRtvWFsJG8eSpUPWP0ZIV018+xgBJOm5YstHRJw0lyDL4IBHNfTIzSJRUTN3c -ecQwn+uOuFW114hcxWokPbLTBQNRxgfvzBRydD1ucs4YKIxKoHflCStFREest2d/ -AYoFWpO+ocH/+OcOZ6RHSXZddZAa9SaP8A== ------END CERTIFICATE----- -# "Global Chambersign Root - 2008" -# 13 63 35 43 93 34 A7 69 80 16 A0 D3 24 DE 72 28 -# 4E 07 9D 7B 52 20 BB 8F BD 74 78 16 EE BE BA CA ------BEGIN CERTIFICATE----- -MIIHSTCCBTGgAwIBAgIJAMnN0+nVfSPOMA0GCSqGSIb3DQEBBQUAMIGsMQswCQYD -VQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3VycmVudCBhZGRyZXNzIGF0 -IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAGA1UEBRMJQTgyNzQzMjg3 -MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xJzAlBgNVBAMTHkdsb2JhbCBD -aGFtYmVyc2lnbiBSb290IC0gMjAwODAeFw0wODA4MDExMjMxNDBaFw0zODA3MzEx -MjMxNDBaMIGsMQswCQYDVQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3Vy -cmVudCBhZGRyZXNzIGF0IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAG -A1UEBRMJQTgyNzQzMjg3MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xJzAl -BgNVBAMTHkdsb2JhbCBDaGFtYmVyc2lnbiBSb290IC0gMjAwODCCAiIwDQYJKoZI -hvcNAQEBBQADggIPADCCAgoCggIBAMDfVtPkOpt2RbQT2//BthmLN0EYlVJH6xed -KYiONWwGMi5HYvNJBL99RDaxccy9Wglz1dmFRP+RVyXfXjaOcNFccUMd2drvXNL7 -G706tcuto8xEpw2uIRU/uXpbknXYpBI4iRmKt4DS4jJvVpyR1ogQC7N0ZJJ0YPP2 -zxhPYLIj0Mc7zmFLmY/CDNBAspjcDahOo7kKrmCgrUVSY7pmvWjg+b4aqIG7HkF4 -ddPB/gBVsIdU6CeQNR1MM62X/JcumIS/LMmjv9GYERTtY/jKmIhYF5ntRQOXfjyG -HoiMvvKRhI9lNNgATH23MRdaKXoKGCQwoze1eqkBfSbW+Q6OWfH9GzO1KTsXO0G2 -Id3UwD2ln58fQ1DJu7xsepeY7s2MH/ucUa6LcL0nn3HAa6x9kGbo1106DbDVwo3V -yJ2dwW3Q0L9R5OP4wzg2rtandeavhENdk5IMagfeOx2YItaswTXbo6Al/3K1dh3e -beksZixShNBFks4c5eUzHdwHU1SjqoI7mjcv3N2gZOnm3b2u/GSFHTynyQbehP9r -6GsaPMWis0L7iwk+XwhSx2LE1AVxv8Rk5Pihg+g+EpuoHtQ2TS9x9o0o9oOpE9Jh -wZG7SMA0j0GMS0zbaRL/UJScIINZc+18ofLx/d33SdNDWKBWY8o9PeU1VlnpDsog -zCtLkykPAgMBAAGjggFqMIIBZjASBgNVHRMBAf8ECDAGAQH/AgEMMB0GA1UdDgQW -BBS5CcqcHtvTbDprru1U8VuTBjUuXjCB4QYDVR0jBIHZMIHWgBS5CcqcHtvTbDpr -ru1U8VuTBjUuXqGBsqSBrzCBrDELMAkGA1UEBhMCRVUxQzBBBgNVBAcTOk1hZHJp -ZCAoc2VlIGN1cnJlbnQgYWRkcmVzcyBhdCB3d3cuY2FtZXJmaXJtYS5jb20vYWRk -cmVzcykxEjAQBgNVBAUTCUE4Mjc0MzI4NzEbMBkGA1UEChMSQUMgQ2FtZXJmaXJt -YSBTLkEuMScwJQYDVQQDEx5HbG9iYWwgQ2hhbWJlcnNpZ24gUm9vdCAtIDIwMDiC -CQDJzdPp1X0jzjAOBgNVHQ8BAf8EBAMCAQYwPQYDVR0gBDYwNDAyBgRVHSAAMCow -KAYIKwYBBQUHAgEWHGh0dHA6Ly9wb2xpY3kuY2FtZXJmaXJtYS5jb20wDQYJKoZI -hvcNAQEFBQADggIBAICIf3DekijZBZRG/5BXqfEv3xoNa/p8DhxJJHkn2EaqbylZ -UohwEurdPfWbU1Rv4WCiqAm57OtZfMY18dwY6fFn5a+6ReAJ3spED8IXDneRRXoz -X1+WLGiLwUePmJs9wOzL9dWCkoQ10b42OFZyMVtHLaoXpGNR6woBrX/sdZ7LoR/x -fxKxueRkf2fWIyr0uDldmOghp+G9PUIadJpwr2hsUF1Jz//7Dl3mLEfXgTpZALVz -a2Mg9jFFCDkO9HB+QHBaP9BrQql0PSgvAm11cpUJjUhjxsYjV5KTXjXBjfkK9yyd -Yhz2rXzdpjEetrHHfoUm+qRqtdpjMNHvkzeyZi99Bffnt0uYlDXA2TopwZ2yUDMd -SqlapskD7+3056huirRXhOukP9DuqqqHW2Pok+JrqNS4cnhrG+055F3Lm6qH1U9O -AP7Zap88MQ8oAgF9mOinsKJknnn4SPIVqczmyETrP3iZ8ntxPjzxmKfFGBI/5rso -M0LpRQp8bfKGeS/Fghl9CYl8slR2iK7ewfPM4W7bMdaTrpmg7yVqc5iJWzouE4ge -v8CSlDQb4ye3ix5vQv/n6TebUB0tovkC7stYWDpxvGjjqsGvHCgfotwjZT+B6q6Z -09gwzxMNTxXJhLynSC34MCN32EZLeW32jO06f2ARePTpm67VVMB0gNELQp/B ------END CERTIFICATE----- -# "GlobalSign" -# CA 42 DD 41 74 5F D0 B8 1E B9 02 36 2C F9 D8 BF -# 71 9D A1 BD 1B 1E FC 94 6F 5B 4C 99 F4 2C 1B 9E ------BEGIN CERTIFICATE----- -MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEgMB4G -A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNp -Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1 -MDgwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEG -A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI -hvcNAQEBBQADggEPADCCAQoCggEBAKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPL -v4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe+3t+c4isUoh7SqbKSaZeqKeMWhG8 -eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTosvNYSuetZfeLQBoZfXklq -tTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnTlEnLJGKRILzd -C9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpRl4pa -zq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCB -mTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IH -V2ccHsBqBt5ZtJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5n -bG9iYWxzaWduLm5ldC9yb290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG -3lm0mi3f3BmGLjANBgkqhkiG9w0BAQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4Gs -J0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbBuOmDAGJFtqkIk7mpM0sYmsL4h4hO -291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yiPqFbQfXf5WRDLenVOavS -ot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG79G+dwfCMNYxd -AfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7 -TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLg== ------END CERTIFICATE----- -# "GlobalSign" -# CB B5 22 D7 B7 F1 27 AD 6A 01 13 86 5B DF 1C D4 -# 10 2E 7D 07 59 AF 63 5A 7C F4 72 0D C9 63 C5 3B ------BEGIN CERTIFICATE----- -MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G -A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp -Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4 -MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG -A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI -hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8 -RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT -gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm -KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd -QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ -XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw -DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o -LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU -RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp -jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK -6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX -mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs -Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH -WD9f ------END CERTIFICATE----- -# "GlobalSign" -# 17 9F BC 14 8A 3D D0 0F D2 4E A1 34 58 CC 43 BF -# A7 F5 9C 81 82 D7 83 A5 13 F6 EB EC 10 0C 89 24 ------BEGIN CERTIFICATE----- -MIICHjCCAaSgAwIBAgIRYFlJ4CYuu1X5CneKcflK2GwwCgYIKoZIzj0EAwMwUDEk -MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI1MRMwEQYDVQQKEwpH -bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX -DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD -QSAtIFI1MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu -MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAER0UOlvt9Xb/pOdEh+J8LttV7HpI6SFkc -8GIxLcB6KP4ap1yztsyX50XUWPrRd21DosCHZTQKH3rd6zwzocWdTaRvQZU4f8ke -hOvRnkmSh5SHDDqFSmafnVmTTZdhBoZKo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYD -VR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPeYpSJvqB8ohREom3m7e0oPQn1kwCgYI -KoZIzj0EAwMDaAAwZQIxAOVpEslu28YxuglB4Zf4+/2a4n0Sye18ZNPLBSWLVtmg -515dTguDnFt2KaAJJiFqYgIwcdK1j1zqO+F4CYWodZI7yFz9SO8NdCKoCOJuxUnO -xwy8p2Fp8fc74SrL+SvzZpA3 ------END CERTIFICATE----- -# "GlobalSign" -# BE C9 49 11 C2 95 56 76 DB 6C 0A 55 09 86 D7 6E -# 3B A0 05 66 7C 44 2C 97 62 B4 FB B7 73 DE 22 8C ------BEGIN CERTIFICATE----- -MIIB4TCCAYegAwIBAgIRKjikHJYKBN5CsiilC+g0mAIwCgYIKoZIzj0EAwIwUDEk -MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI0MRMwEQYDVQQKEwpH -bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX -DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD -QSAtIFI0MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu -MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuMZ5049sJQ6fLjkZHAOkrprlOQcJ -FspjsbmG+IpXwVfOQvpzofdlQv8ewQCybnMO/8ch5RikqtlxP6jUuc6MHaNCMEAw -DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFFSwe61F -uOJAf/sKbvu+M8k8o4TVMAoGCCqGSM49BAMCA0gAMEUCIQDckqGgE6bPA7DmxCGX -kPoUVy0D7O48027KqGx2vKLeuwIgJ6iFJzWbVsaj8kfSt24bAgAXqmemFZHe+pTs -ewv4n4Q= ------END CERTIFICATE----- -# "GlobalSign" -# 2C AB EA FE 37 D0 6C A2 2A BA 73 91 C0 03 3D 25 -# 98 29 52 C4 53 64 73 49 76 3A 3A B5 AD 6C CF 69 ------BEGIN CERTIFICATE----- -MIIFgzCCA2ugAwIBAgIORea7A4Mzw4VlSOb/RVEwDQYJKoZIhvcNAQEMBQAwTDEg -MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjYxEzARBgNVBAoTCkdsb2Jh -bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTQxMjEwMDAwMDAwWhcNMzQx -MjEwMDAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSNjET -MBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCAiIwDQYJ -KoZIhvcNAQEBBQADggIPADCCAgoCggIBAJUH6HPKZvnsFMp7PPcNCPG0RQssgrRI -xutbPK6DuEGSMxSkb3/pKszGsIhrxbaJ0cay/xTOURQh7ErdG1rG1ofuTToVBu1k -ZguSgMpE3nOUTvOniX9PeGMIyBJQbUJmL025eShNUhqKGoC3GYEOfsSKvGRMIRxD -aNc9PIrFsmbVkJq3MQbFvuJtMgamHvm566qjuL++gmNQ0PAYid/kD3n16qIfKtJw -LnvnvJO7bVPiSHyMEAc4/2ayd2F+4OqMPKq0pPbzlUoSB239jLKJz9CgYXfIWHSw -1CM69106yqLbnQneXUQtkPGBzVeS+n68UARjNN9rkxi+azayOeSsJDa38O+2HBNX -k7besvjihbdzorg1qkXy4J02oW9UivFyVm4uiMVRQkQVlO6jxTiWm05OWgtH8wY2 -SXcwvHE35absIQh1/OZhFj931dmRl4QKbNQCTXTAFO39OfuD8l4UoQSwC+n+7o/h -bguyCLNhZglqsQY6ZZZZwPA1/cnaKI0aEYdwgQqomnUdnjqGBQCe24DWJfncBZ4n -WUx2OVvq+aWh2IMP0f/fMBH5hc8zSPXKbWQULHpYT9NLCEnFlWQaYw55PfWzjMpY -rZxCRXluDocZXFSxZba/jJvcE+kNb7gu3GduyYsRtYQUigAZcIN5kZeR1Bonvzce -MgfYFGM8KEyvAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTAD -AQH/MB0GA1UdDgQWBBSubAWjkxPioufi1xzWx/B/yGdToDAfBgNVHSMEGDAWgBSu -bAWjkxPioufi1xzWx/B/yGdToDANBgkqhkiG9w0BAQwFAAOCAgEAgyXt6NH9lVLN -nsAEoJFp5lzQhN7craJP6Ed41mWYqVuoPId8AorRbrcWc+ZfwFSY1XS+wc3iEZGt -Ixg93eFyRJa0lV7Ae46ZeBZDE1ZXs6KzO7V33EByrKPrmzU+sQghoefEQzd5Mr61 -55wsTLxDKZmOMNOsIeDjHfrYBzN2VAAiKrlNIC5waNrlU/yDXNOd8v9EDERm8tLj -vUYAGm0CuiVdjaExUd1URhxN25mW7xocBFymFe944Hn+Xds+qkxV/ZoVqW/hpvvf -cDDpw+5CRu3CkwWJ+n1jez/QcYF8AOiYrg54NMMl+68KnyBr3TsTjxKM4kEaSHpz -oHdpx7Zcf4LIHv5YGygrqGytXm3ABdJ7t+uA/iU3/gKbaKxCXcPu9czc8FB10jZp -nOZ7BN9uBmm23goJSFmH63sUYHpkqmlD75HHTOwY3WzvUy2MmeFe8nI+z1TIvWfs -pA9MRf/TuTAjB0yPEL+GltmZWrSZVxykzLsViVO6LAUP5MSeGbEYNNVMnbrt9x+v -JJUEeKgDu+6B5dpffItKoZB0JaezPkvILFa9x8jvOOJckvB595yEunQtYQEgfn7R -8k8HWV+LLUNS60YMlOH1Zkd5d9VUWx+tJDfLRVpOoERIyNiwmcUVhAn21klJwGW4 -5hpxbqCo8YLoRT5s1gLXCmeDBVrJpBA= ------END CERTIFICATE----- -# "GlobalSign Root CA" -# EB D4 10 40 E4 BB 3E C7 42 C9 E3 81 D3 1E F2 A4 -# 1A 48 B6 68 5C 96 E7 CE F3 C1 DF 6C D4 33 1C 99 ------BEGIN CERTIFICATE----- -MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG -A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv -b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw -MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i -YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT -aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ -jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp -xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp -1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG -snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ -U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8 -9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E -BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B -AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz -yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE -38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP -AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad -DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME -HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A== ------END CERTIFICATE----- -# "Go Daddy Class 2 Certification Authority" -# C3 84 6B F2 4B 9E 93 CA 64 27 4C 0E C6 7C 1E CC -# 5E 02 4F FC AC D2 D7 40 19 35 0E 81 FE 54 6A E4 ------BEGIN CERTIFICATE----- -MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh -MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE -YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3 -MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo -ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg -MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN -ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA -PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w -wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi -EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY -avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+ -YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE -sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h -/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5 -IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj -YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD -ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy -OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P -TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ -HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER -dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf -ReYNnyicsbkqWletNw+vHX/bvZ8= ------END CERTIFICATE----- -# "Go Daddy Root Certificate Authority - G2" -# 45 14 0B 32 47 EB 9C C8 C5 B4 F0 D7 B5 30 91 F7 -# 32 92 08 9E 6E 5A 63 E2 74 9D D3 AC A9 19 8E DA ------BEGIN CERTIFICATE----- -MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx -EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT -EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp -ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz -NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH -EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE -AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw -DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD -E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH -/PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy -DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh -GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR -tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA -AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE -FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX -WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu -9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr -gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo -2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO -LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI -4uJEvlz36hz1 ------END CERTIFICATE----- -# "Government Root Certification Authority" -# 70 B9 22 BF DA 0E 3F 4A 34 2E 4E E2 2D 57 9A E5 -# 98 D0 71 CC 5E C9 C3 0F 12 36 80 34 03 88 AE A5 ------BEGIN CERTIFICATE----- -MIIFSzCCAzOgAwIBAgIRALZLiAfiI+7IXBKtpg4GofIwDQYJKoZIhvcNAQELBQAw -PzELMAkGA1UEBhMCVFcxMDAuBgNVBAoMJ0dvdmVybm1lbnQgUm9vdCBDZXJ0aWZp -Y2F0aW9uIEF1dGhvcml0eTAeFw0xMjA5MjgwODU4NTFaFw0zNzEyMzExNTU5NTla -MD8xCzAJBgNVBAYTAlRXMTAwLgYDVQQKDCdHb3Zlcm5tZW50IFJvb3QgQ2VydGlm -aWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC -AQC2/5c8gb4BWCQnr44BK9ZykjAyG1+bfNTUf+ihYHMwVxAA+lCWJP5Q5ow6ldFX -eYTVZ1MMKoI+GFy4MCYa1l7GLbIEUQ7v3wxjR+vEEghRK5lxXtVpe+FdyXcdIOxW -juVhYC386RyA3/pqg7sFtR4jEpyCygrzFB0g5AaPQySZn7YKk1pzGxY5vgW28Yyl -ZJKPBeRcdvc5w88tvQ7Yy6gOMZvJRg9nU0MEj8iyyIOAX7ryD6uBNaIgIZfOD4k0 -eA/PH07p+4woPN405+2f0mb1xcoxeNLOUNFggmOd4Ez3B66DNJ1JSUPUfr0t4urH -cWWACOQ2nnlwCjyHKenkkpTqBpIpJ3jmrdc96QoLXvTg1oadLXLLi2RW5vSueKWg -OTNYPNyoj420ai39iHPplVBzBN8RiD5C1gJ0+yzEb7xs1uCAb9GGpTJXA9ZN9E4K -mSJ2fkpAgvjJ5E7LUy3Hsbbi08J1J265DnGyNPy/HE7CPfg26QrMWJqhGIZO4uGq -s3NZbl6dtMIIr69c/aQCb/+4DbvVq9dunxpPkUDwH0ZVbaCSw4nNt7H/HLPLo5wK -4/7NqrwB7N1UypHdTxOHpPaY7/1J1lcqPKZc9mA3v9g+fk5oKiMyOr5u5CI9ByTP -isubXVGzMNJxbc5Gim18SjNE2hIvNkvy6fFRCW3bapcOFwIDAQABo0IwQDAPBgNV -HRMBAf8EBTADAQH/MB0GA1UdDgQWBBTVZx3gnHosnMvFmOcdByYqhux0zTAOBgNV -HQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQELBQADggIBAJA75cJTQijq9TFOjj2Rnk0J -89ixUuZPrAwxIbvx6pnMg/y2KOTshAcOD06Xu29oRo8OURWV+Do7H1+CDgxxDryR -T64zLiNB9CZrTxOH+nj2LsIPkQWXqmrBap+8hJ4IKifd2ocXhuGzyl3tOKkpboTe -Rmv8JxlQpRJ6jH1i/NrnzLyfSa8GuCcn8on3Fj0Y5r3e9YwSkZ/jBI3+BxQaWqw5 -ghvxOBnhY+OvbLamURfr+kvriyL2l/4QOl+UoEtTcT9a4RD4co+WgN2NApgAYT2N -vC2xR8zaXeEgp4wxXPHj2rkKhkfIoT0Hozymc26Uke1uJDr5yTDRB6iBfSZ9fYTf -hsmL5a4NHr6JSFEVg5iWL0rrczTXdM3Jb9DCuiv2mv6Z3WAUjhv5nDk8f0OJU+jl -wqu+Iq0nOJt3KLejY2OngeepaUXrjnhWzAWEx/uttjB8YwWfLYwkf0uLkvw4Hp+g -pVezbp3YZLhwmmBScMip0P/GnO0QYV7Ngw5u6E0CQUridgR51lQ/ipgyFKDdLZzn -uoJxo4ZVKZnSKdt1OvfbQ/+2W/u3fjWAjg1srnm3Ni2XUqGwB5wH5Ss2zQOXlL0t -DjQG/MAWifw3VOTWzz0TBPKR2ck2Lj7FWtClTILD/y58Jnb38/1FoqVuVa4uzM8s -iTTa9g3nkagQ6hed8vbs ------END CERTIFICATE----- -# "GTS Root R1" -# 2A 57 54 71 E3 13 40 BC 21 58 1C BD 2C F1 3E 15 -# 84 63 20 3E CE 94 BC F9 D3 CC 19 6B F0 9A 54 72 ------BEGIN CERTIFICATE----- -MIIFWjCCA0KgAwIBAgIQbkepxUtHDA3sM9CJuRz04TANBgkqhkiG9w0BAQwFADBH -MQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM -QzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIy -MDAwMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNl -cnZpY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwggIiMA0GCSqGSIb3DQEB -AQUAA4ICDwAwggIKAoICAQC2EQKLHuOhd5s73L+UPreVp0A8of2C+X0yBoJx9vaM -f/vo27xqLpeXo4xL+Sv2sfnOhB2x+cWX3u+58qPpvBKJXqeqUqv4IyfLpLGcY9vX -mX7wCl7raKb0xlpHDU0QM+NOsROjyBhsS+z8CZDfnWQpJSMHobTSPS5g4M/SCYe7 -zUjwTcLCeoiKu7rPWRnWr4+wB7CeMfGCwcDfLqZtbBkOtdh+JhpFAz2weaSUKK0P -fyblqAj+lug8aJRT7oM6iCsVlgmy4HqMLnXWnOunVmSPlk9orj2XwoSPwLxAwAtc -vfaHszVsrBhQf4TgTM2S0yDpM7xSma8ytSmzJSq0SPly4cpk9+aCEI3oncKKiPo4 -Zor8Y/kB+Xj9e1x3+naH+uzfsQ55lVe0vSbv1gHR6xYKu44LtcXFilWr06zqkUsp -zBmkMiVOKvFlRNACzqrOSbTqn3yDsEB750Orp2yjj32JgfpMpf/VjsPOS+C12LOO -Rc92wO1AK/1TD7Cn1TsNsYqiA94xrcx36m97PtbfkSIS5r762DL8EGMUUXLeXdYW -k70paDPvOmbsB4om3xPXV2V4J95eSRQAogB/mqghtqmxlbCluQ0WEdrHbEg8QOB+ -DVrNVjzRlwW5y0vtOUucxD/SVRNuJLDWcfr0wbrM7Rv1/oFB2ACYPTrIrnqYNxgF -lQIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV -HQ4EFgQU5K8rJnEaK0gnhS9SZizv8IkTcT4wDQYJKoZIhvcNAQEMBQADggIBADiW -Cu49tJYeX++dnAsznyvgyv3SjgofQXSlfKqE1OXyHuY3UjKcC9FhHb8owbZEKTV1 -d5iyfNm9dKyKaOOpMQkpAWBz40d8U6iQSifvS9efk+eCNs6aaAyC58/UEBZvXw6Z -XPYfcX3v73svfuo21pdwCxXu11xWajOl40k4DLh9+42FpLFZXvRq4d2h9mREruZR -gyFmxhE+885H7pwoHyXa/6xmld01D1zvICxi/ZG6qcz8WpyTgYMpl0p8WnK0OdC3 -d8t5/Wk6kjftbjhlRn7pYL15iJdfOBL07q9bgsiG1eGZbYwE8na6SfZu6W0eX6Dv -J4J2QPim01hcDyxC2kLGe4g0x8HYRZvBPsVhHdljUEn2NIVq4BjFbkerQUIpm/Zg -DdIx02OYI5NaAIFItO/Nis3Jz5nu2Z6qNuFoS3FJFDYoOj0dzpqPJeaAcWErtXvM -+SUWgeExX6GjfhaknBZqlxi9dnKlC54dNuYvoS++cJEPqOba+MSSQGwlfnuzCdyy -F62ARPBopY+Udf90WuioAnwMCeKpSwughQtiue+hMZL77/ZRBIls6Kl0obsXs7X9 -SQ98POyDGCBDTtWTurQ0sR8WNh8M5mQ5Fkzc4P4dyKliPUDqysU0ArSuiYgzNdws -E3PYJ/HQcu51OyLemGhmW/HGY0dVHLqlCFF1pkgl ------END CERTIFICATE----- -# "GTS Root R2" -# C4 5D 7B B0 8E 6D 67 E6 2E 42 35 11 0B 56 4E 5F -# 78 FD 92 EF 05 8C 84 0A EA 4E 64 55 D7 58 5C 60 ------BEGIN CERTIFICATE----- -MIIFWjCCA0KgAwIBAgIQbkepxlqz5yDFMJo/aFLybzANBgkqhkiG9w0BAQwFADBH -MQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM -QzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIy -MDAwMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNl -cnZpY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwggIiMA0GCSqGSIb3DQEB -AQUAA4ICDwAwggIKAoICAQDO3v2m++zsFDQ8BwZabFn3GTXd98GdVarTzTukk3Lv -CvptnfbwhYBboUhSnznFt+4orO/LdmgUud+tAWyZH8QiHZ/+cnfgLFuv5AS/T3Kg -GjSY6Dlo7JUle3ah5mm5hRm9iYz+re026nO8/4Piy33B0s5Ks40FnotJk9/BW9Bu -XvAuMC6C/Pq8tBcKSOWIm8Wba96wyrQD8Nr0kLhlZPdcTK3ofmZemde4wj7I0BOd -re7kRXuJVfeKH2JShBKzwkCX44ofR5GmdFrS+LFjKBC4swm4VndAoiaYecb+3yXu -PuWgf9RhD1FLPD+M2uFwdNjCaKH5wQzpoeJ/u1U8dgbuak7MkogwTZq9TwtImoS1 -mKPV+3PBV2HdKFZ1E66HjucMUQkQdYhMvI35ezzUIkgfKtzra7tEscszcTJGr61K -8YzodDqs5xoic4DSMPclQsciOzsSrZYuxsN2B6ogtzVJV+mSSeh2FnIxZyuWfoqj -x5RWIr9qS34BIbIjMt/kmkRtWVtd9QCgHJvGeJeNkP+byKq0rxFROV7Z+2et1VsR -nTKaG73VululycslaVNVJ1zgyjbLiGH7HrfQy+4W+9OmTN6SpdTi3/UGVN4unUu0 -kzCqgc7dGtxRcw1PcOnlthYhGXmy5okLdWTK1au8CcEYof/UVKGFPP0UJAOyh9Ok -twIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV -HQ4EFgQUu//KjiOfT5nK2+JopqUVJxce2Q4wDQYJKoZIhvcNAQEMBQADggIBALZp -8KZ3/p7uC4Gt4cCpx/k1HUCCq+YEtN/L9x0Pg/B+E02NjO7jMyLDOfxA325BS0JT -vhaI8dI4XsRomRyYUpOM52jtG2pzegVATX9lO9ZY8c6DR2Dj/5epnGB3GFW1fgiT -z9D2PGcDFWEJ+YF59exTpJ/JjwGLc8R3dtyDovUMSRqodt6Sm2T4syzFJ9MHwAiA -pJiS4wGWAqoC7o87xdFtCjMwc3i5T1QWvwsHoaRc5svJXISPD+AVdyx+Jn7axEvb -pxZ3B7DNdehyQtaVhJ2Gg/LkkM0JR9SLA3DaWsYDQvTtN6LwG1BUSw7YhN4ZKJmB -R64JGz9I0cNv4rBgF/XuIwKl2gBbbZCr7qLpGzvpx0QnRY5rn/WkhLx3+WuXrD5R -RaIRpsyF7gpo8j5QOHokYh4XIDdtak23CZvJ/KRY9bb7nE4Yu5UC56GtmwfuNmsk -0jmGwZODUNKBRqhfYlcsu2xkiAhu7xNUX90txGdj08+JN7+dIPT7eoOboB6BAFDC -5AwiWVIQ7UNWhwD4FFKnHYuTjKJNRn8nxnGbJN7k2oaLDX5rIMHAnuFl2GqjpuiF -izoHCBy69Y9Vmhh1fuXsgWbRIXOhNUQLgD1bnF5vKheW0YMjiGZt5obicDIvUiLn -yOd/xCxgXS/Dr55FBcOEArf9LAhST4Ldo/DUhgkC ------END CERTIFICATE----- -# "GTS Root R3" -# 15 D5 B8 77 46 19 EA 7D 54 CE 1C A6 D0 B0 C4 03 -# E0 37 A9 17 F1 31 E8 A0 4E 1E 6B 7A 71 BA BC E5 ------BEGIN CERTIFICATE----- -MIICDDCCAZGgAwIBAgIQbkepx2ypcyRAiQ8DVd2NHTAKBggqhkjOPQQDAzBHMQsw -CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU -MBIGA1UEAxMLR1RTIFJvb3QgUjMwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw -MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp -Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjMwdjAQBgcqhkjOPQIBBgUrgQQA -IgNiAAQfTzOHMymKoYTey8chWEGJ6ladK0uFxh1MJ7x/JlFyb+Kf1qPKzEUURout -736GjOyxfi//qXGdGIRFBEFVbivqJn+7kAHjSxm65FSWRQmx1WyRRK2EE46ajA2A -DDL24CejQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud -DgQWBBTB8Sa6oC2uhYHP0/EqEr24Cmf9vDAKBggqhkjOPQQDAwNpADBmAjEAgFuk -fCPAlaUs3L6JbyO5o91lAFJekazInXJ0glMLfalAvWhgxeG4VDvBNhcl2MG9AjEA -njWSdIUlUfUk7GRSJFClH9voy8l27OyCbvWFGFPouOOaKaqW04MjyaR7YbPMAuhd ------END CERTIFICATE----- -# "GTS Root R4" -# 71 CC A5 39 1F 9E 79 4B 04 80 25 30 B3 63 E1 21 -# DA 8A 30 43 BB 26 66 2F EA 4D CA 7F C9 51 A4 BD ------BEGIN CERTIFICATE----- -MIICCjCCAZGgAwIBAgIQbkepyIuUtui7OyrYorLBmTAKBggqhkjOPQQDAzBHMQsw -CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU -MBIGA1UEAxMLR1RTIFJvb3QgUjQwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw -MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp -Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjQwdjAQBgcqhkjOPQIBBgUrgQQA -IgNiAATzdHOnaItgrkO4NcWBMHtLSZ37wWHO5t5GvWvVYRg1rkDdc/eJkTBa6zzu -hXyiQHY7qca4R9gq55KRanPpsXI5nymfopjTX15YhmUPoYRlBtHci8nHc8iMai/l -xKvRHYqjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud -DgQWBBSATNbrdP9JNqPV2Py1PsVq8JQdjDAKBggqhkjOPQQDAwNnADBkAjBqUFJ0 -CMRw3J5QdCHojXohw0+WbhXRIjVhLfoIN+4Zba3bssx9BzT1YBkstTTZbyACMANx -sbqjYAuG7ZoIapVon+Kz4ZNkfF6Tpt95LY2F45TPI11xzPKwTdb+mciUqXWi4w== ------END CERTIFICATE----- -# "Hellenic Academic and Research Institutions ECC RootCA 2015" -# 44 B5 45 AA 8A 25 E6 5A 73 CA 15 DC 27 FC 36 D2 -# 4C 1C B9 95 3A 06 65 39 B1 15 82 DC 48 7B 48 33 ------BEGIN CERTIFICATE----- -MIICwzCCAkqgAwIBAgIBADAKBggqhkjOPQQDAjCBqjELMAkGA1UEBhMCR1IxDzAN -BgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl -c2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkxRDBCBgNVBAMTO0hl -bGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgRUNDIFJv -b3RDQSAyMDE1MB4XDTE1MDcwNzEwMzcxMloXDTQwMDYzMDEwMzcxMlowgaoxCzAJ -BgNVBAYTAkdSMQ8wDQYDVQQHEwZBdGhlbnMxRDBCBgNVBAoTO0hlbGxlbmljIEFj -YWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgQ2VydC4gQXV0aG9yaXR5 -MUQwQgYDVQQDEztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0 -dXRpb25zIEVDQyBSb290Q0EgMjAxNTB2MBAGByqGSM49AgEGBSuBBAAiA2IABJKg -QehLgoRc4vgxEZmGZE4JJS+dQS8KrjVPdJWyUWRrjWvmP3CV8AVER6ZyOFB2lQJa -jq4onvktTpnvLEhvTCUp6NFxW98dwXU3tNf6e3pCnGoKVlp8aQuqgAkkbH7BRqNC -MEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFLQi -C4KZJAEOnLvkDv2/+5cgk5kqMAoGCCqGSM49BAMCA2cAMGQCMGfOFmI4oqxiRaep -lSTAGiecMjvAwNW6qef4BENThe5SId6d9SWDPp5YSy/XZxMOIQIwBeF1Ad5o7Sof -TUwJCA3sS61kFyjndc5FZXIhF8siQQ6ME5g4mlRtm8rifOoCWCKR ------END CERTIFICATE----- -# "Hellenic Academic and Research Institutions RootCA 2011" -# BC 10 4F 15 A4 8B E7 09 DC A5 42 A7 E1 D4 B9 DF -# 6F 05 45 27 E8 02 EA A9 2D 59 54 44 25 8A FE 71 ------BEGIN CERTIFICATE----- -MIIEMTCCAxmgAwIBAgIBADANBgkqhkiG9w0BAQUFADCBlTELMAkGA1UEBhMCR1Ix -RDBCBgNVBAoTO0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1 -dGlvbnMgQ2VydC4gQXV0aG9yaXR5MUAwPgYDVQQDEzdIZWxsZW5pYyBBY2FkZW1p -YyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIFJvb3RDQSAyMDExMB4XDTExMTIw -NjEzNDk1MloXDTMxMTIwMTEzNDk1MlowgZUxCzAJBgNVBAYTAkdSMUQwQgYDVQQK -EztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIENl -cnQuIEF1dGhvcml0eTFAMD4GA1UEAxM3SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl -c2VhcmNoIEluc3RpdHV0aW9ucyBSb290Q0EgMjAxMTCCASIwDQYJKoZIhvcNAQEB -BQADggEPADCCAQoCggEBAKlTAOMupvaO+mDYLZU++CwqVE7NuYRhlFhPjz2L5EPz -dYmNUeTDN9KKiE15HrcS3UN4SoqS5tdI1Q+kOilENbgH9mgdVc04UfCMJDGFr4PJ -fel3r+0ae50X+bOdOFAPplp5kYCvN66m0zH7tSYJnTxa71HFK9+WXesyHgLacEns -bgzImjeN9/E2YEsmLIKe0HjzDQ9jpFEw4fkrJxIH2Oq9GGKYsFk3fb7u8yBRQlqD -75O6aRXxYp2fmTmCobd0LovUxQt7L/DICto9eQqakxylKHJzkUOap9FNhYS5qXSP -FEDH3N6sQWRstBmbAmNtJGSPRLIl6s5ddAxjMlyNh+UCAwEAAaOBiTCBhjAPBgNV -HRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAdBgNVHQ4EFgQUppFC/RNhSiOeCKQp -5dgTBCPuQSUwRwYDVR0eBEAwPqA8MAWCAy5ncjAFggMuZXUwBoIELmVkdTAGggQu -b3JnMAWBAy5ncjAFgQMuZXUwBoEELmVkdTAGgQQub3JnMA0GCSqGSIb3DQEBBQUA -A4IBAQAf73lB4XtuP7KMhjdCSk4cNx6NZrokgclPEg8hwAOXhiVtXdMiKahsog2p -6z0GW5k6x8zDmjR/qw7IThzh+uTczQ2+vyT+bOdrwg3IBp5OjWEopmr95fZi6hg8 -TqBTnbI6nOulnJEWtk2C4AwFSKls9cz4y51JtPACpf1wA+2KIaWuE4ZJwzNzvoc7 -dIsXRSZMFpGD/md9zU1jZ/rzAxKWeAaNsWftjj++n08C9bMJL/NMh98qy5V8Acys -Nnq/onN694/BtZqhFLKPM58N7yLcZnuEvUUXBj08yrl3NI/K6s8/MT7jiOOASSXI -l7WdmplNsDz4SgCbZN2fOUvRJ9e4 ------END CERTIFICATE----- -# "Hellenic Academic and Research Institutions RootCA 2015" -# A0 40 92 9A 02 CE 53 B4 AC F4 F2 FF C6 98 1C E4 -# 49 6F 75 5E 6D 45 FE 0B 2A 69 2B CD 52 52 3F 36 ------BEGIN CERTIFICATE----- -MIIGCzCCA/OgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBpjELMAkGA1UEBhMCR1Ix -DzANBgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNhZGVtaWMgYW5k -IFJlc2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkxQDA+BgNVBAMT -N0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgUm9v -dENBIDIwMTUwHhcNMTUwNzA3MTAxMTIxWhcNNDAwNjMwMTAxMTIxWjCBpjELMAkG -A1UEBhMCR1IxDzANBgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNh -ZGVtaWMgYW5kIFJlc2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkx -QDA+BgNVBAMTN0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1 -dGlvbnMgUm9vdENBIDIwMTUwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC -AQDC+Kk/G4n8PDwEXT2QNrCROnk8ZlrvbTkBSRq0t89/TSNTt5AA4xMqKKYx8ZEA -4yjsriFBzh/a/X0SWwGDD7mwX5nh8hKDgE0GPt+sr+ehiGsxr/CL0BgzuNtFajT0 -AoAkKAoCFZVedioNmToUW/bLy1O8E00BiDeUJRtCvCLYjqOWXjrZMts+6PAQZe10 -4S+nfK8nNLspfZu2zwnI5dMK/IhlZXQK3HMcXM1AsRzUtoSMTFDPaI6oWa7CJ06C -ojXdFPQf/7J31Ycvqm59JCfnxssm5uX+Zwdj2EUN3TpZZTlYepKZcj2chF6IIbjV -9Cz82XBST3i4vTwri5WY9bPRaM8gFH5MXF/ni+X1NYEZN9cRCLdmvtNKzoNXADrD -gfgXy5I2XdGj2HUb4Ysn6npIQf1FGQatJ5lOwXBH3bWfgVMS5bGMSF0xQxfjjMZ6 -Y5ZLKTBOhE5iGV48zpeQpX8B653g+IuJ3SWYPZK2fu/Z8VFRfS0myGlZYeCsargq -NhEEelC9MoS+L9xy1dcdFkfkR2YgP/SWxa+OAXqlD3pk9Q0Yh9muiNX6hME6wGko -LfINaFGq46V3xqSQDqE3izEjR8EJCOtu93ib14L8hCCZSRm2Ekax+0VVFqmjZayc -Bw/qa9wfLgZy7IaIEuQt218FL+TwA9MmM+eAws1CoRc0CwIDAQABo0IwQDAPBgNV -HRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUcRVnyMjJvXVd -ctA4GGqd83EkVAswDQYJKoZIhvcNAQELBQADggIBAHW7bVRLqhBYRjTyYtcWNl0I -XtVsyIe9tC5G8jH4fOpCtZMWVdyhDBKg2mF+D1hYc2Ryx+hFjtyp8iY/xnmMsVMI -M4GwVhO+5lFc2JsKT0ucVlMC6U/2DWDqTUJV6HwbISHTGzrMd/K4kPFox/la/vot -9L/J9UUbzjgQKjeKeaO04wlshYaT/4mWJ3iBj2fjRnRUjtkNaeJK9E10A/+yd+2V -Z5fkscWrv2oj6NSU4kQoYsRL4vDY4ilrGnB+JGGTe08DMiUNRSQrlrRGar9KC/ea -j8GsGsVn82800vpzY4zvFrCopEYq+OsS7HK07/grfoxSwIuEVPkvPuNVqNxmsdnh -X9izjFk0WaSrT2y7HxjbdavYy5LNlDhhDgcGH0tGEPEVvo2FXDtKK4F5D7Rpn0lQ -l033DlZdwJVqwjbDG2jJ9SrcR5q+ss7FJej6A7na+RZukYT1HCjI/CbM1xyQVqdf -bzoEvM14iQuODy+jqk+iGxI9FghAD/FGTNeqewjBCvVtJ94Cj8rDtSvK6evIIVM4 -pcw72Hc3MKJP2W/R8kCtQXoXxdZKNYm3QdV8hn9VTYNKpXMgwDqvkPGaJI7ZjnHK -e7iG2rKPmT4dEw0SEe7Uq/DpFXYC5ODfqiAeW2GFZECpkJcNrVPSWh2HagCXZWK0 -vm9qp/UsQu0yrbYhnr68 ------END CERTIFICATE----- -# "Hongkong Post Root CA 1" -# F9 E6 7D 33 6C 51 00 2A C0 54 C6 32 02 2D 66 DD -# A2 E7 E3 FF F1 0A D0 61 ED 31 D8 BB B4 10 CF B2 ------BEGIN CERTIFICATE----- -MIIDMDCCAhigAwIBAgICA+gwDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UEBhMCSEsx -FjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdrb25nIFBvc3Qg -Um9vdCBDQSAxMB4XDTAzMDUxNTA1MTMxNFoXDTIzMDUxNTA0NTIyOVowRzELMAkG -A1UEBhMCSEsxFjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdr -b25nIFBvc3QgUm9vdCBDQSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC -AQEArP84tulmAknjorThkPlAj3n54r15/gK97iSSHSL22oVyaf7XPwnU3ZG1ApzQ -jVrhVcNQhrkpJsLj2aDxaQMoIIBFIi1WpztUlVYiWR8o3x8gPW2iNr4joLFutbEn -PzlTCeqrauh0ssJlXI6/fMN4hM2eFvz1Lk8gKgifd/PFHsSaUmYeSF7jEAaPIpjh -ZY4bXSNmO7ilMlHIhqqhqZ5/dpTCpmy3QfDVyAY45tQM4vM7TG1QjMSDJ8EThFk9 -nnV0ttgCXjqQesBCNnLsak3c78QA3xMYV18meMjWCnl3v/evt3a5pQuEF10Q6m/h -q5URX208o1xNg1vysxmKgIsLhwIDAQABoyYwJDASBgNVHRMBAf8ECDAGAQH/AgED -MA4GA1UdDwEB/wQEAwIBxjANBgkqhkiG9w0BAQUFAAOCAQEADkbVPK7ih9legYsC -mEEIjEy82tvuJxuC52pF7BaLT4Wg87JwvVqWuspube5Gi27nKi6Wsxkz67SfqLI3 -7piol7Yutmcn1KZJ/RyTZXaeQi/cImyaT/JaFTmxcdcrUehtHJjA2Sr0oYJ71clB -oiMBdDhViw+5LmeiIAQ32pwL0xch4I+XeTRvhEgCIDMb5jREn5Fw9IBehEPCKdJs -EhTkYY2sEJCehFC78JZvRZ+K88psT/oROhUVRsPNH4NbLUES7VBnQRM9IauUiqpO -fMGx+6fWtScvl6tu4B3i0RwsH0Ti/L6RoZz71ilTc4afU9hDDl3WY4JxHYB0yvbi -AmvZWg== ------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 ------BEGIN CERTIFICATE----- -MIIFYDCCA0igAwIBAgIQCgFCgAAAAUUjyES1AAAAAjANBgkqhkiG9w0BAQsFADBK -MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScwJQYDVQQDEx5JZGVu -VHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwHhcNMTQwMTE2MTgxMjIzWhcNMzQw -MTE2MTgxMjIzWjBKMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScw -JQYDVQQDEx5JZGVuVHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwggIiMA0GCSqG -SIb3DQEBAQUAA4ICDwAwggIKAoICAQCnUBneP5k91DNG8W9RYYKyqU+PZ4ldhNlT -3Qwo2dfw/66VQ3KZ+bVdfIrBQuExUHTRgQ18zZshq0PirK1ehm7zCYofWjK9ouuU -+ehcCuz/mNKvcbO0U59Oh++SvL3sTzIwiEsXXlfEU8L2ApeN2WIrvyQfYo3fw7gp -S0l4PJNgiCL8mdo2yMKi1CxUAGc1bnO/AljwpN3lsKImesrgNqUZFvX9t++uP0D1 -bVoE/c40yiTcdCMbXTMTEl3EASX2MN0CXZ/g1Ue9tOsbobtJSdifWwLziuQkkORi -T0/Br4sOdBeo0XKIanoBScy0RnnGF7HamB4HWfp1IYVl3ZBWzvurpWCdxJ35UrCL -vYf5jysjCiN2O/cz4ckA82n5S6LgTrx+kzmEB/dEcH7+B1rlsazRGMzyNeVJSQjK -Vsk9+w8YfYs7wRPCTY/JTw436R+hDmrfYi7LNQZReSzIJTj0+kuniVyc0uMNOYZK -dHzVWYfCP04MXFL0PfdSgvHqo6z9STQaKPNBiDoT7uje/5kdX7rL6B7yuVBgwDHT -c+XvvqDtMwt0viAgxGds8AgDelWAf0ZOlqf0Hj7h9tgJ4TNkK2PXMl6f+cB7D3hv -l7yTmvmcEpB4eoCHFddydJxVdHixuuFucAS6T6C6aMN7/zHwcz09lCqxC0EOoP5N -iGVreTO01wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB -/zAdBgNVHQ4EFgQU7UQZwNPwBovupHu+QucmVMiONnYwDQYJKoZIhvcNAQELBQAD -ggIBAA2ukDL2pkt8RHYZYR4nKM1eVO8lvOMIkPkp165oCOGUAFjvLi5+U1KMtlwH -6oi6mYtQlNeCgN9hCQCTrQ0U5s7B8jeUeLBfnLOic7iPBZM4zY0+sLj7wM+x8uwt -LRvM7Kqas6pgghstO8OEPVeKlh6cdbjTMM1gCIOQ045U8U1mwF10A0Cj7oV+wh93 -nAbowacYXVKV7cndJZ5t+qntozo00Fl72u1Q8zW/7esUTTHHYPTa8Yec4kjixsU3 -+wYQ+nVZZjFHKdp2mhzpgq7vmrlR94gjmmmVYjzlVYA211QC//G5Xc7UI2/YRYRK -W2XviQzdFKcgyxilJbQN+QHwotL0AMh0jqEqSI5l2xPE4iUXfeu+h1sXIFRRk0pT -AwvsXcoz7WL9RccvW9xYoIA55vrX/hMUpu09lEpCdNTDd1lzzY9GvlU47/rokTLq -l1gEIt44w8y8bckzOmoKaT+gyOpyj4xjhiO9bTyWnpXgSUyqorkqG5w2gXjtw+hG -4iZZRHUe2XWJUc0QhJ1hYMtd+ZciTY6Y5uN/9lu7rs3KSoFrXgvzUeF0K+l+J6fZ -mUlO+KWA2yUPHGNiiskzZ2s8EIPGrd6ozRaOjfAHN3Gf8qv8QfXBi+wAN10J5U6A -7/qxXDgGpRtK4dw4LTzcqx+QGtVKnO7RcGzM7vRX+Bi6hG6H ------END CERTIFICATE----- -# "IdenTrust Public Sector Root CA 1" -# 30 D0 89 5A 9A 44 8A 26 20 91 63 55 22 D1 F5 20 -# 10 B5 86 7A CA E1 2C 78 EF 95 8F D4 F4 38 9F 2F ------BEGIN CERTIFICATE----- -MIIFZjCCA06gAwIBAgIQCgFCgAAAAUUjz0Z8AAAAAjANBgkqhkiG9w0BAQsFADBN -MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MSowKAYDVQQDEyFJZGVu -VHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwHhcNMTQwMTE2MTc1MzMyWhcN -MzQwMTE2MTc1MzMyWjBNMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0 -MSowKAYDVQQDEyFJZGVuVHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwggIi -MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2IpT8pEiv6EdrCvsnduTyP4o7 -ekosMSqMjbCpwzFrqHd2hCa2rIFCDQjrVVi7evi8ZX3yoG2LqEfpYnYeEe4IFNGy -RBb06tD6Hi9e28tzQa68ALBKK0CyrOE7S8ItneShm+waOh7wCLPQ5CQ1B5+ctMlS -bdsHyo+1W/CD80/HLaXIrcuVIKQxKFdYWuSNG5qrng0M8gozOSI5Cpcu81N3uURF -/YTLNiCBWS2ab21ISGHKTN9T0a9SvESfqy9rg3LvdYDaBjMbXcjaY8ZNzaxmMc3R -3j6HEDbhuaR672BQssvKplbgN6+rNBM5Jeg5ZuSYeqoSmJxZZoY+rfGwyj4GD3vw -EUs3oERte8uojHH01bWRNszwFcYr3lEXsZdMUD2xlVl8BX0tIdUAvwFnol57plzy -9yLxkA2T26pEUWbMfXYD62qoKjgZl3YNa4ph+bz27nb9cCvdKTz4Ch5bQhyLVi9V -GxyhLrXHFub4qjySjmm2AcG1hp2JDws4lFTo6tyePSW8Uybt1as5qsVATFSrsrTZ -2fjXctscvG29ZV/viDUqZi/u9rNl8DONfJhBaUYPQxxp+pu10GFqzcpL2UyQRqsV -WaFHVCkugyhfHMKiq3IXAAaOReyL4jM9f9oZRORicsPfIsbyVtTdX5Vy7W1f90gD -W/3FKqD2cyOEEBsB5wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/ -BAUwAwEB/zAdBgNVHQ4EFgQU43HgntinQtnbcZFrlJPrw6PRFKMwDQYJKoZIhvcN -AQELBQADggIBAEf63QqwEZE4rU1d9+UOl1QZgkiHVIyqZJnYWv6IAcVYpZmxI1Qj -t2odIFflAWJBF9MJ23XLblSQdf4an4EKwt3X9wnQW3IV5B4Jaj0z8yGa5hV+rVHV -DRDtfULAj+7AmgjVQdZcDiFpboBhDhXAuM/FSRJSzL46zNQuOAXeNf0fb7iAaJg9 -TaDKQGXSc3z1i9kKlT/YPyNtGtEqJBnZhbMX73huqVjRI9PHE+1yJX9dsXNw0H8G -lwmEKYBhHfpe/3OsoOOJuBxxFcbeMX8S3OFtm6/n6J91eEyrRjuazr8FGF1NFTwW -mhlQBJqymm9li1JfPFgEKCXAZmExfrngdbkaqIHWchezxQMxNRF4eKLg6TCMf4Df -WN88uieW4oA0beOY02QnrEh+KHdcxiVhJfiFDGX6xDIvpZgF5PgLZxYWxoK4Mhn5 -+bl53B/N66+rDt0b20XkeucC4pVd/GnwU2lhlXV5C15V5jgclKlZM57IcXR5f1GJ -tshquDDIajjDbp7hNxbqBWJMWxJH7ae0s1hWx0nzfxJoCTFx8G34Tkf71oXuxVhA -GaQdp/lLQzfcaFpPz+vCZHTetBXZ9FRUGi8c15dxVJCO2SCdUyt/q4/i6jC8UDfv -8Ue1fXwsBOxonbRJRBD0ckscZOf85muQ3Wl9af0AVqW3rLatt8o+Ae+c ------END CERTIFICATE----- -# "ISRG Root X1" -# 96 BC EC 06 26 49 76 F3 74 60 77 9A CF 28 C5 A7 -# CF E8 A3 C0 AA E1 1A 8F FC EE 05 C0 BD DF 08 C6 ------BEGIN CERTIFICATE----- -MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw -TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh -cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4 -WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu -ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY -MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc -h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+ -0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U -A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW -T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH -B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC -B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv -KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn -OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn -jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw -qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI -rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV -HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq -hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL -ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ -3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK -NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5 -ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur -TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC -jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc -oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq -4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA -mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d -emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc= ------END CERTIFICATE----- -# "Izenpe.com" -# 23 80 42 03 CA 45 D8 CD E7 16 B8 C1 3B F3 B4 48 -# 45 7F A0 6C C1 02 50 99 7F A0 14 58 31 7C 41 E5 ------BEGIN CERTIFICATE----- -MIIF8DCCA9igAwIBAgIPBuhGJy8fCo/RhFzjafbVMA0GCSqGSIb3DQEBBQUAMDgx -CzAJBgNVBAYTAkVTMRQwEgYDVQQKDAtJWkVOUEUgUy5BLjETMBEGA1UEAwwKSXpl -bnBlLmNvbTAeFw0wNzEyMTMxMzA4MjdaFw0zNzEyMTMwODI3MjVaMDgxCzAJBgNV -BAYTAkVTMRQwEgYDVQQKDAtJWkVOUEUgUy5BLjETMBEGA1UEAwwKSXplbnBlLmNv -bTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMnTesoPHqynhugWZWqx -whtFMnGV2f4QW8yv56V5AY+Jw8ryVXH3d753lPNypCxE2J6SmxQ6oeckkAoKVo7F -2CaU4dlI4S0+2gpy3aOZFdqBoof0e24md4lYrdbrDLJBenNubdt6eEHpCIgSfocu -ZhFjbFT7PJ1ywLwu/8K33Q124zrX97RovqL144FuwUZvXY3gTcZUVYkaMzEKsVe5 -o4qYw+w7NMWVQWl+dcI8IMVhulFHoCCQk6GQS/NOfIVFVJrRBSZBsLVNHTO+xAPI -JXzBcNs79AktVCdIrC/hxKw+yMuSTFM5NyPs0wH54AlETU1kwOENWocivK0bo/4m -tRXzp/yEGensoYi0RGmEg/OJ0XQGqcwL1sLeJ4VQJsoXuMl6h1YsGgEebL4TrRCs -tST1OJGh1kva8bvS3ke18byB9llrzxlT6Y0Vy0rLqW9E5RtBz+GGp8rQap+8TI0G -M1qiheWQNaBiXBZO8OOi+gMatCxxs1gs3nsL2xoP694hHwZ3BgOwye+Z/MC5TwuG -KP7Suerj2qXDR2kS4Nvw9hmL7Xtw1wLW7YcYKCwEJEx35EiKGsY7mtQPyvp10gFA -Wo15v4vPS8+qFsGV5K1Mij4XkdSxYuWC5YAEpAN+jb/af6IPl08M0w3719Hlcn4c -yHf/W5oPt64FRuXxqBbsR6QXAgMBAAGjgfYwgfMwgbAGA1UdEQSBqDCBpYEPaW5m -b0BpemVucGUuY29tpIGRMIGOMUcwRQYDVQQKDD5JWkVOUEUgUy5BLiAtIENJRiBB -MDEzMzcyNjAtUk1lcmMuVml0b3JpYS1HYXN0ZWl6IFQxMDU1IEY2MiBTODFDMEEG -A1UECQw6QXZkYSBkZWwgTWVkaXRlcnJhbmVvIEV0b3JiaWRlYSAxNCAtIDAxMDEw -IFZpdG9yaWEtR2FzdGVpejAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB -BjAdBgNVHQ4EFgQUHRxlDqjyJXu0kc/ksbHmvVV0bAUwDQYJKoZIhvcNAQEFBQAD -ggIBAMeBRm8hGE+gBe/n1bqXUKJg7aWSFBpSm/nxiEqg3Hh10dUflU7F57dp5iL0 -+CmoKom+z892j+Mxc50m0xwbRxYpB2iEitL7sRskPtKYGCwkjq/2e+pEFhsqxPqg -l+nqbFik73WrAGLRne0TNtsiC7bw0fRue0aHwp28vb5CO7dz0JoqPLRbEhYArxk5 -ja2DUBzIgU+9Ag89njWW7u/kwgN8KRwCfr00J16vU9adF79XbOnQgxCvv11N75B7 -XSus7Op9ACYXzAJcY9cZGKfsK8eKPlgOiofmg59OsjQerFQJTx0CCzl+gQgVuaBp -E8gyK+OtbBPWg50jLbJtooiGfqgNASYJQNntKE6MkyQP2/EeTXp6WuKlWPHcj1+Z -ggwuz7LdmMySlD/5CbOlliVbN/UShUHiGUzGigjB3Bh6Dx4/glmimj4/+eAJn/3B -kUtdyXvWton83x18hqrNA/ILUpLxYm9/h+qrdslsUMIZgq+qHfUgKGgu1fxkN0/P -pUTEvnK0jHS0bKf68r10OEMr3q/53NjgnZ/cPcqlY0S/kqJPTIAcuxrDmkoEVU3K -7iYLHL8CxWTTnn7S05EcS6L1HOUXHA0MUqORH5zwIe0ClG+poEnK6EOMxPQ02nwi -o8ZmPrgbBYhdurz3vOXcFD2nhqi2WVIhA16L4wTtSyoeo09Q ------END CERTIFICATE----- -# "Izenpe.com" -# 25 30 CC 8E 98 32 15 02 BA D9 6F 9B 1F BA 1B 09 -# 9E 2D 29 9E 0F 45 48 BB 91 4F 36 3B C0 D4 53 1F ------BEGIN CERTIFICATE----- -MIIF8TCCA9mgAwIBAgIQALC3WhZIX7/hy/WL1xnmfTANBgkqhkiG9w0BAQsFADA4 -MQswCQYDVQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6 -ZW5wZS5jb20wHhcNMDcxMjEzMTMwODI4WhcNMzcxMjEzMDgyNzI1WjA4MQswCQYD -VQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6ZW5wZS5j -b20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ03rKDx6sp4boFmVq -scIbRTJxldn+EFvMr+eleQGPicPK8lVx93e+d5TzcqQsRNiekpsUOqHnJJAKClaO -xdgmlOHZSOEtPtoKct2jmRXagaKH9HtuJneJWK3W6wyyQXpzbm3benhB6QiIEn6H -LmYRY2xU+zydcsC8Lv/Ct90NduM61/e0aL6i9eOBbsFGb12N4E3GVFWJGjMxCrFX -uaOKmMPsOzTFlUFpfnXCPCDFYbpRR6AgkJOhkEvzTnyFRVSa0QUmQbC1TR0zvsQD -yCV8wXDbO/QJLVQnSKwv4cSsPsjLkkxTOTcj7NMB+eAJRE1NZMDhDVqHIrytG6P+ -JrUV86f8hBnp7KGItERphIPzidF0BqnMC9bC3ieFUCbKF7jJeodWLBoBHmy+E60Q -rLUk9TiRodZL2vG70t5HtfG8gfZZa88ZU+mNFctKy6lvROUbQc/hhqfK0GqfvEyN -BjNaooXlkDWgYlwWTvDjovoDGrQscbNYLN57C9saD+veIR8GdwYDsMnvmfzAuU8L -hij+0rnq49qlw0dpEuDb8PYZi+17cNcC1u2HGCgsBCRMd+RIihrGO5rUD8r6ddIB -QFqNeb+Lz0vPqhbBleStTIo+F5HUsWLlguWABKQDfo2/2n+iD5dPDNMN+9fR5XJ+ -HMh3/1uaD7euBUbl8agW7EekFwIDAQABo4H2MIHzMIGwBgNVHREEgagwgaWBD2lu -Zm9AaXplbnBlLmNvbaSBkTCBjjFHMEUGA1UECgw+SVpFTlBFIFMuQS4gLSBDSUYg -QTAxMzM3MjYwLVJNZXJjLlZpdG9yaWEtR2FzdGVpeiBUMTA1NSBGNjIgUzgxQzBB -BgNVBAkMOkF2ZGEgZGVsIE1lZGl0ZXJyYW5lbyBFdG9yYmlkZWEgMTQgLSAwMTAx -MCBWaXRvcmlhLUdhc3RlaXowDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC -AQYwHQYDVR0OBBYEFB0cZQ6o8iV7tJHP5LGx5r1VdGwFMA0GCSqGSIb3DQEBCwUA -A4ICAQB4pgwWSp9MiDrAyw6lFn2fuUhfGI8NYjb2zRlrrKvV9pF9rnHzP7MOeIWb -laQnIUdCSnxIOvVFfLMMjlF4rJUT3sb9fbgakEyrkgPH7UIBzg/YsfqikuFgba56 -awmqxinuaElnMIAkejEWOVt+8Rwu3WwJrfIxwYJOubv5vr8qhT/AQKM6WfxZSzwo -JNu0FXWuDYi6LnPAvViH5ULy617uHjAimcs30cQhbIHsvm0m5hzkQiCeR7Csg1lw -LDXWrzY0tM07+DKo7+N4ifuNRSzanLh+QBxh5z6ikixL8s36mLYp//Pye6kfLqCT -VyvehQP5aTfLnnhqBbTFMXiJ7HqnheG5ezzevh55hM6fcA5ZwjUukCox2eRFekGk -LhObNA5me0mrZJfQRsN5nXJQY6aYWwa9SG3YOYNw6DXwBdGqvOPbyALqfP2C2sJb -UjWumDqtujWTI6cfSN01RpiyEGjkpTHCClguGYEQyVB1/OpaFs4R1+7vUIgtYf8/ -QnMFlEPVjjxOAToZpR9GTnfQXeWBIiGH/pR9hNiTrdZoQ0iy2+tzJOeRf1SktoA+ -naM8THLCV8Sg1Mw4J87VBp6iSNnpn86CcDaTmjvfliHjWbcM2pE38P1ZWrOZyGls -QyYBNWNgVYkDOnXYukrZVP/u3oDYLdE41V4tC5h9Pmzb/CaIxw== ------END CERTIFICATE----- -# "KISA RootCA 1" -# 6F DB 3F 76 C8 B8 01 A7 53 38 D8 A5 0A 7C 02 87 -# 9F 61 98 B5 7E 59 4D 31 8D 38 32 90 0F ED CD 79 ------BEGIN CERTIFICATE----- -MIIDczCCAlugAwIBAgIBBDANBgkqhkiG9w0BAQUFADBkMQswCQYDVQQGEwJLUjEN -MAsGA1UECgwES0lTQTEuMCwGA1UECwwlS29yZWEgQ2VydGlmaWNhdGlvbiBBdXRo -b3JpdHkgQ2VudHJhbDEWMBQGA1UEAwwNS0lTQSBSb290Q0EgMTAeFw0wNTA4MjQw -ODA1NDZaFw0yNTA4MjQwODA1NDZaMGQxCzAJBgNVBAYTAktSMQ0wCwYDVQQKDARL -SVNBMS4wLAYDVQQLDCVLb3JlYSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBDZW50 -cmFsMRYwFAYDVQQDDA1LSVNBIFJvb3RDQSAxMIIBIDANBgkqhkiG9w0BAQEFAAOC -AQ0AMIIBCAKCAQEAvATk+hM58DSWIGtsaLv623f/J/es7C/n/fB/bW+MKs0lCVsk -9KFo/CjsySXirO3eyDOE9bClCTqnsUdIxcxPjHmc+QZXfd3uOPbPFLKc6tPAXXdi -8EcNuRpAU1xkcK8IWsD3z3X5bI1kKB4g/rcbGdNaZoNy4rCbvdMlFQ0yb2Q3lIVG -yHK+d9VuHygvx2nt54OJM1jT3qC/QOhDUO7cTWu8peqmyGGO9cNkrwYV3CmLP3WM -vHFE2/yttRcdbYmDz8Yzvb9Fov4Kn6MRXw+5H5wawkbMnChmn3AmPC7fqoD+jMUE -CSVPzZNHPDfqAmeS/vwiJFys0izgXAEzisEZ2wIBA6MyMDAwHQYDVR0OBBYEFL+2 -J9gDWnZlTGEBQVYx5Yt7OtnMMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEF -BQADggEBABOvUQveimpb5poKyLGQSk6hAp3MiNKrZr097LuxQpVqslxa/6FjZJap -aBV/JV6K+KRzwYCKhQoOUugy50X4TmWAkZl0Q+VFnUkq8JSV3enhMNITbslOsXfl -BM+tWh6UCVrXPAgcrnrpFDLBRa3SJkhyrKhB2vAhhzle3/xk/2F0KpzZm4tfwjeT -2KM3LzuTa7IbB6d/CVDv0zq+IWuKkDsnSlFOa56ch534eJAx7REnxqhZvvwYC/uO -fi5C4e3nCSG9uRPFVmf0JqZCQ5BEVLRxm3bkGhKsGigA35vB1fjbXKP4krG9tNT5 -UNkAAk/bg9ART6RCVmE6fhMy04Qfybo= ------END CERTIFICATE----- -# "Microsec e-Szigno Root CA 2009" -# 3C 5F 81 FE A5 FA B8 2C 64 BF A2 EA EC AF CD E8 -# E0 77 FC 86 20 A7 CA E5 37 16 3D F3 6E DB F3 78 ------BEGIN CERTIFICATE----- -MIIECjCCAvKgAwIBAgIJAMJ+QwRORz8ZMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD -VQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFjAUBgNVBAoMDU1pY3Jvc2VjIEx0 -ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EgMjAwOTEfMB0G -CSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5odTAeFw0wOTA2MTYxMTMwMThaFw0y -OTEyMzAxMTMwMThaMIGCMQswCQYDVQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3Qx -FjAUBgNVBAoMDU1pY3Jvc2VjIEx0ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3pp -Z25vIFJvb3QgQ0EgMjAwOTEfMB0GCSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5o -dTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOn4j/NjrdqG2KfgQvvP -kd6mJviZpWNwrZuuyjNAfW2WbqEORO7hE52UQlKavXWFdCyoDh2Tthi3jCyoz/tc -cbna7P7ofo/kLx2yqHWH2Leh5TvPmUpG0IMZfcChEhyVbUr02MelTTMuhTlAdX4U -fIASmFDHQWe4oIBhVKZsTh/gnQ4H6cm6M+f+wFUoLAKApxn1ntxVUwOXewdI/5n7 -N4okxFnMUBBjjqqpGrCEGob5X7uxUG6k0QrM1XF+H6cbfPVTbiJfyyvm1HxdrtbC -xkzlBQHZ7Vf8wSN5/PrIJIOV87VqUQHQd9bpEqH5GoP7ghu5sJf0dgYzQ0mg/wu1 -+rUCAwEAAaOBgDB+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G -A1UdDgQWBBTLD8bfQkPMPcu1SCOhGnqmKrs0aDAfBgNVHSMEGDAWgBTLD8bfQkPM -Pcu1SCOhGnqmKrs0aDAbBgNVHREEFDASgRBpbmZvQGUtc3ppZ25vLmh1MA0GCSqG -SIb3DQEBCwUAA4IBAQDJ0Q5eLtXMs3w+y/w9/w0olZMEyL/azXm4Q5DwpL7v8u8h -mLzU1F0G9u5C7DBsoKqpyvGvivo/C3NqPuouQH4frlRheesuCDfXI/OMn74dseGk -ddug4lQUsbocKaQY9hK6ohQU4zE1yED/t+AFdlfBHFny+L/k7SViXITwfn4fs775 -tyERzAMBVnCnEJIeGzSBHq2cGsMEPO0CYdYeBvNfOofyK/FFh+U9rNHHV4S9a67c -2Pm2G2JwCz02yULyMtd6YebS2z3PyKnJm9zbWETXbzivf3jTo60adbocwTZ8jx5t -HMN1Rq41Bab2XD0h7lbwyYIiLXpUq3DDfSJlgnCW ------END CERTIFICATE----- -# "NetLock Arany (Class Gold) Főtanúsítvány" -# 6C 61 DA C3 A2 DE F0 31 50 6B E0 36 D2 A6 FE 40 -# 19 94 FB D1 3D F9 C8 D4 66 59 92 74 C4 46 EC 98 ------BEGIN CERTIFICATE----- -MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQG -EwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3 -MDUGA1UECwwuVGFuw7pzw610dsOhbnlraWFkw7NrIChDZXJ0aWZpY2F0aW9uIFNl -cnZpY2VzKTE1MDMGA1UEAwwsTmV0TG9jayBBcmFueSAoQ2xhc3MgR29sZCkgRsWR -dGFuw7pzw610dsOhbnkwHhcNMDgxMjExMTUwODIxWhcNMjgxMjA2MTUwODIxWjCB -pzELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRUwEwYDVQQKDAxOZXRM -b2NrIEtmdC4xNzA1BgNVBAsMLlRhbsO6c8OtdHbDoW55a2lhZMOzayAoQ2VydGlm -aWNhdGlvbiBTZXJ2aWNlcykxNTAzBgNVBAMMLE5ldExvY2sgQXJhbnkgKENsYXNz -IEdvbGQpIEbFkXRhbsO6c8OtdHbDoW55MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A -MIIBCgKCAQEAxCRec75LbRTDofTjl5Bu0jBFHjzuZ9lk4BqKf8owyoPjIMHj9DrT -lF8afFttvzBPhCf2nx9JvMaZCpDyD/V/Q4Q3Y1GLeqVw/HpYzY6b7cNGbIRwXdrz -AZAj/E4wqX7hJ2Pn7WQ8oLjJM2P+FpD/sLj916jAwJRDC7bVWaaeVtAkH3B5r9s5 -VA1lddkVQZQBr17s9o3x/61k/iCa11zr/qYfCGSji3ZVrR47KGAuhyXoqq8fxmRG -ILdwfzzeSNuWU7c5d+Qa4scWhHaXWy+7GRWF+GmF9ZmnqfI0p6m2pgP8b4Y9VHx2 -BJtr+UBdADTHLpl1neWIA6pN+APSQnbAGwIDAKiLo0UwQzASBgNVHRMBAf8ECDAG -AQH/AgEEMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUzPpnk/C2uNClwB7zU/2M -U9+D15YwDQYJKoZIhvcNAQELBQADggEBAKt/7hwWqZw8UQCgwBEIBaeZ5m8BiFRh -bvG5GK1Krf6BQCOUL/t1fC8oS2IkgYIL9WHxHG64YTjrgfpioTtaYtOUZcTh5m2C -+C8lcLIhJsFyUR+MLMOEkMNaj7rP9KdlpeuY0fsFskZ1FSNqb4VjMIDw1Z4fKRzC -bLBQWV2QWzuoDTDPv31/zvGdg73JRm4gpvlhUbohL3u+pRVjodSVh/GeufOJ8z2F -uLjbvrW5KfnaNwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2 -XjG4Kvte9nHfRCaexOYNkbQudZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E= ------END CERTIFICATE----- -# "Network Solutions Certificate Authority" -# 15 F0 BA 00 A3 AC 7A F3 AC 88 4C 07 2B 10 11 A0 -# 77 BD 77 C0 97 F4 01 64 B2 F8 59 8A BD 83 86 0C ------BEGIN CERTIFICATE----- -MIID5jCCAs6gAwIBAgIQV8szb8JcFuZHFhfjkDFo4DANBgkqhkiG9w0BAQUFADBi -MQswCQYDVQQGEwJVUzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMu -MTAwLgYDVQQDEydOZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3Jp -dHkwHhcNMDYxMjAxMDAwMDAwWhcNMjkxMjMxMjM1OTU5WjBiMQswCQYDVQQGEwJV -UzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMuMTAwLgYDVQQDEydO -ZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEiMA0GCSqG -SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDkvH6SMG3G2I4rC7xGzuAnlt7e+foS0zwz -c7MEL7xxjOWftiJgPl9dzgn/ggwbmlFQGiaJ3dVhXRncEg8tCqJDXRfQNJIg6nPP -OCwGJgl6cvf6UDL4wpPTaaIjzkGxzOTVHzbRijr4jGPiFFlp7Q3Tf2vouAPlT2rl -mGNpSAW+Lv8ztumXWWn4Zxmuk2GWRBXTcrA/vGp97Eh/jcOrqnErU2lBUzS1sLnF -BgrEsEX1QV1uiUV7PTsmjHTC5dLRfbIR1PtYMiKagMnc/Qzpf14Dl847ABSHJ3A4 -qY5usyd2mFHgBeMhqxrVhSI8KbWaFsWAqPS7azCPL0YCorEMIuDTAgMBAAGjgZcw -gZQwHQYDVR0OBBYEFCEwyfsA106Y2oeqKtCnLrFAMadMMA4GA1UdDwEB/wQEAwIB -BjAPBgNVHRMBAf8EBTADAQH/MFIGA1UdHwRLMEkwR6BFoEOGQWh0dHA6Ly9jcmwu -bmV0c29sc3NsLmNvbS9OZXR3b3JrU29sdXRpb25zQ2VydGlmaWNhdGVBdXRob3Jp -dHkuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQC7rkvnt1frf6ott3NHhWrB5KUd5Oc8 -6fRZZXe1eltajSU24HqXLjjAV2CDmAaDn7l2em5Q4LqILPxFzBiwmZVRDuwduIj/ -h1AcgsLj4DKAv6ALR8jDMe+ZZzKATxcheQxpXN5eNK4CtSbqUN9/GGUsyfJj4akH -/nxxH2szJGoeBfcFaMBqEssuXmHLrijTfsK0ZpEmXzwuJF/LWA/rKOyvEZbz3Htv -wKeI8lN3s2Berq4o2jUsbzRF0ybh3uxbTydrFny9RAQYgrOJeRcQcT16ohZO9QHN -pGxlaKFJdlxDydi8NmdspZS11My5vWo1ViHe2MPr+8ukYEywVaCge1ey ------END CERTIFICATE----- -# "OISTE WISeKey Global Root GA CA" -# 41 C9 23 86 6A B4 CA D6 B7 AD 57 80 81 58 2E 02 -# 07 97 A6 CB DF 4F FF 78 CE 83 96 B3 89 37 D7 F5 ------BEGIN CERTIFICATE----- -MIID8TCCAtmgAwIBAgIQQT1yx/RrH4FDffHSKFTfmjANBgkqhkiG9w0BAQUFADCB -ijELMAkGA1UEBhMCQ0gxEDAOBgNVBAoTB1dJU2VLZXkxGzAZBgNVBAsTEkNvcHly -aWdodCAoYykgMjAwNTEiMCAGA1UECxMZT0lTVEUgRm91bmRhdGlvbiBFbmRvcnNl -ZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwgUm9vdCBHQSBDQTAeFw0w -NTEyMTExNjAzNDRaFw0zNzEyMTExNjA5NTFaMIGKMQswCQYDVQQGEwJDSDEQMA4G -A1UEChMHV0lTZUtleTEbMBkGA1UECxMSQ29weXJpZ2h0IChjKSAyMDA1MSIwIAYD -VQQLExlPSVNURSBGb3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBX -SVNlS2V5IEdsb2JhbCBSb290IEdBIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A -MIIBCgKCAQEAy0+zAJs9Nt350UlqaxBJH+zYK7LG+DKBKUOVTJoZIyEVRd7jyBxR -VVuuk+g3/ytr6dTqvirdqFEr12bDYVxgAsj1znJ7O7jyTmUIms2kahnBAbtzptf2 -w93NvKSLtZlhuAGio9RN1AU9ka34tAhxZK9w8RxrfvbDd50kc3vkDIzh2TbhmYsF -mQvtRTEJysIA2/dyoJaqlYfQjse2YXMNdmaM3Bu0Y6Kff5MTMPGhJ9vZ/yxViJGg -4E8HsChWjBgbl0SOid3gF27nKu+POQoxhILYQBRJLnpB5Kf+42TMwVlxSywhp1t9 -4B3RLoGbw9ho972WG6xwsRYUC9tguSYBBQIDAQABo1EwTzALBgNVHQ8EBAMCAYYw -DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUswN+rja8sHnR3JQmthG+IbJphpQw -EAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBAEuh/wuHbrP5wUOx -SPMowB0uyQlB+pQAHKSkq0lPjz0e701vvbyk9vImMMkQyh2I+3QZH4VFvbBsUfk2 -ftv1TDI6QU9bR8/oCy22xBmddMVHxjtqD6wU2zz0c5ypBd8A3HR4+vg1YFkCExh8 -vPtNsCBtQ7tgMHpnM1zFmdH4LTlSc/uMqpclXHLZCB6rTjzjgTGfA6b7wP4piFXa -hNVQA7bihKOmNqoROgHhGEvWRGizPflTdISzRpFGlgC3gCy24eMQ4tui5yiPAZZi -Fj4A4xylNoEYokxSdsARo27mHbrjWr42U8U+dY+GaSlYU7Wcu2+fXMUY7N0v4ZjJ -/L7fCg0= ------END CERTIFICATE----- -# "OISTE WISeKey Global Root GB CA" -# 6B 9C 08 E8 6E B0 F7 67 CF AD 65 CD 98 B6 21 49 -# E5 49 4A 67 F5 84 5E 7B D1 ED 01 9F 27 B8 6B D6 ------BEGIN CERTIFICATE----- -MIIDtTCCAp2gAwIBAgIQdrEgUnTwhYdGs/gjGvbCwDANBgkqhkiG9w0BAQsFADBt -MQswCQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUg -Rm91bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9i -YWwgUm9vdCBHQiBDQTAeFw0xNDEyMDExNTAwMzJaFw0zOTEyMDExNTEwMzFaMG0x -CzAJBgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBG -b3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2Jh -bCBSb290IEdCIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2Be3 -HEokKtaXscriHvt9OO+Y9bI5mE4nuBFde9IllIiCFSZqGzG7qFshISvYD06fWvGx -WuR51jIjK+FTzJlFXHtPrby/h0oLS5daqPZI7H17Dc0hBt+eFf1Biki3IPShehtX -1F1Q/7pn2COZH8g/497/b1t3sWtuuMlk9+HKQUYOKXHQuSP8yYFfTvdv37+ErXNk -u7dCjmn21HYdfp2nuFeKUWdy19SouJVUQHMD9ur06/4oQnc/nSMbsrY9gBQHTC5P -99UKFg29ZkM3fiNDecNAhvVMKdqOmq0NpQSHiB6F4+lT1ZvIiwNjeOvgGUpuuy9r -M2RYk61pv48b74JIxwIDAQABo1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUw -AwEB/zAdBgNVHQ4EFgQUNQ/INmNe4qPs+TtmFc5RUuORmj0wEAYJKwYBBAGCNxUB -BAMCAQAwDQYJKoZIhvcNAQELBQADggEBAEBM+4eymYGQfp3FsLAmzYh7KzKNbrgh -cViXfa43FK8+5/ea4n32cZiZBKpDdHij40lhPnOMTZTg+XHEthYOU3gf1qKHLwI5 -gSk8rxWYITD+KJAAjNHhy/peyP34EEY7onhCkRd0VQreUGdNZtGn//3ZwLWoo4rO -ZvUPQ82nK1d7Y0Zqqi5S2PTt4W2tKZB4SLrhI6qjiey1q5bAtEuiHZeeevJuQHHf -aPFlTc58Bd9TZaml8LGXBHAVRgOY1NK/VLSgWH1Sb9pWJmLU2NuJMW8c8CLC02Ic -Nc1MaRVUGpCY3useX8p3x8uOPUNpnJpY0CQ73xtAln41rYHHTnG6iBM= ------END CERTIFICATE----- -# "OISTE WISeKey Global Root GC CA" -# 85 60 F9 1C 36 24 DA BA 95 70 B5 FE A0 DB E3 6F -# F1 1A 83 23 BE 94 86 85 4F B3 F3 4A 55 71 19 8D ------BEGIN CERTIFICATE----- -MIICaTCCAe+gAwIBAgIQISpWDK7aDKtARb8roi066jAKBggqhkjOPQQDAzBtMQsw -CQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUgRm91 -bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwg -Um9vdCBHQyBDQTAeFw0xNzA1MDkwOTQ4MzRaFw00MjA1MDkwOTU4MzNaMG0xCzAJ -BgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBGb3Vu -ZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2JhbCBS -b290IEdDIENBMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAETOlQwMYPchi82PG6s4ni -eUqjFqdrVCTbUf/q9Akkwwsin8tqJ4KBDdLArzHkdIJuyiXZjHWd8dvQmqJLIX4W -p2OQ0jnUsYd4XxiWD1AbNTcPasbc2RNNpI6QN+a9WzGRo1QwUjAOBgNVHQ8BAf8E -BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSIcUrOPDnpBgOtfKie7T -rYy0UGYwEAYJKwYBBAGCNxUBBAMCAQAwCgYIKoZIzj0EAwMDaAAwZQIwJsdpW9zV -57LnyAyMjMPdeYwbY9XJUpROTYJKcx6ygISpJcBMWm1JKWB4E+J+SOtkAjEA2zQg -Mgj/mkkCtojeFK9dbJlxjRo/i9fgojaGHAeCOnZT/cKi7e97sIBPWA9LUzm9 ------END CERTIFICATE----- -# "OpenTrust Root CA G1" -# 56 C7 71 28 D9 8C 18 D9 1B 4C FD FF BC 25 EE 91 -# 03 D4 75 8E A2 AB AD 82 6A 90 F3 45 7D 46 0E B4 ------BEGIN CERTIFICATE----- -MIIFbzCCA1egAwIBAgISESCzkFU5fX82bWTCp59rY45nMA0GCSqGSIb3DQEBCwUA -MEAxCzAJBgNVBAYTAkZSMRIwEAYDVQQKDAlPcGVuVHJ1c3QxHTAbBgNVBAMMFE9w -ZW5UcnVzdCBSb290IENBIEcxMB4XDTE0MDUyNjA4NDU1MFoXDTM4MDExNTAwMDAw -MFowQDELMAkGA1UEBhMCRlIxEjAQBgNVBAoMCU9wZW5UcnVzdDEdMBsGA1UEAwwU -T3BlblRydXN0IFJvb3QgQ0EgRzEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK -AoICAQD4eUbalsUwXopxAy1wpLuwxQjczeY1wICkES3d5oeuXT2R0odsN7faYp6b -wiTXj/HbpqbfRm9RpnHLPhsxZ2L3EVs0J9V5ToybWL0iEA1cJwzdMOWo010hOHQX -/uMftk87ay3bfWAfjH1MBcLrARYVmBSO0ZB3Ij/swjm4eTrwSSTilZHcYTSSjFR0 -77F9jAHiOH3BX2pfJLKOYheteSCtqx234LSWSE9mQxAGFiQD4eCcjsZGT44ameGP -uY4zbGneWK2gDqdkVBFpRGZPTBKnjix9xNRbxQA0MMHZmf4yzgeEtE7NCv82TWLx -p2NX5Ntqp66/K7nJ5rInieV+mhxNaMbBGN4zK1FGSxyO9z0M+Yo0FMT7MzUj8czx -Kselu7Cizv5Ta01BG2Yospb6p64KTrk5M0ScdMGTHPjgniQlQ/GbI4Kq3ywgsNw2 -TgOzfALU5nsaqocTvz6hdLubDuHAk5/XpGbKuxs74zD0M1mKB3IDVedzagMxbm+W -G+Oin6+Sx+31QrclTDsTBM8clq8cIqPQqwWyTBIjUtz9GVsnnB47ev1CI9sjgBPw -vFEVVJSmdz7QdFG9URQIOTfLHzSpMJ1ShC5VkLG631UAC9hWLbFJSXKAqWLXwPYY -EQRVzXR7z2FwefR7LFxckvzluFqrTJOVoSfupb7PcSNCupt2LQIDAQABo2MwYTAO -BgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUl0YhVyE1 -2jZVx/PxN3DlCPaTKbYwHwYDVR0jBBgwFoAUl0YhVyE12jZVx/PxN3DlCPaTKbYw -DQYJKoZIhvcNAQELBQADggIBAB3dAmB84DWn5ph76kTOZ0BP8pNuZtQ5iSas000E -PLuHIT839HEl2ku6q5aCgZG27dmxpGWX4m9kWaSW7mDKHyP7Rbr/jyTwyqkxf3kf -gLMtMrpkZ2CvuVnN35pJ06iCsfmYlIrM4LvgBBuZYLFGZdwIorJGnkSI6pN+VxbS -FXJfLkur1J1juONI5f6ELlgKn0Md/rcYkoZDSw6cMoYsYPXpSOqV7XAp8dUv/TW0 -V8/bhUiZucJvbI/NeJWsZCj9VrDDb8O+WVLhX4SPgPL0DTatdrOjteFkdjpY3H1P -XlZs5VVZV6Xf8YpmMIzUUmI4d7S+KNfKNsSbBfD4Fdvb8e80nR14SohWZ25g/4/I -i+GOvUKpMwpZQhISKvqxnUOOBZuZ2mKtVzazHbYNeS2WuOvyDEsMpZTGMKcmGS3t -TAZQMPH9WD25SxdfGbRqhFS0OE85og2WaMMolP3tLR9Ka0OWLpABEPs4poEL0L91 -09S5zvE/bw4cHjdx5RiHdRk/ULlepEU0rbDK5uUTdg8xFKmOLZTW1YVNcxVPS/Ky -Pu1svf0OnWZzsD2097+o4BGkxK51CUpjAEggpsadCwmKtODmzj7HPiY46SvepghJ -AwSQiumPv+i2tCqjI40cHLI5kqiPAlxAOXXUc0ECd97N4EOH1uS6SsNsEn/+KuYj -1oxx ------END CERTIFICATE----- -# "OpenTrust Root CA G2" -# 27 99 58 29 FE 6A 75 15 C1 BF E8 48 F9 C4 76 1D -# B1 6C 22 59 29 25 7B F4 0D 08 94 F2 9E A8 BA F2 ------BEGIN CERTIFICATE----- -MIIFbzCCA1egAwIBAgISESChaRu/vbm9UpaPI+hIvyYRMA0GCSqGSIb3DQEBDQUA -MEAxCzAJBgNVBAYTAkZSMRIwEAYDVQQKDAlPcGVuVHJ1c3QxHTAbBgNVBAMMFE9w -ZW5UcnVzdCBSb290IENBIEcyMB4XDTE0MDUyNjAwMDAwMFoXDTM4MDExNTAwMDAw -MFowQDELMAkGA1UEBhMCRlIxEjAQBgNVBAoMCU9wZW5UcnVzdDEdMBsGA1UEAwwU -T3BlblRydXN0IFJvb3QgQ0EgRzIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK -AoICAQDMtlelM5QQgTJT32F+D3Y5z1zCU3UdSXqWON2ic2rxb95eolq5cSG+Ntmh -/LzubKh8NBpxGuga2F8ORAbtp+Dz0mEL4DKiltE48MLaARf85KxP6O6JHnSrT78e -CbY2albz4e6WiWYkBuTNQjpK3eCasMSCRbP+yatcfD7J6xcvDH1urqWPyKwlCm/6 -1UWY0jUJ9gNDlP7ZvyCVeYCYitmJNbtRG6Q3ffyZO6v/v6wNj0OxmXsWEH4db0fE -FY8ElggGQgT4hNYdvJGmQr5J1WqIP7wtUdGejeBSzFfdNTVY27SPJIjki9/ca1TS -gSuyzpJLHB9G+h3Ykst2Z7UJmQnlrBcUVXDGPKBWCgOz3GIZ38i1MH/1PCZ1Eb3X -G7OHngevZXHloM8apwkQHZOJZlvoPGIytbU6bumFAYueQ4xncyhZW+vj3CzMpSZy -YhK05pyDRPZRpOLAeiRXyg6lPzq1O4vldu5w5pLeFlwoW5cZJ5L+epJUzpM5ChaH -vGOz9bGTXOBut9Dq+WIyiET7vycotjCVXRIouZW+j1MY5aIYFuJWpLIsEPUdN6b4 -t/bQWVyJ98LVtZR00dX+G7bw5tYee9I8y6jj9RjzIR9u701oBnstXW5DiabA+aC/ -gh7PU3+06yzbXfZqfUAkBXKJOAGTy3HCOV0GEfZvePg3DTmEJwIDAQABo2MwYTAO -BgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUajn6QiL3 -5okATV59M4PLuG53hq8wHwYDVR0jBBgwFoAUajn6QiL35okATV59M4PLuG53hq8w -DQYJKoZIhvcNAQENBQADggIBAJjLq0A85TMCl38th6aP1F5Kr7ge57tx+4BkJamz -Gj5oXScmp7oq4fBXgwpkTx4idBvpkF/wrM//T2h6OKQQbA2xx6R3gBi2oihEdqc0 -nXGEL8pZ0keImUEiyTCYYW49qKgFbdEfwFFEVn8nNQLdXpgKQuswv42hm1GqO+qT -RmTFAHneIWv2V6CG1wZy7HBGS4tz3aAhdT7cHcCP009zHIXZ/n9iyJVvttN7jLpT -wm+bREx50B1ws9efAvSyB7DH5fitIw6mVskpEndI2S9G/Tvw/HRwkqWOOAgfZDC2 -t0v7NqwQjqBSM2OdAzVWxWm9xiNaJ5T2pBL4LTM8oValX9YZ6e18CL13zSdkzJTa -TkZQh+D5wVOAHrut+0dSixv9ovneDiK3PTNZbNTe9ZUGMg1RGUFcPk8G97krgCf2 -o6p6fAbhQ8MTOWIaNr3gKC6UAuQpLmBVrkA9sHSSXvAgZJY/X0VdiLWK2gKgW0VU -3jg9CcCoSmVGFvyqv1ROTVu+OEO3KMqLM6oaJbolXCkvW0pujOotnCr2BXbgd5eA -iN1nE28daCSLT7d0geX0YJ96Vdc+N9oWaz53rK4YcJUIeSkDiv7BO7M/Gg+kO14f -WKGVyasvc0rQLW6aWQ9VGHgtPFGml4vmu7JwqkwR3v98KzfUetF3NI/n+UL3PIEM -S1IK ------END CERTIFICATE----- -# "OpenTrust Root CA G3" -# B7 C3 62 31 70 6E 81 07 8C 36 7C B8 96 19 8F 1E -# 32 08 DD 92 69 49 DD 8F 57 09 A4 10 F7 5B 62 92 ------BEGIN CERTIFICATE----- -MIICITCCAaagAwIBAgISESDm+Ez8JLC+BUCs2oMbNGA/MAoGCCqGSM49BAMDMEAx -CzAJBgNVBAYTAkZSMRIwEAYDVQQKDAlPcGVuVHJ1c3QxHTAbBgNVBAMMFE9wZW5U -cnVzdCBSb290IENBIEczMB4XDTE0MDUyNjAwMDAwMFoXDTM4MDExNTAwMDAwMFow -QDELMAkGA1UEBhMCRlIxEjAQBgNVBAoMCU9wZW5UcnVzdDEdMBsGA1UEAwwUT3Bl -blRydXN0IFJvb3QgQ0EgRzMwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAARK7liuTcpm -3gY6oxH84Bjwbhy6LTAMidnW7ptzg6kjFYwvWYpa3RTqnVkrQ7cG7DK2uu5Bta1d -oYXM6h0UZqNnfkbilPPntlahFVmhTzeXuSIevRHr9LIfXsMUmuXZl5mjYzBhMA4G -A1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRHd8MUi2I5 -DMlv4VBN0BBY3JWIbTAfBgNVHSMEGDAWgBRHd8MUi2I5DMlv4VBN0BBY3JWIbTAK -BggqhkjOPQQDAwNpADBmAjEAj6jcnboMBBf6Fek9LykBl7+BFjNAk2z8+e2AcG+q -j9uEwov1NcoG3GRvaBbhj5G5AjEA2Euly8LQCGzpGPta3U1fJAuwACEl74+nBCZx -4nxp5V2a+EEfOzmTk51V6s2N8fvB ------END CERTIFICATE----- -# "QuoVadis Root CA 1 G3" -# 8A 86 6F D1 B2 76 B5 7E 57 8E 92 1C 65 82 8A 2B -# ED 58 E9 F2 F2 88 05 41 34 B7 F1 F4 BF C9 CC 74 ------BEGIN CERTIFICATE----- -MIIFYDCCA0igAwIBAgIUeFhfLq0sGUvjNwc1NBMotZbUZZMwDQYJKoZIhvcNAQEL -BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc -BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMSBHMzAeFw0xMjAxMTIxNzI3NDRaFw00 -MjAxMTIxNzI3NDRaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM -aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDEgRzMwggIiMA0GCSqG -SIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvlAQjunybEC0BJyFuTHK3C3kEakEPBtV -wedYMB0ktMPvhd6MLOHBPd+C5k+tR4ds7FtJwUrVu4/sh6x/gpqG7D0DmVIB0jWe -rNrwU8lmPNSsAgHaJNM7qAJGr6Qc4/hzWHa39g6QDbXwz8z6+cZM5cOGMAqNF341 -68Xfuw6cwI2H44g4hWf6Pser4BOcBRiYz5P1sZK0/CPTz9XEJ0ngnjybCKOLXSoh -4Pw5qlPafX7PGglTvF0FBM+hSo+LdoINofjSxxR3W5A2B4GbPgb6Ul5jxaYA/qXp -UhtStZI5cgMJYr2wYBZupt0lwgNm3fME0UDiTouG9G/lg6AnhF4EwfWQvTA9xO+o -abw4m6SkltFi2mnAAZauy8RRNOoMqv8hjlmPSlzkYZqn0ukqeI1RPToV7qJZjqlc -3sX5kCLliEVx3ZGZbHqfPT2YfF72vhZooF6uCyP8Wg+qInYtyaEQHeTTRCOQiJ/G -KubX9ZqzWB4vMIkIG1SitZgj7Ah3HJVdYdHLiZxfokqRmu8hqkkWCKi9YSgxyXSt -hfbZxbGL0eUQMk1fiyA6PEkfM4VZDdvLCXVDaXP7a3F98N/ETH3Goy7IlXnLc6KO -Tk0k+17kBL5yG6YnLUlamXrXXAkgt3+UuU/xDRxeiEIbEbfnkduebPRq34wGmAOt -zCjvpUfzUwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB -BjAdBgNVHQ4EFgQUo5fW816iEOGrRZ88F2Q87gFwnMwwDQYJKoZIhvcNAQELBQAD -ggIBABj6W3X8PnrHX3fHyt/PX8MSxEBd1DKquGrX1RUVRpgjpeaQWxiZTOOtQqOC -MTaIzen7xASWSIsBx40Bz1szBpZGZnQdT+3Btrm0DWHMY37XLneMlhwqI2hrhVd2 -cDMT/uFPpiN3GPoajOi9ZcnPP/TJF9zrx7zABC4tRi9pZsMbj/7sPtPKlL92CiUN -qXsCHKnQO18LwIE6PWThv6ctTr1NxNgpxiIY0MWscgKCP6o6ojoilzHdCGPDdRS5 -YCgtW2jgFqlmgiNR9etT2DGbe+m3nUvriBbP+V04ikkwj+3x6xn0dxoxGE1nVGwv -b2X52z3sIexe9PSLymBlVNFxZPT5pqOBMzYzcfCkeF9OrYMh3jRJjehZrJ3ydlo2 -8hP0r+AJx2EqbPfgna67hkooby7utHnNkDPDs3b69fBsnQGQ+p6Q9pxyz0fawx/k -NSBT8lTR32GDpgLiJTjehTItXnOQUl1CxM49S+H5GYQd1aJQzEH7QRTDvdbJWqNj -ZgKAvQU6O0ec7AAmTPWIUb+oI38YB7AL7YsmoWTTYUrrXJ/es69nA7Mf3W1daWhp -q1467HxpvMc7hU6eFbm0FU/DlXpY18ls6Wy58yljXrQs8C097Vpl4KlbQMJImYFt -nh8GKjwStIsPm6Ik8KaN1nrgS7ZklmOVhMJKzRwuJIczYOXD ------END CERTIFICATE----- -# "QuoVadis Root CA 2" -# 85 A0 DD 7D D7 20 AD B7 FF 05 F8 3D 54 2B 20 9D -# C7 FF 45 28 F7 D6 77 B1 83 89 FE A5 E5 C4 9E 86 ------BEGIN CERTIFICATE----- -MIIFtzCCA5+gAwIBAgICBQkwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x -GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv -b3QgQ0EgMjAeFw0wNjExMjQxODI3MDBaFw0zMTExMjQxODIzMzNaMEUxCzAJBgNV -BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W -YWRpcyBSb290IENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCa -GMpLlA0ALa8DKYrwD4HIrkwZhR0In6spRIXzL4GtMh6QRr+jhiYaHv5+HBg6XJxg -Fyo6dIMzMH1hVBHL7avg5tKifvVrbxi3Cgst/ek+7wrGsxDp3MJGF/hd/aTa/55J -WpzmM+Yklvc/ulsrHHo1wtZn/qtmUIttKGAr79dgw8eTvI02kfN/+NsRE8Scd3bB -rrcCaoF6qUWD4gXmuVbBlDePSHFjIuwXZQeVikvfj8ZaCuWw419eaxGrDPmF60Tp -+ARz8un+XJiM9XOva7R+zdRcAitMOeGylZUtQofX1bOQQ7dsE/He3fbE+Ik/0XX1 -ksOR1YqI0JDs3G3eicJlcZaLDQP9nL9bFqyS2+r+eXyt66/3FsvbzSUr5R/7mp/i -Ucw6UwxI5g69ybR2BlLmEROFcmMDBOAENisgGQLodKcftslWZvB1JdxnwQ5hYIiz -PtGo/KPaHbDRsSNU30R2be1B2MGyIrZTHN81Hdyhdyox5C315eXbyOD/5YDXC2Og -/zOhD7osFRXql7PSorW+8oyWHhqPHWykYTe5hnMz15eWniN9gqRMgeKh0bpnX5UH -oycR7hYQe7xFSkyyBNKr79X9DFHOUGoIMfmR2gyPZFwDwzqLID9ujWc9Otb+fVuI -yV77zGHcizN300QyNQliBJIWENieJ0f7OyHj+OsdWwIDAQABo4GwMIGtMA8GA1Ud -EwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMB0GA1UdDgQWBBQahGK8SEwzJQTU7tD2 -A8QZRtGUazBuBgNVHSMEZzBlgBQahGK8SEwzJQTU7tD2A8QZRtGUa6FJpEcwRTEL -MAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMT -ElF1b1ZhZGlzIFJvb3QgQ0EgMoICBQkwDQYJKoZIhvcNAQEFBQADggIBAD4KFk2f -BluornFdLwUvZ+YTRYPENvbzwCYMDbVHZF34tHLJRqUDGCdViXh9duqWNIAXINzn -g/iN/Ae42l9NLmeyhP3ZRPx3UIHmfLTJDQtyU/h2BwdBR5YM++CCJpNVjP4iH2Bl -fF/nJrP3MpCYUNQ3cVX2kiF495V5+vgtJodmVjB3pjd4M1IQWK4/YY7yarHvGH5K -WWPKjaJW1acvvFYfzznB4vsKqBUsfU16Y8Zsl0Q80m/DShcK+JDSV6IZUaUtl0Ha -B0+pUNqQjZRG4T7wlP0QADj1O+hA4bRuVhogzG9Yje0uRY/W6ZM/57Es3zrWIozc -hLsib9D45MY56QSIPMO661V6bYCZJPVsAfv4l7CUW+v90m/xd2gNNWQjrLhVoQPR -TUIZ3Ph1WVaj+ahJefivDrkRoHy3au000LYmYjgahwz46P0u05B/B5EqHdZ+XIWD -mbA4CD/pXvk1B+TJYm5Xf6dQlfe6yJvmjqIBxdZmv3lh8zwc4bmCXF2gw+nYSL0Z -ohEUGW6yhhtoPkg3Goi3XZZenMfvJ2II4pEZXNLxId26F0KCl3GBUzGpn/Z9Yr9y -4aOTHcyKJloJONDO1w2AFrR4pTqHTI2KpdVGl/IsELm8VCLAAVBpQ570su9t+Oza -8eOx79+Rj1QqCyXBJhnEUhAFZdWCEOrCMc0u ------END CERTIFICATE----- -# "QuoVadis Root CA 2 G3" -# 8F E4 FB 0A F9 3A 4D 0D 67 DB 0B EB B2 3E 37 C7 -# 1B F3 25 DC BC DD 24 0E A0 4D AF 58 B4 7E 18 40 ------BEGIN CERTIFICATE----- -MIIFYDCCA0igAwIBAgIURFc0JFuBiZs18s64KztbpybwdSgwDQYJKoZIhvcNAQEL -BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc -BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMiBHMzAeFw0xMjAxMTIxODU5MzJaFw00 -MjAxMTIxODU5MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM -aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDIgRzMwggIiMA0GCSqG -SIb3DQEBAQUAA4ICDwAwggIKAoICAQChriWyARjcV4g/Ruv5r+LrI3HimtFhZiFf -qq8nUeVuGxbULX1QsFN3vXg6YOJkApt8hpvWGo6t/x8Vf9WVHhLL5hSEBMHfNrMW -n4rjyduYNM7YMxcoRvynyfDStNVNCXJJ+fKH46nafaF9a7I6JaltUkSs+L5u+9ym -c5GQYaYDFCDy54ejiK2toIz/pgslUiXnFgHVy7g1gQyjO/Dh4fxaXc6AcW34Sas+ -O7q414AB+6XrW7PFXmAqMaCvN+ggOp+oMiwMzAkd056OXbxMmO7FGmh77FOm6RQ1 -o9/NgJ8MSPsc9PG/Srj61YxxSscfrf5BmrODXfKEVu+lV0POKa2Mq1W/xPtbAd0j -IaFYAI7D0GoT7RPjEiuA3GfmlbLNHiJuKvhB1PLKFAeNilUSxmn1uIZoL1NesNKq -IcGY5jDjZ1XHm26sGahVpkUG0CM62+tlXSoREfA7T8pt9DTEceT/AFr2XK4jYIVz -8eQQsSWu1ZK7E8EM4DnatDlXtas1qnIhO4M15zHfeiFuuDIIfR0ykRVKYnLP43eh -vNURG3YBZwjgQQvD6xVu+KQZ2aKrr+InUlYrAoosFCT5v0ICvybIxo/gbjh9Uy3l -7ZizlWNof/k19N+IxWA1ksB8aRxhlRbQ694Lrz4EEEVlWFA4r0jyWbYW8jwNkALG -cC4BrTwV1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB -BjAdBgNVHQ4EFgQU7edvdlq/YOxJW8ald7tyFnGbxD0wDQYJKoZIhvcNAQELBQAD -ggIBAJHfgD9DCX5xwvfrs4iP4VGyvD11+ShdyLyZm3tdquXK4Qr36LLTn91nMX66 -AarHakE7kNQIXLJgapDwyM4DYvmL7ftuKtwGTTwpD4kWilhMSA/ohGHqPHKmd+RC -roijQ1h5fq7KpVMNqT1wvSAZYaRsOPxDMuHBR//47PERIjKWnML2W2mWeyAMQ0Ga -W/ZZGYjeVYg3UQt4XAoeo0L9x52ID8DyeAIkVJOviYeIyUqAHerQbj5hLja7NQ4n -lv1mNDthcnPxFlxHBlRJAHpYErAK74X9sbgzdWqTHBLmYF5vHX/JHyPLhGGfHoJE -+V+tYlUkmlKY7VHnoX6XOuYvHxHaU4AshZ6rNRDbIl9qxV6XU/IyAgkwo1jwDQHV -csaxfGl7w/U2Rcxhbl5MlMVerugOXou/983g7aEOGzPuVBj+D77vfoRrQ+NwmNtd -dbINWQeFFSM51vHfqSYP1kjHs6Yi9TM3WpVHn3u6GBVv/9YUZINJ0gpnIdsPNWNg -KCLjsZWDzYWm3S8P52dSbrsvhXz1SnPnxT7AvSESBT/8twNJAlvIJebiVDj1eYeM -HVOyToV7BjjHLPj4sHKNJeV3UvQDHEimUF+IIDBu8oJDqz2XhOdT+yHBTw8imoa4 -WSr2Rz0ZiC3oheGe7IUIarFsNMkd7EgrO3jtZsSOeWmD3n+M ------END CERTIFICATE----- -# "QuoVadis Root CA 3" -# 18 F1 FC 7F 20 5D F8 AD DD EB 7F E0 07 DD 57 E3 -# AF 37 5A 9C 4D 8D 73 54 6B F4 F1 FE D1 E1 8D 35 ------BEGIN CERTIFICATE----- -MIIGnTCCBIWgAwIBAgICBcYwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x -GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv -b3QgQ0EgMzAeFw0wNjExMjQxOTExMjNaFw0zMTExMjQxOTA2NDRaMEUxCzAJBgNV -BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W -YWRpcyBSb290IENBIDMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDM -V0IWVJzmmNPTTe7+7cefQzlKZbPoFog02w1ZkXTPkrgEQK0CSzGrvI2RaNggDhoB -4hp7Thdd4oq3P5kazethq8Jlph+3t723j/z9cI8LoGe+AaJZz3HmDyl2/7FWeUUr -H556VOijKTVopAFPD6QuN+8bv+OPEKhyq1hX51SGyMnzW9os2l2ObjyjPtr7guXd -8lyyBTNvijbO0BNO/79KDDRMpsMhvVAEVeuxu537RR5kFd5VAYwCdrXLoT9Cabwv -vWhDFlaJKjdhkf2mrk7AyxRllDdLkgbvBNDInIjbC3uBr7E9KsRlOni27tyAsdLT -mZw67mtaa7ONt9XOnMK+pUsvFrGeaDsGb659n/je7Mwpp5ijJUMv7/FfJuGITfhe -btfZFG4ZM2mnO4SJk8RTVROhUXhA+LjJou57ulJCg54U7QVSWllWp5f8nT8KKdjc -T5EOE7zelaTfi5m+rJsziO+1ga8bxiJTyPbH7pcUsMV8eFLI8M5ud2CEpukqdiDt -WAEXMJPpGovgc2PZapKUSU60rUqFxKMiMPwJ7Wgic6aIDFUhWMXhOp8q3crhkODZ -c6tsgLjoC2SToJyMGf+z0gzskSaHirOi4XCPLArlzW1oUevaPwV/izLmE1xr/l9A -4iLItLRkT9a6fUg+qGkM17uGcclzuD87nSVL2v9A6wIDAQABo4IBlTCCAZEwDwYD -VR0TAQH/BAUwAwEB/zCB4QYDVR0gBIHZMIHWMIHTBgkrBgEEAb5YAAMwgcUwgZMG -CCsGAQUFBwICMIGGGoGDQW55IHVzZSBvZiB0aGlzIENlcnRpZmljYXRlIGNvbnN0 -aXR1dGVzIGFjY2VwdGFuY2Ugb2YgdGhlIFF1b1ZhZGlzIFJvb3QgQ0EgMyBDZXJ0 -aWZpY2F0ZSBQb2xpY3kgLyBDZXJ0aWZpY2F0aW9uIFByYWN0aWNlIFN0YXRlbWVu -dC4wLQYIKwYBBQUHAgEWIWh0dHA6Ly93d3cucXVvdmFkaXNnbG9iYWwuY29tL2Nw -czALBgNVHQ8EBAMCAQYwHQYDVR0OBBYEFPLAE+CCQz777i9nMpY1XNu4ywLQMG4G -A1UdIwRnMGWAFPLAE+CCQz777i9nMpY1XNu4ywLQoUmkRzBFMQswCQYDVQQGEwJC -TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDEbMBkGA1UEAxMSUXVvVmFkaXMg -Um9vdCBDQSAzggIFxjANBgkqhkiG9w0BAQUFAAOCAgEAT62gLEz6wPJv92ZVqyM0 -7ucp2sNbtrCD2dDQ4iH782CnO11gUyeim/YIIirnv6By5ZwkajGxkHon24QRiSem -d1o417+shvzuXYO8BsbRd2sPbSQvS3pspweWyuOEn62Iix2rFo1bZhfZFvSLgNLd -+LJ2w/w4E6oM3kJpK27zPOuAJ9v1pkQNn1pVWQvVDVJIxa6f8i+AxeoyUDUSly7B -4f/xI4hROJ/yZlZ25w9Rl6VSDE1JUZU2Pb+iSwwQHYaZTKrzchGT5Or2m9qoXadN -t54CrnMAyNojA+j56hl0YgCUyyIgvpSnWbWCar6ZeXqp8kokUvd0/bpO5qgdAm6x -DYBEwa7TIzdfu4V8K5Iu6H6li92Z4b8nby1dqnuH/grdS/yO9SbkbnBCbjPsMZ57 -k8HkyWkaPcBrTiJt7qtYTcbQQcEr6k8Sh17rRdhs9ZgC06DYVYoGmRmioHfRMJ6s -zHXug/WwYjnPbFfiTNKRCw51KBuav/0aQ/HKd/s7j2G4aSgWQgRecCocIdiP4b0j -Wy10QJLZYxkNc91pvGJHvOB0K7Lrfb5BG7XARsWhIstfTsEokt4YutUqKLsRixeT -mJlglFwjz1onl14LBQaTNx47aTbrqZ5hHY8y2o4M1nQ+ewkk2gF3R8Q7zTSMmfXK -4SVhM7JZG+Ju1zdXtg2pEto= ------END CERTIFICATE----- -# "QuoVadis Root CA 3 G3" -# 88 EF 81 DE 20 2E B0 18 45 2E 43 F8 64 72 5C EA -# 5F BD 1F C2 D9 D2 05 73 07 09 C5 D8 B8 69 0F 46 ------BEGIN CERTIFICATE----- -MIIFYDCCA0igAwIBAgIULvWbAiin23r/1aOp7r0DoM8Sah0wDQYJKoZIhvcNAQEL -BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc -BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMyBHMzAeFw0xMjAxMTIyMDI2MzJaFw00 -MjAxMTIyMDI2MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM -aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDMgRzMwggIiMA0GCSqG -SIb3DQEBAQUAA4ICDwAwggIKAoICAQCzyw4QZ47qFJenMioKVjZ/aEzHs286IxSR -/xl/pcqs7rN2nXrpixurazHb+gtTTK/FpRp5PIpM/6zfJd5O2YIyC0TeytuMrKNu -FoM7pmRLMon7FhY4futD4tN0SsJiCnMK3UmzV9KwCoWdcTzeo8vAMvMBOSBDGzXR -U7Ox7sWTaYI+FrUoRqHe6okJ7UO4BUaKhvVZR74bbwEhELn9qdIoyhA5CcoTNs+c -ra1AdHkrAj80//ogaX3T7mH1urPnMNA3I4ZyYUUpSFlob3emLoG+B01vr87ERROR -FHAGjx+f+IdpsQ7vw4kZ6+ocYfx6bIrc1gMLnia6Et3UVDmrJqMz6nWB2i3ND0/k -A9HvFZcba5DFApCTZgIhsUfei5pKgLlVj7WiL8DWM2fafsSntARE60f75li59wzw -eyuxwHApw0BiLTtIadwjPEjrewl5qW3aqDCYz4ByA4imW0aucnl8CAMhZa634Ryl -sSqiMd5mBPfAdOhx3v89WcyWJhKLhZVXGqtrdQtEPREoPHtht+KPZ0/l7DxMYIBp -VzgeAVuNVejH38DMdyM0SXV89pgR6y3e7UEuFAUCf+D+IOs15xGsIs5XPd7JMG0Q -A4XN8f+MFrXBsj6IbGB/kE+V9/YtrQE5BwT6dYB9v0lQ7e/JxHwc64B+27bQ3RP+ -ydOc17KXqQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB -BjAdBgNVHQ4EFgQUxhfQvKjqAkPyGwaZXSuQILnXnOQwDQYJKoZIhvcNAQELBQAD -ggIBADRh2Va1EodVTd2jNTFGu6QHcrxfYWLopfsLN7E8trP6KZ1/AvWkyaiTt3px -KGmPc+FSkNrVvjrlt3ZqVoAh313m6Tqe5T72omnHKgqwGEfcIHB9UqM+WXzBusnI -FUBhynLWcKzSt/Ac5IYp8M7vaGPQtSCKFWGafoaYtMnCdvvMujAWzKNhxnQT5Wvv -oxXqA/4Ti2Tk08HS6IT7SdEQTXlm66r99I0xHnAUrdzeZxNMgRVhvLfZkXdxGYFg -u/BYpbWcC/ePIlUnwEsBbTuZDdQdm2NnL9DuDcpmvJRPpq3t/O5jrFc/ZSXPsoaP -0Aj/uHYUbt7lJ+yreLVTubY/6CD50qi+YUbKh4yE8/nxoGibIh6BJpsQBJFxwAYf -3KDTuVan45gtf4Od34wrnDKOMpTwATwiKp9Dwi7DmDkHOHv8XgBCH/MyJnmDhPbl -8MFREsALHgQjDFSlTC9JxUrRtm5gDWv8a4uFJGS3iQ6rJUdbPM9+Sb3H6QrG2vd+ -DhcI00iX0HGS8A85PjRqHH3Y8iKuu2n0M7SmSFXRDw4m6Oy2Cy2nhTXN/VnIn9HN -PlopNLk9hM6xZdRZkZFWdSHBd575euFgndOtBBj0fOtek49TSiIp+EgrPk2GrFt/ -ywaZWWDYWGWVjUTR939+J399roD1B0y2PpxxVJkES/1Y+Zj0 ------END CERTIFICATE----- -# "QuoVadis Root Certification Authority" -# A4 5E DE 3B BB F0 9C 8A E1 5C 72 EF C0 72 68 D6 -# 93 A2 1C 99 6F D5 1E 67 CA 07 94 60 FD 6D 88 73 ------BEGIN CERTIFICATE----- -MIIF0DCCBLigAwIBAgIEOrZQizANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJC -TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDElMCMGA1UECxMcUm9vdCBDZXJ0 -aWZpY2F0aW9uIEF1dGhvcml0eTEuMCwGA1UEAxMlUXVvVmFkaXMgUm9vdCBDZXJ0 -aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wMTAzMTkxODMzMzNaFw0yMTAzMTcxODMz -MzNaMH8xCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMSUw -IwYDVQQLExxSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYDVQQDEyVR -dW9WYWRpcyBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG -9w0BAQEFAAOCAQ8AMIIBCgKCAQEAv2G1lVO6V/z68mcLOhrfEYBklbTRvM16z/Yp -li4kVEAkOPcahdxYTMukJ0KX0J+DisPkBgNbAKVRHnAEdOLB1Dqr1607BxgFjv2D -rOpm2RgbaIr1VxqYuvXtdj182d6UajtLF8HVj71lODqV0D1VNk7feVcxKh7YWWVJ -WCCYfqtffp/p1k3sg3Spx2zY7ilKhSoGFPlU5tPaZQeLYzcS19Dsw3sgQUSj7cug -F+FxZc4dZjH3dgEZyH0DWLaVSR2mEiboxgx24ONmy+pdpibu5cxfvWenAScOospU -xbF6lR1xHkopigPcakXBpBlebzbNw6Kwt/5cOOJSvPhEQ+aQuwIDAQABo4ICUjCC -Ak4wPQYIKwYBBQUHAQEEMTAvMC0GCCsGAQUFBzABhiFodHRwczovL29jc3AucXVv -dmFkaXNvZmZzaG9yZS5jb20wDwYDVR0TAQH/BAUwAwEB/zCCARoGA1UdIASCAREw -ggENMIIBCQYJKwYBBAG+WAABMIH7MIHUBggrBgEFBQcCAjCBxxqBxFJlbGlhbmNl -IG9uIHRoZSBRdW9WYWRpcyBSb290IENlcnRpZmljYXRlIGJ5IGFueSBwYXJ0eSBh -c3N1bWVzIGFjY2VwdGFuY2Ugb2YgdGhlIHRoZW4gYXBwbGljYWJsZSBzdGFuZGFy -ZCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB1c2UsIGNlcnRpZmljYXRpb24gcHJh -Y3RpY2VzLCBhbmQgdGhlIFF1b1ZhZGlzIENlcnRpZmljYXRlIFBvbGljeS4wIgYI -KwYBBQUHAgEWFmh0dHA6Ly93d3cucXVvdmFkaXMuYm0wHQYDVR0OBBYEFItLbe3T -KbkGGew5Oanwl4Rqy+/fMIGuBgNVHSMEgaYwgaOAFItLbe3TKbkGGew5Oanwl4Rq -y+/foYGEpIGBMH8xCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1p -dGVkMSUwIwYDVQQLExxSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYD -VQQDEyVRdW9WYWRpcyBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggQ6tlCL -MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOCAQEAitQUtf70mpKnGdSk -fnIYj9lofFIk3WdvOXrEql494liwTXCYhGHoG+NpGA7O+0dQoE7/8CQfvbLO9Sf8 -7C9TqnN7Az10buYWnuulLsS/VidQK2K6vkscPFVcQR0kvoIgR13VRH56FmjffU1R -cHhXHTMe/QKZnAzNCgVPx7uOpHX6Sm2xgI4JVrmcGmD+XcHXetwReNDWXcG31a0y -mQM6isxUJTkxgXsTIlG6Rmyhu576BGxJJnSP0nPrzDCi5upZIof4l/UO/erMkqQW -xFIY6iHOsfHmhIHluqmGKPJDWl0Snawe2ajlCmqnf6CHKc/yiU3U7MXi5nrQNiOK -SnQ2+Q== ------END CERTIFICATE----- -# "Secure Global CA" -# 42 00 F5 04 3A C8 59 0E BB 52 7D 20 9E D1 50 30 -# 29 FB CB D4 1C A1 B5 06 EC 27 F1 5A DE 7D AC 69 ------BEGIN CERTIFICATE----- -MIIDvDCCAqSgAwIBAgIQB1YipOjUiolN9BPI8PjqpTANBgkqhkiG9w0BAQUFADBK -MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x -GTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwHhcNMDYxMTA3MTk0MjI4WhcNMjkx -MjMxMTk1MjA2WjBKMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3Qg -Q29ycG9yYXRpb24xGTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwggEiMA0GCSqG -SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvNS7YrGxVaQZx5RNoJLNP2MwhR/jxYDiJ -iQPpvepeRlMJ3Fz1Wuj3RSoC6zFh1ykzTM7HfAo3fg+6MpjhHZevj8fcyTiW89sa -/FHtaMbQbqR8JNGuQsiWUGMu4P51/pinX0kuleM5M2SOHqRfkNJnPLLZ/kG5VacJ -jnIFHovdRIWCQtBJwB1g8NEXLJXr9qXBkqPFwqcIYA1gBBCWeZ4WNOaptvolRTnI -HmX5k/Wq8VLcmZg9pYYaDDUz+kulBAYVHDGA76oYa8J719rO+TMg1fW9ajMtgQT7 -sFzUnKPiXB3jqUJ1XnvUd+85VLrJChgbEplJL4hL/VBi0XPnj3pDAgMBAAGjgZ0w -gZowEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQF -MAMBAf8wHQYDVR0OBBYEFK9EBMJBfkiD2045AuzshHrmzsmkMDQGA1UdHwQtMCsw -KaAnoCWGI2h0dHA6Ly9jcmwuc2VjdXJldHJ1c3QuY29tL1NHQ0EuY3JsMBAGCSsG -AQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IBAQBjGghAfaReUw132HquHw0L -URYD7xh8yOOvaliTFGCRsoTciE6+OYo68+aCiV0BN7OrJKQVDpI1WkpEXk5X+nXO -H0jOZvQ8QCaSmGwb7iRGDBezUqXbpZGRzzfTb+cnCDpOGR86p1hcF895P4vkp9Mm -I50mD1hp/Ed+stCNi5O/KU9DaXR2Z0vPB4zmAve14bRDtUstFJ/53CYNv6ZHdAbY -iNE6KTCEztI5gGIbqMdXSbxqVVFnFUq+NQfk1XWYN3kwFNspnWzFacxHVaIw98xc -f8LDmBxrThaA63p4ZUWiABqvDA1VZDRIuJK58bRQKfJPIx/abKwfROHdI3hRW8cW ------END CERTIFICATE----- -# "SecureTrust CA" -# F1 C1 B5 0A E5 A2 0D D8 03 0E C9 F6 BC 24 82 3D -# D3 67 B5 25 57 59 B4 E7 1B 61 FC E9 F7 37 5D 73 ------BEGIN CERTIFICATE----- -MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI -MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x -FzAVBgNVBAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIz -MTE5NDA1NVowSDELMAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENv -cnBvcmF0aW9uMRcwFQYDVQQDEw5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcN -AQEBBQADggEPADCCAQoCggEBAKukgeWVzfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEz -Zum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6pkjGnx29vo6pQT64lO0pGtSO -0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgUXPLIXgGZbf2IzIao -wW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPeZqx2pHGj -7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS -8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjAT -BgkrBgEEAYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB -/zAdBgNVHQ4EFgQUQjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCeg -JYYjaHR0cDovL2NybC5zZWN1cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGC -NxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBADDtT0rhWDpSclu1pqNlGKa7UTt3 -6Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+DCMh/bwQf2AQWnL1mA6s7Ll/ -3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr5Fiiu1cprp6poxkm -D5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUFdAvnZyPS -CPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR -3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jE= ------END CERTIFICATE----- -# "Security Communication EV RootCA1" -# A2 2D BA 68 1E 97 37 6E 2D 39 7D 72 8A AE 3A 9B -# 62 96 B9 FD BA 60 BC 2E 11 F6 47 F2 C6 75 FB 37 ------BEGIN CERTIFICATE----- -MIIDfTCCAmWgAwIBAgIBADANBgkqhkiG9w0BAQUFADBgMQswCQYDVQQGEwJKUDEl -MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEqMCgGA1UECxMh -U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBFViBSb290Q0ExMB4XDTA3MDYwNjAyMTIz -MloXDTM3MDYwNjAyMTIzMlowYDELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09N -IFRydXN0IFN5c3RlbXMgQ08uLExURC4xKjAoBgNVBAsTIVNlY3VyaXR5IENvbW11 -bmljYXRpb24gRVYgUm9vdENBMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC -ggEBALx/7FebJOD+nLpCeamIivqA4PUHKUPqjgo0No0c+qe1OXj/l3X3L+SqawSE -RMqm4miO/VVQYg+kcQ7OBzgtQoVQrTyWb4vVog7P3kmJPdZkLjjlHmy1V4qe70gO -zXppFodEtZDkBp2uoQSXWHnvIEqCa4wiv+wfD+mEce3xDuS4GBPMVjZd0ZoeUWs5 -bmB2iDQL87PRsJ3KYeJkHcFGB7hj3R4zZbOOCVVSPbW9/wfrrWFVGCypaZhKqkDF -MxRldAD5kd6vA0jFQFTcD4SQaCDFkpbcLuUCRarAX1T4bepJz11sS6/vmsJWXMY1 -VkJqMF/Cq/biPT+zyRGPMUzXn0kCAwEAAaNCMEAwHQYDVR0OBBYEFDVK9U2vP9eC -OKyrcWUXdYydVZPmMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0G -CSqGSIb3DQEBBQUAA4IBAQCoh+ns+EBnXcPBZsdAS5f8hxOQWsTvoMpfi7ent/HW -tWS3irO4G8za+6xmiEHO6Pzk2x6Ipu0nUBsCMCRGef4Eh3CXQHPRwMFXGZpppSeZ -q51ihPZRwSzJIxXYKLerJRO1RuGGAv8mjMSIkh1W/hln8lXkgKNrnKt34VFxDSDb -EJrbvXZ5B3eZKK2aXtqxT0QsNY6llsf9g/BYxnnWmHyojf6GPgcWkuF75x3sM3Z+ -Qi5KhfmRiWiEA4Glm5q+4zfFVKtWOxgtQaQM+ELbmaDgcm+7XeEWT1MKZPlO9L9O -VL14bIjqv5wTJMJwaaJ/D8g8rQjJsJhAoyrniIPtd490 ------END CERTIFICATE----- -# "Security Communication RootCA1" -# E7 5E 72 ED 9F 56 0E EC 6E B4 80 00 73 A4 3F C3 -# AD 19 19 5A 39 22 82 01 78 95 97 4A 99 02 6B 6C ------BEGIN CERTIFICATE----- -MIIDWjCCAkKgAwIBAgIBADANBgkqhkiG9w0BAQUFADBQMQswCQYDVQQGEwJKUDEY -MBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYDVQQLEx5TZWN1cml0eSBDb21t -dW5pY2F0aW9uIFJvb3RDQTEwHhcNMDMwOTMwMDQyMDQ5WhcNMjMwOTMwMDQyMDQ5 -WjBQMQswCQYDVQQGEwJKUDEYMBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYD -VQQLEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTEwggEiMA0GCSqGSIb3 -DQEBAQUAA4IBDwAwggEKAoIBAQCzs/5/022x7xZ8V6UMbXaKL0u/ZPtM7orw8yl8 -9f/uKuDp6bpbZCKamm8sOiZpUQWZJtzVHGpxxpp9Hp3dfGzGjGdnSj74cbAZJ6kJ -DKaVv0uMDPpVmDvY6CKhS3E4eayXkmmziX7qIWgGmBSWh9JhNrxtJ1aeV+7AwFb9 -Ms+k2Y7CI9eNqPPYJayX5HA49LY6tJ07lyZDo6G8SVlyTCMwhwFY9k6+HGhWZq/N -QV3Is00qVUarH9oe4kA92819uZKAnDfdDJZkndwi92SL32HeFZRSFaB9UslLqCHJ -xrHty8OVYNEP8Ktw+N/LTX7s1vqr2b1/VPKl6Xn62dZ2JChzAgMBAAGjPzA9MB0G -A1UdDgQWBBSgc0mZaNyFW2XjmygvV5+9M7wHSDALBgNVHQ8EBAMCAQYwDwYDVR0T -AQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAaECpqLvkT115swW1F7NgE+vG -kl3g0dNq/vu+m22/xwVtWSDEHPC32oRYAmP6SBbvT6UL90qY8j+eG61Ha2POCEfr -Uj94nK9NrvjVT8+amCoQQTlSxN3Zmw7vkwGusi7KaEIkQmywszo+zenaSMQVy+n5 -Bw+SUEmK3TGXX8npN6o7WWWXlDLJs58+OmJYxUmtYg5xpTKqL8aJdkNAExNnPaJU -JRDL8Try2frbSVa7pv6nQTXD4IhhyYjH3zYQIphZ6rBK+1YWc26sTfcioU+tHXot -RSflMMFe8toTyyVCUZVHA4xsIcx0Qu1T/zOLjw9XARYvz6buyXAiFL39vmwLAw== ------END CERTIFICATE----- -# "Security Communication RootCA2" -# 51 3B 2C EC B8 10 D4 CD E5 DD 85 39 1A DF C6 C2 -# DD 60 D8 7B B7 36 D2 B5 21 48 4A A4 7A 0E BE F6 ------BEGIN CERTIFICATE----- -MIIDdzCCAl+gAwIBAgIBADANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJKUDEl -MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEnMCUGA1UECxMe -U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBSb290Q0EyMB4XDTA5MDUyOTA1MDAzOVoX -DTI5MDUyOTA1MDAzOVowXTELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09NIFRy -dXN0IFN5c3RlbXMgQ08uLExURC4xJzAlBgNVBAsTHlNlY3VyaXR5IENvbW11bmlj -YXRpb24gUm9vdENBMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANAV -OVKxUrO6xVmCxF1SrjpDZYBLx/KWvNs2l9amZIyoXvDjChz335c9S672XewhtUGr -zbl+dp+++T42NKA7wfYxEUV0kz1XgMX5iZnK5atq1LXaQZAQwdbWQonCv/Q4EpVM -VAX3NuRFg3sUZdbcDE3R3n4MqzvEFb46VqZab3ZpUql6ucjrappdUtAtCms1FgkQ -hNBqyjoGADdH5H5XTz+L62e4iKrFvlNVspHEfbmwhRkGeC7bYRr6hfVKkaHnFtWO -ojnflLhwHyg/i/xAXmODPIMqGplrz95Zajv8bxbXH/1KEOtOghY6rCcMU/Gt1SSw -awNQwS08Ft1ENCcadfsCAwEAAaNCMEAwHQYDVR0OBBYEFAqFqXdlBZh8QIH4D5cs -OPEK7DzPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3 -DQEBCwUAA4IBAQBMOqNErLlFsceTfsgLCkLfZOoc7llsCLqJX2rKSpWeeo8HxdpF -coJxDjrSzG+ntKEju/Ykn8sX/oymzsLS28yN/HH8AynBbF0zX2S2ZTuJbxh2ePXc -okgfGT+Ok+vx+hfuzU7jBBJV1uXk3fs+BXziHV7Gp7yXT2g69ekuCkO2r1dcYmh8 -t/2jioSgrGK+KwmHNPBqAbubKVY8/gA3zyNs8U6qtnRGEmyR7jTV7JqR50S+kDFy -1UkC9gLl9B/rfNmWVan/7Ir5mUf/NVoCqgTLiluHcSmRvaS0eg29mvVXIwAHIRc/ -SjnRBUkLp7Y3gaVdjKozXoEofKd9J+sAro03 ------END CERTIFICATE----- -# "Sonera Class2 CA" -# 79 08 B4 03 14 C1 38 10 0B 51 8D 07 35 80 7F FB -# FC F8 51 8A 00 95 33 71 05 BA 38 6B 15 3D D9 27 ------BEGIN CERTIFICATE----- -MIIDIDCCAgigAwIBAgIBHTANBgkqhkiG9w0BAQUFADA5MQswCQYDVQQGEwJGSTEP -MA0GA1UEChMGU29uZXJhMRkwFwYDVQQDExBTb25lcmEgQ2xhc3MyIENBMB4XDTAx -MDQwNjA3Mjk0MFoXDTIxMDQwNjA3Mjk0MFowOTELMAkGA1UEBhMCRkkxDzANBgNV -BAoTBlNvbmVyYTEZMBcGA1UEAxMQU29uZXJhIENsYXNzMiBDQTCCASIwDQYJKoZI -hvcNAQEBBQADggEPADCCAQoCggEBAJAXSjWdyvANlsdE+hY3/Ei9vX+ALTU74W+o -Z6m/AxxNjG8yR9VBaKQTBME1DJqEQ/xcHf+Js+gXGM2RX/uJ4+q/Tl18GybTdXnt -5oTjV+WtKcT0OijnpXuENmmz/V52vaMtmdOQTiMofRhj8VQ7Jp12W5dCsv+u8E7s -3TmVToMGf+dJQMjFAbJUWmYdPfz56TwKnoG4cPABi+QjVHzIrviQHgCWctRUz2Ej -vOr7nQKV0ba5cTppCD8PtOFCx4j1P5iop7oc4HFx71hXgVB6XGt0Rg6DA5jDjqhu -8nYybieDwnPz3BjotJPqdURrBGAgcVeHnfO+oJAjPYok4doh28MCAwEAAaMzMDEw -DwYDVR0TAQH/BAUwAwEB/zARBgNVHQ4ECgQISqCqWITTXjwwCwYDVR0PBAQDAgEG -MA0GCSqGSIb3DQEBBQUAA4IBAQBazof5FnIVV0sd2ZvnoiYw7JNn39Yt0jSv9zil -zqsWuasvfDXLrNAPtEwr/IDva4yRXzZ299uzGxnq9LIR/WFxRL8oszodv7ND6J+/ -3DEIcbCdjdY0RzKQxmUk96BKfARzjzlvF4xytb1LyHr4e4PDKE6cCepnP7JnBBvD -FNr450kkkdAdavphOe9r5yF1BgfYErQhIHBCcYHaPJo2vqZbDWpsmh+Re/n570K6 -Tk6ezAyNlNzZRZxe7EJQY670XcSxEtzKO6gunRRaBXW37Ndj4ro1tgQIkejanZz2 -ZrUYrAqmVCY0M9IbwdR/GjqOC6oybtv8TyWf2TLHllpwrN9M ------END CERTIFICATE----- -# "SSL.com EV Root Certification Authority ECC" -# 22 A2 C1 F7 BD ED 70 4C C1 E7 01 B5 F4 08 C3 10 -# 88 0F E9 56 B5 DE 2A 4A 44 F9 9C 87 3A 25 A7 C8 ------BEGIN CERTIFICATE----- -MIIClDCCAhqgAwIBAgIILCmcWxbtBZUwCgYIKoZIzj0EAwIwfzELMAkGA1UEBhMC -VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T -U0wgQ29ycG9yYXRpb24xNDAyBgNVBAMMK1NTTC5jb20gRVYgUm9vdCBDZXJ0aWZp -Y2F0aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNTIzWhcNNDEwMjEyMTgx -NTIzWjB/MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hv -dXN0b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjE0MDIGA1UEAwwrU1NMLmNv -bSBFViBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49 -AgEGBSuBBAAiA2IABKoSR5CYG/vvw0AHgyBO8TCCogbR8pKGYfL2IWjKAMTH6kMA -VIbc/R/fALhBYlzccBYy3h+Z1MzFB8gIH2EWB1E9fVwHU+M1OIzfzZ/ZLg1Kthku -WnBaBu2+8KGwytAJKaNjMGEwHQYDVR0OBBYEFFvKXuXe0oGqzagtZFG22XKbl+ZP -MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUW8pe5d7SgarNqC1kUbbZcpuX -5k8wDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2gAMGUCMQCK5kCJN+vp1RPZ -ytRrJPOwPYdGWBrssd9v+1a6cGvHOMzosYxPD/fxZ3YOg9AeUY8CMD32IygmTMZg -h5Mmm7I1HrrW9zzRHM76JTymGoEVW/MSD2zuZYrJh6j5B+BimoxcSg== ------END CERTIFICATE----- -# "SSL.com EV Root Certification Authority RSA R2" -# 2E 7B F1 6C C2 24 85 A7 BB E2 AA 86 96 75 07 61 -# B0 AE 39 BE 3B 2F E9 D0 CC 6D 4E F7 34 91 42 5C ------BEGIN CERTIFICATE----- -MIIF6zCCA9OgAwIBAgIIVrYpzTS8ePYwDQYJKoZIhvcNAQELBQAwgYIxCzAJBgNV -BAYTAlVTMQ4wDAYDVQQIDAVUZXhhczEQMA4GA1UEBwwHSG91c3RvbjEYMBYGA1UE -CgwPU1NMIENvcnBvcmF0aW9uMTcwNQYDVQQDDC5TU0wuY29tIEVWIFJvb3QgQ2Vy -dGlmaWNhdGlvbiBBdXRob3JpdHkgUlNBIFIyMB4XDTE3MDUzMTE4MTQzN1oXDTQy -MDUzMDE4MTQzN1owgYIxCzAJBgNVBAYTAlVTMQ4wDAYDVQQIDAVUZXhhczEQMA4G -A1UEBwwHSG91c3RvbjEYMBYGA1UECgwPU1NMIENvcnBvcmF0aW9uMTcwNQYDVQQD -DC5TU0wuY29tIEVWIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgUlNBIFIy -MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAjzZlQOHWTcDXtOlG2mvq -M0fNTPl9fb69LT3w23jhhqXZuglXaO1XPqDQCEGD5yhBJB/jchXQARr7XnAjssuf -OePPxU7Gkm0mxnu7s9onnQqG6YE3Bf7wcXHswxzpY6IXFJ3vG2fThVUCAtZJycxa -4bH3bzKfydQ7iEGonL3Lq9ttewkfokxykNorCPzPPFTOZw+oz12WGQvE43LrrdF9 -HSfvkusQv1vrO6/PgN3B0pYEW3p+pKk8OHakYo6gOV7qd89dAFmPZiw+B6KjBSYR -aZfqhbcPlgtLyEDhULouisv3D5oi53+aNxPN8k0TayHRwMwi8qFG9kRpnMphNQcA -b9ZhCBHqurj26bNg5U257J8UZslXWNvNh2n4ioYSA0e/ZhN2rHd9NCSFg83XqpyQ -Gp8hLH94t2S42Oim9HizVcuE0jLEeK6jj2HdzghTreyI/BXkmg3mnxp3zkyPuBQV -PWKchjgGAGYS5Fl2WlPAApiiECtoRHuOec4zSnaqW4EWG7WK2NAAe15itAnWhmMO -pgWVSbooi4iTsjQc2KRVbrcc0N6ZVTsj9CLg+SlmJuwgUHfbSguPvuUCYHBBXtSu -UDkiFCbLsjtzdFVHB3mBOagwE0TlBIqulhMlQg+5U8Sb/M3kHN48+qvWBkofZ6aY -MBzdLNvcGJVXZsb/XItW9XcCAwEAAaNjMGEwDwYDVR0TAQH/BAUwAwEB/zAfBgNV -HSMEGDAWgBT5YLvU49U09rj1BoAlp3PbRmmonjAdBgNVHQ4EFgQU+WC71OPVNPa4 -9QaAJadz20ZpqJ4wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQBW -s47LCp1Jjr+kxJG7ZhcFUZh1++VQLHqe8RT6q9OKPv+RKY9ji9i0qVQBDb6Thi/5 -Sm3HXvVX+cpVHBK+Rw82xd9qt9t1wkclf7nxY/hoLVUE0fKNsKTPvDxeH3jnpaAg -cLAExbf3cqfeIg29MyVGjGSSJuM+LmOW2puMPfgYCdcDzH2GguDKBAdRUNf/ktUM -79qGn5nX67evaOI5JpS6aLe/g9Pqemc9YmeuJeVy6OLk7K4S9ksrPJ/psEDzOFSz -/bdoyNrGj1E8svuR3Bznm53htw1yj+KkxKl4+esUrMZDBcJlOSgYAsOCsp0FvmXt -ll9ldDz7CTUue5wT/RsPXcdtgTpWD8w74a8CLyKsRspGPKAcTNZEtF4uXBVmCeEm -Kf7GUmG6sXP/wwyc5WxqlD8UykAWlYTzWamsX0xhk23RO8yilQwipmdnRC652dKK -QbNmC1r7fSOl8hqw/96bg5Qu0T/fkreRrwU7ZcegbLHNYhLDkBvjJc40vG93drEQ -w/cFGsDWr3RiSBd3kmmQYRzelYB0VI8YHMPzA9C/pEN1hlMYegouCRw2n5H9gooi -S9EOUCXdywMMF8mDAAhONU2Ki+3wApRmLER/y5UnlhetCTCstnEXbosX9hwJ1C07 -mKVx01QT2WDz9UtmT/rx7iASjbSsV7FFY6GsdqnC+w== ------END CERTIFICATE----- -# "SSL.com Root Certification Authority ECC" -# 34 17 BB 06 CC 60 07 DA 1B 96 1C 92 0B 8A B4 CE -# 3F AD 82 0E 4A A3 0B 9A CB C4 A7 4E BD CE BC 65 ------BEGIN CERTIFICATE----- -MIICjTCCAhSgAwIBAgIIdebfy8FoW6gwCgYIKoZIzj0EAwIwfDELMAkGA1UEBhMC -VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T -U0wgQ29ycG9yYXRpb24xMTAvBgNVBAMMKFNTTC5jb20gUm9vdCBDZXJ0aWZpY2F0 -aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNDAzWhcNNDEwMjEyMTgxNDAz -WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hvdXN0 -b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjExMC8GA1UEAwwoU1NMLmNvbSBS -b290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49AgEGBSuB -BAAiA2IABEVuqVDEpiM2nl8ojRfLliJkP9x6jh3MCLOicSS6jkm5BBtHllirLZXI -7Z4INcgn64mMU1jrYor+8FsPazFSY0E7ic3s7LaNGdM0B9y7xgZ/wkWV7Mt/qCPg -CemB+vNH06NjMGEwHQYDVR0OBBYEFILRhXMw5zUE044CkvvlpNHEIejNMA8GA1Ud -EwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUgtGFczDnNQTTjgKS++Wk0cQh6M0wDgYD -VR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2cAMGQCMG/n61kRpGDPYbCWe+0F+S8T -kdzt5fxQaxFGRrMcIQBiu77D5+jNB5n5DQtdcj7EqgIwH7y6C+IwJPt8bYBVCpk+ -gA0z5Wajs6O7pdWLjwkspl1+4vAHCGht0nxpbl/f5Wpl ------END CERTIFICATE----- -# "SSL.com Root Certification Authority RSA" -# 85 66 6A 56 2E E0 BE 5C E9 25 C1 D8 89 0A 6F 76 -# A8 7E C1 6D 4D 7D 5F 29 EA 74 19 CF 20 12 3B 69 ------BEGIN CERTIFICATE----- -MIIF3TCCA8WgAwIBAgIIeyyb0xaAMpkwDQYJKoZIhvcNAQELBQAwfDELMAkGA1UE -BhMCVVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQK -DA9TU0wgQ29ycG9yYXRpb24xMTAvBgNVBAMMKFNTTC5jb20gUm9vdCBDZXJ0aWZp -Y2F0aW9uIEF1dGhvcml0eSBSU0EwHhcNMTYwMjEyMTczOTM5WhcNNDEwMjEyMTcz -OTM5WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hv -dXN0b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjExMC8GA1UEAwwoU1NMLmNv -bSBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IFJTQTCCAiIwDQYJKoZIhvcN -AQEBBQADggIPADCCAgoCggIBAPkP3aMrfcvQKv7sZ4Wm5y4bunfh4/WvpOz6Sl2R -xFdHaxh3a3by/ZPkPQ/CFp4LZsNWlJ4Xg4XOVu/yFv0AYvUiCVToZRdOQbngT0aX -qhvIuG5iXmmxX9sqAn78bMrzQdjt0Oj8P2FI7bADFB0QDksZ4LtO7IZl/zbzXmcC -C52GVWH9ejjt/uIZALdvoVBidXQ8oPrIJZK0bnoix/geoeOy3ZExqysdBP+lSgQ3 -6YWkMyv94tZVNHwZpEpox7Ko07fKoZOI68GXvIz5HdkihCR0xwQ9aqkpk8zruFvh -/l8lqjRYyMEjVJ0bmBHDOJx+PYZspQ9AhnwC9FwCTyjLrnGfDzrIM/4RJTXq/LrF -YD3ZfBjVsqnTdXgDciLKOsMf7yzlLqn6niy2UUb9rwPW6mBo6oUWNmuF6R7As93E -JNyAKoFBbZQ+yODJgUEAnl6/f8UImKIYLEJAs/lvOCdLToD0PYFH4Ih86hzOtXVc -US4cK38acijnALXRdMbX5J+tB5O2UzU1/Dfkw/ZdFr4hc96SCvigY2q8lpJqPvi8 -ZVWb3vUNiSYE/CUapiVpy8JtynziWV+XrOvvLsi81xtZPCvM8hnIk2snYxnP/Okm -+Mpxm3+T/jRnhE6Z6/yzeAkzcLpmpnbtG3PrGqUNxCITIJRWCk4sbE6x/c+cCbqi -M+2HAgMBAAGjYzBhMB0GA1UdDgQWBBTdBAkHovV6fVJTEpKV7jiAJQ2mWTAPBgNV -HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFN0ECQei9Xp9UlMSkpXuOIAlDaZZMA4G -A1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAgEAIBgRlCn7Jp0cHh5wYfGV -cpNxJK1ok1iOMq8bs3AD/CUrdIWQPXhq9LmLpZc7tRiRux6n+UBbkflVma8eEdBc -Hadm47GUBwwyOabqG7B52B2ccETjit3E+ZUfijhDPwGFpUenPUayvOUiaPd7nNgs -PgohyC0zrL/FgZkxdMF1ccW+sfAjRfSda/wZY52jvATGGAslu1OJD7OAUN5F7kR/ -q5R4ZJjT9ijdh9hwZXT7DrkT66cPYakylszeu+1jTBi7qUD3oFRuIIhxdRjqerQ0 -cuAjJ3dctpDqhiVAq+8zD8ufgr6iIPv2tS0a5sKFsXQP+8hlAqRSAUfdSSLBv9jr -a6x+3uxjMxW3IwiPxg+NQVrdjsW5j+VFP3jbutIbQLH+cU0/4IGiul607BXgk90I -H37hVZkLId6Tngr75qNJvTYw/ud3sqB1l7UtgYgXZSD32pAAn8lSzDLKNXz1PQ/Y -K9f1JmzJBjSWFupwWRoyeXkLtoh/D1JIPb9s2KJELtFOt3JY04kTlf5Eq/jXixtu -nLwsoFvVagCvXzfh1foQC5ichucmj87w7G6KVwuA406ywKBjYZC6VWg3dGq2ktuf -oYYitmUnDuy2n0Jg5GfCtdpBC8TTi2EbvPofkSvXRAdeuims2cXp71NIWuuA8ShY -Ic2wBlX7Jz9TkHCpBB5XJ7k= ------END CERTIFICATE----- -# "Staat der Nederlanden EV Root CA" -# 4D 24 91 41 4C FE 95 67 46 EC 4C EF A6 CF 6F 72 -# E2 8A 13 29 43 2F 9D 8A 90 7A C4 CB 5D AD C1 5A ------BEGIN CERTIFICATE----- -MIIFcDCCA1igAwIBAgIEAJiWjTANBgkqhkiG9w0BAQsFADBYMQswCQYDVQQGEwJO -TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSkwJwYDVQQDDCBTdGFh -dCBkZXIgTmVkZXJsYW5kZW4gRVYgUm9vdCBDQTAeFw0xMDEyMDgxMTE5MjlaFw0y -MjEyMDgxMTEwMjhaMFgxCzAJBgNVBAYTAk5MMR4wHAYDVQQKDBVTdGFhdCBkZXIg -TmVkZXJsYW5kZW4xKTAnBgNVBAMMIFN0YWF0IGRlciBOZWRlcmxhbmRlbiBFViBS -b290IENBMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA48d+ifkkSzrS -M4M1LGns3Amk41GoJSt5uAg94JG6hIXGhaTK5skuU6TJJB79VWZxXSzFYGgEt9nC -UiY4iKTWO0Cmws0/zZiTs1QUWJZV1VD+hq2kY39ch/aO5ieSZxeSAgMs3NZmdO3d -Z//BYY1jTw+bbRcwJu+r0h8QoPnFfxZpgQNH7R5ojXKhTbImxrpsX23Wr9GxE46p -rfNeaXUmGD5BKyF/7otdBwadQ8QpCiv8Kj6GyzyDOvnJDdrFmeK8eEEzduG/L13l -pJhQDBXd4Pqcfzho0LKmeqfRMb1+ilgnQ7O6M5HTp5gVXJrm0w912fxBmJc+qiXb -j5IusHsMX/FjqTf5m3VpTCgmJdrV8hJwRVXj33NeN/UhbJCONVrJ0yPr08C+eKxC -KFhmpUZtcALXEPlLVPxdhkqHz3/KRawRWrUgUY0viEeXOcDPusBCAUCZSCELa6fS -/ZbV0b5GnUngC6agIk440ME8MLxwjyx1zNDFjFE7PZQIZCZhfbnDZY8UnCHQqv0X -cgOPvZuM5l5Tnrmd74K74bzickFbIZTTRTeU0d8JOV3nI6qaHcptqAqGhYqCvkIH -1vI4gnPah1vlPNOePqc7nvQDs/nxfRN0Av+7oeX6AHkcpmZBiFxgV6YuCcS6/ZrP -px9Aw7vMWgpVSzs4dlG4Y4uElBbmVvMCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB -/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFP6rAJCYniT8qcwaivsnuL8wbqg7 -MA0GCSqGSIb3DQEBCwUAA4ICAQDPdyxuVr5Os7aEAJSrR8kN0nbHhp8dB9O2tLsI -eK9p0gtJ3jPFrK3CiAJ9Brc1AsFgyb/E6JTe1NOpEyVa/m6irn0F3H3zbPB+po3u -2dfOWBfoqSmuc0iH55vKbimhZF8ZE/euBhD/UcabTVUlT5OZEAFTdfETzsemQUHS -v4ilf0X8rLiltTMMgsT7B/Zq5SWEXwbKwYY5EdtYzXc7LMJMD16a4/CrPmEbUCTC -wPTxGfARKbalGAKb12NMcIxHowNDXLldRqANb/9Zjr7dn3LDWyvfjFvO5QxGbJKy -CqNMVEIYFRIYvdr8unRu/8G2oGTYqV9Vrp9canaW2HNnh/tNf1zuacpzEPuKqf2e -vTY4SUmH9A4U8OmHuD+nT3pajnnUk+S7aFKErGzp85hwVXIy+TSrK0m1zSBi5Dp6 -Z2Orltxtrpfs/J92VoguZs9btsmksNcFuuEnL5O7Jiqik7Ab846+HUCjuTaPPoIa -Gl6I6lD4WeKDRikL40Rc4ZW2aZCaFG+XroHPaO+Zmr615+F/+PoTRxZMzG0IQOeL -eG9QgkRQP2YGiqtDhFZKDyAthg710tvSeopLzaXoTvFeJiUBWSOgftL2fiFX1ye8 -FVdMpEbB4IMeDExNH08GGeL5qPQ6gqGyeUN51q1veieQA6TqJIc/2b3Z6fJfUEkc -7uzXLg== ------END CERTIFICATE----- -# "Staat der Nederlanden Root CA - G2" -# 66 8C 83 94 7D A6 3B 72 4B EC E1 74 3C 31 A0 E6 -# AE D0 DB 8E C5 B3 1B E3 77 BB 78 4F 91 B6 71 6F ------BEGIN CERTIFICATE----- -MIIFyjCCA7KgAwIBAgIEAJiWjDANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJO -TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSswKQYDVQQDDCJTdGFh -dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQSAtIEcyMB4XDTA4MDMyNjExMTgxN1oX -DTIwMDMyNTExMDMxMFowWjELMAkGA1UEBhMCTkwxHjAcBgNVBAoMFVN0YWF0IGRl -ciBOZWRlcmxhbmRlbjErMCkGA1UEAwwiU3RhYXQgZGVyIE5lZGVybGFuZGVuIFJv -b3QgQ0EgLSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMVZ5291 -qj5LnLW4rJ4L5PnZyqtdj7U5EILXr1HgO+EASGrP2uEGQxGZqhQlEq0i6ABtQ8Sp -uOUfiUtnvWFI7/3S4GCI5bkYYCjDdyutsDeqN95kWSpGV+RLufg3fNU254DBtvPU -Z5uW6M7XxgpT0GtJlvOjCwV3SPcl5XCsMBQgJeN/dVrlSPhOewMHBPqCYYdu8DvE -pMfQ9XQ+pV0aCPKbJdL2rAQmPlU6Yiile7Iwr/g3wtG61jj99O9JMDeZJiFIhQGp -5Rbn3JBV3w/oOM2ZNyFPXfUib2rFEhZgF1XyZWampzCROME4HYYEhLoaJXhena/M -UGDWE4dS7WMfbWV9whUYdMrhfmQpjHLYFhN9C0lK8SgbIHRrxT3dsKpICT0ugpTN -GmXZK4iambwYfp/ufWZ8Pr2UuIHOzZgweMFvZ9C+X+Bo7d7iscksWXiSqt8rYGPy -5V6548r6f1CGPqI0GAwJaCgRHOThuVw+R7oyPxjMW4T182t0xHJ04eOLoEq9jWYv -6q012iDTiIJh8BIitrzQ1aTsr1SIJSQ8p22xcik/Plemf1WvbibG/ufMQFxRRIEK -eN5KzlW/HdXZt1bv8Hb/C3m1r737qWmRRpdogBQ2HbN/uymYNqUg+oJgYjOk7Na6 -B6duxc8UpufWkjTYgfX8HV2qXB72o007uPc5AgMBAAGjgZcwgZQwDwYDVR0TAQH/ -BAUwAwEB/zBSBgNVHSAESzBJMEcGBFUdIAAwPzA9BggrBgEFBQcCARYxaHR0cDov -L3d3dy5wa2lvdmVyaGVpZC5ubC9wb2xpY2llcy9yb290LXBvbGljeS1HMjAOBgNV -HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJFoMocVHYnitfGsNig0jQt8YojrMA0GCSqG -SIb3DQEBCwUAA4ICAQCoQUpnKpKBglBu4dfYszk78wIVCVBR7y29JHuIhjv5tLyS -CZa59sCrI2AGeYwRTlHSeYAz+51IvuxBQ4EffkdAHOV6CMqqi3WtFMTC6GY8ggen -5ieCWxjmD27ZUD6KQhgpxrRW/FYQoAUXvQwjf/ST7ZwaUb7dRUG/kSS0H4zpX897 -IZmflZ85OkYcbPnNe5yQzSipx6lVu6xiNGI1E0sUOlWDuYaNkqbG9AclVMwWVxJK -gnjIFNkXgiYtXSAfea7+1HAWFpWD2DU5/1JddRwWxRNVz0fMdWVSSt7wsKfkCpYL -+63C4iWEst3kvX5ZbJvw8NjnyvLplzh+ib7M+zkXYT9y2zqR2GUBGR2tUKRXCnxL -vJxxcypFURmFzI79R6d0lR2o0a9OF7FpJsKqeFdbxU2n5Z4FF5TKsl+gSRiNNOkm -bEgeqmiSBeGCc1qb3AdbCG19ndeNIdn8FCCqwkXfP+cAslHkwvgFuXkajDTznlvk -N1trSt8sV4pAWja63XVECDdCcAz+3F4hoKOKwJCcaNpQ5kUQR3i2TtJlycM33+FC -Y7BXN0Ute4qcvwXqZVUz9zkQxSgqIXobisQk+T8VyJoVIPVVYpbtbZNQvOSqeK3Z -ywplh6ZmwcSBo3c6WB4L7oOLnR7SUqTMHW+wmG2UMbX4cQrcufx9MmDm66+KAQ== ------END CERTIFICATE----- -# "Staat der Nederlanden Root CA - G3" -# 3C 4F B0 B9 5A B8 B3 00 32 F4 32 B8 6F 53 5F E1 -# 72 C1 85 D0 FD 39 86 58 37 CF 36 18 7F A6 F4 28 ------BEGIN CERTIFICATE----- -MIIFdDCCA1ygAwIBAgIEAJiiOTANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJO -TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSswKQYDVQQDDCJTdGFh -dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQSAtIEczMB4XDTEzMTExNDExMjg0MloX -DTI4MTExMzIzMDAwMFowWjELMAkGA1UEBhMCTkwxHjAcBgNVBAoMFVN0YWF0IGRl -ciBOZWRlcmxhbmRlbjErMCkGA1UEAwwiU3RhYXQgZGVyIE5lZGVybGFuZGVuIFJv -b3QgQ0EgLSBHMzCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAL4yolQP -cPssXFnrbMSkUeiFKrPMSjTysF/zDsccPVMeiAho2G89rcKezIJnByeHaHE6n3WW -IkYFsO2tx1ueKt6c/DrGlaf1F2cY5y9JCAxcz+bMNO14+1Cx3Gsy8KL+tjzk7FqX -xz8ecAgwoNzFs21v0IJyEavSgWhZghe3eJJg+szeP4TrjTgzkApyI/o1zCZxMdFy -KJLZWyNtZrVtB0LrpjPOktvA9mxjeM3KTj215VKb8b475lRgsGYeCasH/lSJEULR -9yS6YHgamPfJEf0WwTUaVHXvQ9Plrk7O53vDxk5hUUurmkVLoR9BvUhTFXFkC4az -5S6+zqQbwSmEorXLCCN2QyIkHxcE1G6cxvx/K2Ya7Irl1s9N9WMJtxU51nus6+N8 -6U78dULI7ViVDAZCopz35HCz33JvWjdAidiFpNfxC95DGdRKWCyMijmev4SH8RY7 -Ngzp07TKbBlBUgmhHbBqv4LvcFEhMtwFdozL92TkA1CvjJFnq8Xy7ljY3r735zHP -bMk7ccHViLVlvMDoFxcHErVc0qsgk7TmgoNwNsXNo42ti+yjwUOH5kPiNL6VizXt -BznaqB16nzaeErAMZRKQFWDZJkBE41ZgpRDUajz9QdwOWke275dhdU/Z/seyHdTt -XUmzqWrLZoQT1Vyg3N9udwbRcXXIV2+vD3dbAgMBAAGjQjBAMA8GA1UdEwEB/wQF -MAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRUrfrHkleuyjWcLhL75Lpd -INyUVzANBgkqhkiG9w0BAQsFAAOCAgEAMJmdBTLIXg47mAE6iqTnB/d6+Oea31BD -U5cqPco8R5gu4RV78ZLzYdqQJRZlwJ9UXQ4DO1t3ApyEtg2YXzTdO2PCwyiBwpwp -LiniyMMB8jPqKqrMCQj3ZWfGzd/TtiunvczRDnBfuCPRy5FOCvTIeuXZYzbB1N/8 -Ipf3YF3qKS9Ysr1YvY2WTxB1v0h7PVGHoTx0IsL8B3+A3MSs/mrBcDCw6Y5p4ixp -gZQJut3+TcCDjJRYwEYgr5wfAvg1VUkvRtTA8KCWAg8zxXHzniN9lLf9OtMJgwYh -/WA9rjLA0u6NpvDntIJ8CsxwyXmA+P5M9zWEGYox+wrZ13+b8KKaa8MFSu1BYBQw -0aoRQm7TIwIEC8Zl3d1Sd9qBa7Ko+gE4uZbqKmxnl4mUnrzhVNXkanjvSr0rmj1A -fsbAddJu+2gw7OyLnflJNZoaLNmzlTnVHpL3prllL+U9bTpITAjc5CgSKL59NVzq -4BZ+Extq1z7XnvwtdbLBFNUjA9tbbws+eC8N3jONFrdI54OagQ97wUNNVQQXOEpR -1VmiiXTTn74eS9fGbbeIJG9gkaSChVtWQbzQRKtqE77RLFi3EjNYsjdj3BP1lB0/ -QFH1T/U67cjF68IeHRaVesd+QnGTbksVtzDfqu1XhUisHWrdOWnk4Xl4vs4Fv6EM -94B7IWcnMFk= ------END CERTIFICATE----- -# "Starfield Class 2 Certification Authority" -# 14 65 FA 20 53 97 B8 76 FA A6 F0 A9 95 8E 55 90 -# E4 0F CC 7F AA 4F B7 C2 C8 67 75 21 FB 5F B6 58 ------BEGIN CERTIFICATE----- -MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl -MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp -U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw -NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE -ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp -ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3 -DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf -8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN -+lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0 -X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa -K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA -1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G -A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR -zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0 -YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD -bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w -DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3 -L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D -eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl -xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp -VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY -WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q= ------END CERTIFICATE----- -# "Starfield Root Certificate Authority - G2" -# 2C E1 CB 0B F9 D2 F9 E1 02 99 3F BE 21 51 52 C3 -# B2 DD 0C AB DE 1C 68 E5 31 9B 83 91 54 DB B7 F5 ------BEGIN CERTIFICATE----- -MIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx -EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT -HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs -ZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw -MFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6 -b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj -aG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp -Y2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC -ggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg -nLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1 -HOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N -Hwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN -dloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0 -HZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO -BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G -CSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU -sHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3 -4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg -8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K -pL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1 -mMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0 ------END CERTIFICATE----- -# "Starfield Services Root Certificate Authority - G2" -# 56 8D 69 05 A2 C8 87 08 A4 B3 02 51 90 ED CF ED -# B1 97 4A 60 6A 13 C6 E5 29 0F CB 2A E6 3E DA B5 ------BEGIN CERTIFICATE----- -MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx -EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT -HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs -ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5 -MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD -VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy -ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy -dmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI -hvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p -OsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2 -8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K -Ts9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe -hRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk -6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw -DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q -AdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI -bw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB -ve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z -qwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd -iEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn -0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN -sSi6 ------END CERTIFICATE----- -# "StartCom Certification Authority" -# C7 66 A9 BE F2 D4 07 1C 86 3A 31 AA 49 20 E8 13 -# B2 D1 98 60 8C B7 B7 CF E2 11 43 B8 36 DF 09 EA ------BEGIN CERTIFICATE----- -MIIHyTCCBbGgAwIBAgIBATANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQGEwJJTDEW -MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg -Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh -dGlvbiBBdXRob3JpdHkwHhcNMDYwOTE3MTk0NjM2WhcNMzYwOTE3MTk0NjM2WjB9 -MQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi -U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3Rh -cnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUA -A4ICDwAwggIKAoICAQDBiNsJvGxGfHiflXu1M5DycmLWwTYgIiRezul38kMKogZk -pMyONvg45iPwbm2xPN1yo4UcodM9tDMr0y+v/uqwQVlntsQGfQqedIXWeUyAN3rf -OQVSWff0G0ZDpNKFhdLDcfN1YjS6LIp/Ho/u7TTQEceWzVI9ujPW3U3eCztKS5/C -Ji/6tRYccjV3yjxd5srhJosaNnZcAdt0FCX+7bWgiA/deMotHweXMAEtcnn6RtYT -Kqi5pquDSR3l8u/d5AGOGAqPY1MWhWKpDhk6zLVmpsJrdAfkK+F2PrRt2PZE4XNi -HzvEvqBTViVsUQn3qqvKv3b9bZvzndu/PWa8DFaqr5hIlTpL36dYUNk4dalb6kMM -Av+Z6+hsTXBbKWWc3apdzK8BMewM69KN6Oqce+Zu9ydmDBpI125C4z/eIT574Q1w -+2OqqGwaVLRcJXrJosmLFqa7LH4XXgVNWG4SHQHuEhANxjJ/GP/89PrNbpHoNkm+ -Gkhpi8KWTRoSsmkXwQqQ1vp5Iki/untp+HDH+no32NgN0nZPV/+Qt+OR0t3vwmC3 -Zzrd/qqc8NSLf3Iizsafl7b4r4qgEKjZ+xjGtrVcUjyJthkqcwEKDwOzEmDyei+B -26Nu/yYwl/WL3YlXtq09s68rxbd2AvCl1iuahhQqcvbjM4xdCUsT37uMdBNSSwID -AQABo4ICUjCCAk4wDAYDVR0TBAUwAwEB/zALBgNVHQ8EBAMCAa4wHQYDVR0OBBYE -FE4L7xqkQFulF2mHMMo0aEPQQa7yMGQGA1UdHwRdMFswLKAqoCiGJmh0dHA6Ly9j -ZXJ0LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMCugKaAnhiVodHRwOi8vY3Js -LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMIIBXQYDVR0gBIIBVDCCAVAwggFM -BgsrBgEEAYG1NwEBATCCATswLwYIKwYBBQUHAgEWI2h0dHA6Ly9jZXJ0LnN0YXJ0 -Y29tLm9yZy9wb2xpY3kucGRmMDUGCCsGAQUFBwIBFilodHRwOi8vY2VydC5zdGFy -dGNvbS5vcmcvaW50ZXJtZWRpYXRlLnBkZjCB0AYIKwYBBQUHAgIwgcMwJxYgU3Rh -cnQgQ29tbWVyY2lhbCAoU3RhcnRDb20pIEx0ZC4wAwIBARqBl0xpbWl0ZWQgTGlh -YmlsaXR5LCByZWFkIHRoZSBzZWN0aW9uICpMZWdhbCBMaW1pdGF0aW9ucyogb2Yg -dGhlIFN0YXJ0Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5IFBvbGljeSBhdmFp -bGFibGUgYXQgaHR0cDovL2NlcnQuc3RhcnRjb20ub3JnL3BvbGljeS5wZGYwEQYJ -YIZIAYb4QgEBBAQDAgAHMDgGCWCGSAGG+EIBDQQrFilTdGFydENvbSBGcmVlIFNT -TCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTANBgkqhkiG9w0BAQUFAAOCAgEAFmyZ -9GYMNPXQhV59CuzaEE44HF7fpiUFS5Eyweg78T3dRAlbB0mKKctmArexmvclmAk8 -jhvh3TaHK0u7aNM5Zj2gJsfyOZEdUauCe37Vzlrk4gNXcGmXCPleWKYK34wGmkUW -FjgKXlf2Ysd6AgXmvB618p70qSmD+LIU424oh0TDkBreOKk8rENNZEXO3SipXPJz -ewT4F+irsfMuXGRuczE6Eri8sxHkfY+BUZo7jYn0TZNmezwD7dOaHZrzZVD1oNB1 -ny+v8OqCQ5j4aZyJecRDjkZy42Q2Eq/3JR44iZB3fsNrarnDy0RLrHiQi+fHLB5L -EUTINFInzQpdn4XBidUaePKVEFMy3YCEZnXZtWgo+2EuvoSoOMCZEoalHmdkrQYu -L6lwhceWD3yJZfWOQ1QOq92lgDmUYMA0yZZwLKMS9R9Ie70cfmu3nZD0Ijuu+Pwq -yvqCUqDvr0tVk+vBtfAii6w0TiYiBKGHLHVKt+V9E9e4DGTANtLJL4YSjCMJwRuC -O3NJo2pXh5Tl1njFmUNj403gdy3hZZlyaQQaRwnmDwFWJPsfvw55qVguucQJAX6V -um0ABj6y6koQOdjQK/W/7HW/lwLFCRsI3FU34oH7N4RDYiDK51ZLZer+bMEkkySh -NOsF/5oirpt9P/FlUQqmMGqz9IgcgA38corog14= ------END CERTIFICATE----- -# "StartCom Certification Authority" -# E1 78 90 EE 09 A3 FB F4 F4 8B 9C 41 4A 17 D6 37 -# B7 A5 06 47 E9 BC 75 23 22 72 7F CC 17 42 A9 11 ------BEGIN CERTIFICATE----- -MIIHhzCCBW+gAwIBAgIBLTANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJJTDEW -MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg -Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh -dGlvbiBBdXRob3JpdHkwHhcNMDYwOTE3MTk0NjM3WhcNMzYwOTE3MTk0NjM2WjB9 -MQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi -U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3Rh -cnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUA -A4ICDwAwggIKAoICAQDBiNsJvGxGfHiflXu1M5DycmLWwTYgIiRezul38kMKogZk -pMyONvg45iPwbm2xPN1yo4UcodM9tDMr0y+v/uqwQVlntsQGfQqedIXWeUyAN3rf -OQVSWff0G0ZDpNKFhdLDcfN1YjS6LIp/Ho/u7TTQEceWzVI9ujPW3U3eCztKS5/C -Ji/6tRYccjV3yjxd5srhJosaNnZcAdt0FCX+7bWgiA/deMotHweXMAEtcnn6RtYT -Kqi5pquDSR3l8u/d5AGOGAqPY1MWhWKpDhk6zLVmpsJrdAfkK+F2PrRt2PZE4XNi -HzvEvqBTViVsUQn3qqvKv3b9bZvzndu/PWa8DFaqr5hIlTpL36dYUNk4dalb6kMM -Av+Z6+hsTXBbKWWc3apdzK8BMewM69KN6Oqce+Zu9ydmDBpI125C4z/eIT574Q1w -+2OqqGwaVLRcJXrJosmLFqa7LH4XXgVNWG4SHQHuEhANxjJ/GP/89PrNbpHoNkm+ -Gkhpi8KWTRoSsmkXwQqQ1vp5Iki/untp+HDH+no32NgN0nZPV/+Qt+OR0t3vwmC3 -Zzrd/qqc8NSLf3Iizsafl7b4r4qgEKjZ+xjGtrVcUjyJthkqcwEKDwOzEmDyei+B -26Nu/yYwl/WL3YlXtq09s68rxbd2AvCl1iuahhQqcvbjM4xdCUsT37uMdBNSSwID -AQABo4ICEDCCAgwwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD -VR0OBBYEFE4L7xqkQFulF2mHMMo0aEPQQa7yMB8GA1UdIwQYMBaAFE4L7xqkQFul -F2mHMMo0aEPQQa7yMIIBWgYDVR0gBIIBUTCCAU0wggFJBgsrBgEEAYG1NwEBATCC -ATgwLgYIKwYBBQUHAgEWImh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL3BvbGljeS5w -ZGYwNAYIKwYBBQUHAgEWKGh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL2ludGVybWVk -aWF0ZS5wZGYwgc8GCCsGAQUFBwICMIHCMCcWIFN0YXJ0IENvbW1lcmNpYWwgKFN0 -YXJ0Q29tKSBMdGQuMAMCAQEagZZMaW1pdGVkIExpYWJpbGl0eSwgcmVhZCB0aGUg -c2VjdGlvbiAqTGVnYWwgTGltaXRhdGlvbnMqIG9mIHRoZSBTdGFydENvbSBDZXJ0 -aWZpY2F0aW9uIEF1dGhvcml0eSBQb2xpY3kgYXZhaWxhYmxlIGF0IGh0dHA6Ly93 -d3cuc3RhcnRzc2wuY29tL3BvbGljeS5wZGYwEQYJYIZIAYb4QgEBBAQDAgAHMDgG -CWCGSAGG+EIBDQQrFilTdGFydENvbSBGcmVlIFNTTCBDZXJ0aWZpY2F0aW9uIEF1 -dGhvcml0eTANBgkqhkiG9w0BAQsFAAOCAgEAjo/n3JR5fPGFf59Jb2vKXfuM/gTF -wWLRfUKKvFO3lANmMD+x5wqnUCBVJX92ehQN6wQOQOY+2IirByeDqXWmN3PH/UvS -Ta0XQMhGvjt/UfzDtgUx3M2FIk5xt/JxXrAaxrqTi3iSSoX4eA+D/i+tLPfkpLst -0OcNOrg+zvZ49q5HJMqjNTbOx8aHmNrs++myziebiMMEofYLWWivydsQD032ZGNc -pRJvkrKTlMeIFw6Ttn5ii5B/q06f/ON1FE8qMt9bDeD1e5MNq6HPh+GlBEXoPBKl -CcWw0bdT82AUuoVpaiF8H3VhFyAXe2w7QSlc4axa0c2Mm+tgHRns9+Ww2vl5GKVF -P0lDV9LdJNUso/2RjSe15esUBppMeyG7Oq0wBhjA2MFrLH9ZXF2RsXAiV+uKa0hK -1Q8p7MZAwC+ITGgBF3f0JBlPvfrhsiAhS90a2Cl9qrjeVOwhVYBsHvUwyKMQ5bLm -KhQxw4UtjJixhlpPiVktucf3HMiKf8CdBUrmQk9io20ppB+Fq9vlgcitKj1MXVuE -JnHEhV5xJMqlG2zYYdMa4FTbzrqpMrUi9nNBCV24F10OD5mQ1kfabwo6YigUZ4LZ -8dCAWZvLMdibD4x3TrVoivJs9iQOLWxwxXPR3hTQcY+203sC9uO41Alua551hDnm -fyWl8kgAwKQB2j8= ------END CERTIFICATE----- -# "StartCom Certification Authority G2" -# C7 BA 65 67 DE 93 A7 98 AE 1F AA 79 1E 71 2D 37 -# 8F AE 1F 93 C4 39 7F EA 44 1B B7 CB E6 FD 59 95 ------BEGIN CERTIFICATE----- -MIIFYzCCA0ugAwIBAgIBOzANBgkqhkiG9w0BAQsFADBTMQswCQYDVQQGEwJJTDEW -MBQGA1UEChMNU3RhcnRDb20gTHRkLjEsMCoGA1UEAxMjU3RhcnRDb20gQ2VydGlm -aWNhdGlvbiBBdXRob3JpdHkgRzIwHhcNMTAwMTAxMDEwMDAxWhcNMzkxMjMxMjM1 -OTAxWjBTMQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjEsMCoG -A1UEAxMjU3RhcnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgRzIwggIiMA0G -CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2iTZbB7cgNr2Cu+EWIAOVeq8Oo1XJ -JZlKxdBWQYeQTSFgpBSHO839sj60ZwNq7eEPS8CRhXBF4EKe3ikj1AENoBB5uNsD -vfOpL9HG4A/LnooUCri99lZi8cVytjIl2bLzvWXFDSxu1ZJvGIsAQRSCb0AgJnoo -D/Uefyf3lLE3PbfHkffiAez9lInhzG7TNtYKGXmu1zSCZf98Qru23QumNK9LYP5/ -Q0kGi4xDuFby2X8hQxfqp0iVAXV16iulQ5XqFYSdCI0mblWbq9zSOdIxHWDirMxW -RST1HFSr7obdljKF+ExP6JV2tgXdNiNnvP8V4so75qbsO+wmETRIjfaAKxojAuuK -HDp2KntWFhxyKrOq42ClAJ8Em+JvHhRYW6Vsi1g8w7pOOlz34ZYrPu8HvKTlXcxN -nw3h3Kq74W4a7I/htkxNeXJdFzULHdfBR9qWJODQcqhaX2YtENwvKhOuJv4KHBnM -0D4LnMgJLvlblnpHnOl68wVQdJVznjAJ85eCXuaPOQgeWeU1FEIT/wCc976qUM/i -UUjXuG+v+E5+M5iSFGI6dWPPe/regjupuznixL0sAA7IF6wT700ljtizkC+p2il9 -Ha90OrInwMEePnWjFqmveiJdnxMaz6eg6+OGCtP95paV1yPIN93EfKo2rJgaErHg -TuixO/XWb/Ew1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQE -AwIBBjAdBgNVHQ4EFgQUS8W0QGutHLOlHGVuRjaJhwUMDrYwDQYJKoZIhvcNAQEL -BQADggIBAHNXPyzVlTJ+N9uWkusZXn5T50HsEbZH77Xe7XRcxfGOSeD8bpkTzZ+K -2s06Ctg6Wgk/XzTQLwPSZh0avZyQN8gMjgdalEVGKua+etqhqaRpEpKwfTbURIfX -UfEpY9Z1zRbkJ4kd+MIySP3bmdCPX1R0zKxnNBFi2QwKN4fRoxdIjtIXHfbX/dtl -6/2o1PXWT6RbdejF0mCy2wl+JYt7ulKSnj7oxXehPOBKc2thz4bcQ///If4jXSRK -9dNtD2IEBVeC2m6kMyV5Sy5UGYvMLD0w6dEG/+gyRr61M3Z3qAFdlsHB1b6uJcDJ -HgoJIIihDsnzb02CVAAgp9KP5DlUFy6NHrgbuxu9mk47EDTcnIhT76IxW1hPkWLI -wpqazRVdOKnWvvgTtZ8SafJQYqz7Fzf07rh1Z2AQ+4NQ+US1dZxAF7L+/XldblhY -XzD8AK6vM8EOTmy6p6ahfzLbOOCxchcKK5HsamMm7YnUeMx0HgX4a/6ManY5Ka5l -IxKVCCIcl85bBu4M4ru8H0ST9tg4RQUh7eStqxK2A6RCLi3ECToDZ2mEmuFZkIoo -hdVddLHRDiBYmxOlsGOm7XtH/UVVMKTumtTm4ofvmMkyghEpIrwACjFeLQ/Ajulr -so8uBtjRkcfGEvRM/TAXw8HaOFvjqermobp573PYtlNXLfbQ4ddI ------END CERTIFICATE----- -# "Swisscom Root CA 1" -# 21 DB 20 12 36 60 BB 2E D4 18 20 5D A1 1E E7 A8 -# 5A 65 E2 BC 6E 55 B5 AF 7E 78 99 C8 A2 66 D9 2E ------BEGIN CERTIFICATE----- -MIIF2TCCA8GgAwIBAgIQXAuFXAvnWUHfV8w/f52oNjANBgkqhkiG9w0BAQUFADBk -MQswCQYDVQQGEwJjaDERMA8GA1UEChMIU3dpc3Njb20xJTAjBgNVBAsTHERpZ2l0 -YWwgQ2VydGlmaWNhdGUgU2VydmljZXMxGzAZBgNVBAMTElN3aXNzY29tIFJvb3Qg -Q0EgMTAeFw0wNTA4MTgxMjA2MjBaFw0yNTA4MTgyMjA2MjBaMGQxCzAJBgNVBAYT -AmNoMREwDwYDVQQKEwhTd2lzc2NvbTElMCMGA1UECxMcRGlnaXRhbCBDZXJ0aWZp -Y2F0ZSBTZXJ2aWNlczEbMBkGA1UEAxMSU3dpc3Njb20gUm9vdCBDQSAxMIICIjAN -BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0LmwqAzZuz8h+BvVM5OAFmUgdbI9 -m2BtRsiMMW8Xw/qabFbtPMWRV8PNq5ZJkCoZSx6jbVfd8StiKHVFXqrWW/oLJdih -FvkcxC7mlSpnzNApbjyFNDhhSbEAn9Y6cV9Nbc5fuankiX9qUvrKm/LcqfmdmUc/ -TilftKaNXXsLmREDA/7n29uj/x2lzZAeAR81sH8A25Bvxn570e56eqeqDFdvpG3F -EzuwpdntMhy0XmeLVNxzh+XTF3xmUHJd1BpYwdnP2IkCb6dJtDZd0KTeByy2dbco -kdaXvij1mB7qWybJvbCXc9qukSbraMH5ORXWZ0sKbU/Lz7DkQnGMU3nn7uHbHaBu -HYwadzVcFh4rUx80i9Fs/PJnB3r1re3WmquhsUvhzDdf/X/NTa64H5xD+SpYVUNF -vJbNcA78yeNmuk6NO4HLFWR7uZToXTNShXEuT46iBhFRyePLoW4xCGQMwtI89Tbo -19AOeCMgkckkKmUpWyL3Ic6DXqTz3kvTaI9GdVyDCW4pa8RwjPWd1yAv/0bSKzjC -L3UcPX7ape8eYIVpQtPM+GP+HkM5haa2Y0EQs3MevNP6yn0WR+Kn1dCjigoIlmJW -bjTb2QK5MHXjBNLnj8KwEUAKrNVxAmKLMb7dxiNYMUJDLXT5xp6mig/p/r+D5kNX -JLrvRjSq1xIBOO0CAwEAAaOBhjCBgzAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0hBBYw -FDASBgdghXQBUwABBgdghXQBUwABMBIGA1UdEwEB/wQIMAYBAf8CAQcwHwYDVR0j -BBgwFoAUAyUv3m+CATpcLNwroWm1Z9SM0/0wHQYDVR0OBBYEFAMlL95vggE6XCzc -K6FptWfUjNP9MA0GCSqGSIb3DQEBBQUAA4ICAQA1EMvspgQNDQ/NwNurqPKIlwzf -ky9NfEBWMXrrpA9gzXrzvsMnjgM+pN0S734edAY8PzHyHHuRMSG08NBsl9Tpl7Ik -Vh5WwzW9iAUPWxAaZOHHgjD5Mq2eUCzneAXQMbFamIp1TpBcahQq4FJHgmDmHtqB -sfsUC1rxn9KVuj7QG9YVHaO+htXbD8BJZLsuUBlL0iT43R4HVtA4oJVwIHaM190e -3p9xxCPvgxNcoyQVTSlAPGrEqdi3pkSlDfTgnXceQHAm/NrZNuR55LU/vJtlvrsR -ls/bxig5OgjOR1tTWsWZ/l2p3e9M1MalrQLmjAcSHm8D0W+go/MpvRLHUKKwf4ip -mXeascClOS5cfGniLLDqN2qk4Vrh9VDlg++luyqI54zb/W1elxmofmZ1a3Hqv7HH -b6D0jqTsNFFbjCYDcKF31QESVwA12yPeDooomf2xEG9L/zgtYE4snOtnta1J7ksf -rK/7DZBaZmBwXarNeNQk7shBoJMBkpxqnvy5JMWzFYJ+vq6VK+uxwNrjAWALXmms -hFZhvnEX/h0TD/7Gh0Xp/jKgGg0TpJRVcaUWi7rKibCyx/yP2FS1k2Kdzs9Z+z0Y -zirLNRWCXf9UIltxUvu3yf5gmwBBZPCqKuy2QkPOiWaByIufOVQDJdMWNY6E0F/6 -MBr1mmz0DlP5OlvRHA== ------END CERTIFICATE----- -# "Swisscom Root CA 2" -# F0 9B 12 2C 71 14 F4 A0 9B D4 EA 4F 4A 99 D5 58 -# B4 6E 4C 25 CD 81 14 0D 29 C0 56 13 91 4C 38 41 ------BEGIN CERTIFICATE----- -MIIF2TCCA8GgAwIBAgIQHp4o6Ejy5e/DfEoeWhhntjANBgkqhkiG9w0BAQsFADBk -MQswCQYDVQQGEwJjaDERMA8GA1UEChMIU3dpc3Njb20xJTAjBgNVBAsTHERpZ2l0 -YWwgQ2VydGlmaWNhdGUgU2VydmljZXMxGzAZBgNVBAMTElN3aXNzY29tIFJvb3Qg -Q0EgMjAeFw0xMTA2MjQwODM4MTRaFw0zMTA2MjUwNzM4MTRaMGQxCzAJBgNVBAYT -AmNoMREwDwYDVQQKEwhTd2lzc2NvbTElMCMGA1UECxMcRGlnaXRhbCBDZXJ0aWZp -Y2F0ZSBTZXJ2aWNlczEbMBkGA1UEAxMSU3dpc3Njb20gUm9vdCBDQSAyMIICIjAN -BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAlUJOhJ1R5tMJ6HJaI2nbeHCOFvEr -jw0DzpPMLgAIe6szjPTpQOYXTKueuEcUMncy3SgM3hhLX3af+Dk7/E6J2HzFZ++r -0rk0X2s682Q2zsKwzxNoysjL67XiPS4h3+os1OD5cJZM/2pYmLcX5BtS5X4HAB1f -2uY+lQS3aYg5oUFgJWFLlTloYhyxCwWJwDaCFCE/rtuh/bxvHGCGtlOUSbkrRsVP -ACu/obvLP+DHVxxX6NZp+MEkUp2IVd3Chy50I9AU/SpHWrumnf2U5NGKpV+GY3aF -y6//SSj8gO1MedK75MDvAe5QQQg1I3ArqRa0jG6F6bYRzzHdUyYb3y1aSgJA/MTA -tukxGggo5WDDH8SQjhBiYEQN7Aq+VRhxLKX0srwVYv8c474d2h5Xszx+zYIdkeNL -6yxSNLCK/RJOlrDrcH+eOfdmQrGrrFLadkBXeyq96G4DsguAhYidDMfCd7Camlf0 -uPoTXGiTOmekl9AbmbeGMktg2M7v0Ax/lZ9vh0+Hio5fCHyqW/xavqGRn1V9TrAL -acywlKinh/LTSlDcX3KwFnUey7QYYpqwpzmqm59m2I2mbJYV4+by+PGDYmy7Velh -k6M99bFXi08jsJvllGov34zflVEpYKELKeRcVVi3qPyZ7iVNTA6z00yPhOgpD/0Q -VAKFyPnlw4vP5w8CAwEAAaOBhjCBgzAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0hBBYw -FDASBgdghXQBUwIBBgdghXQBUwIBMBIGA1UdEwEB/wQIMAYBAf8CAQcwHQYDVR0O -BBYEFE0mICKJS9PVpAqhb97iEoHF8TwuMB8GA1UdIwQYMBaAFE0mICKJS9PVpAqh -b97iEoHF8TwuMA0GCSqGSIb3DQEBCwUAA4ICAQAyCrKkG8t9voJXiblqf/P0wS4R -fbgZPnm3qKhyN2abGu2sEzsOv2LwnN+ee6FTSA5BesogpxcbtnjsQJHzQq0Qw1zv -/2BZf82Fo4s9SBwlAjxnffUy6S8w5X2lejjQ82YqZh6NM4OKb3xuqFp1mrjX2lhI -REeoTPpMSQpKwhI3qEAMw8jh0FcNlzKVxzqfl9NX+Ave5XLzo9v/tdhZsnPdTSpx -srpJ9csc1fV5yJmz/MFMdOO0vSk3FQQoHt5FRnDsr7p4DooqzgB53MBfGWcsa0vv -aGgLQ+OswWIJ76bdZWGgr4RVSJFSHMYlkSrQwSIjYVmvRRGFHQEkNI/Ps/8XciAT -woCqISxxOQ7Qj1zB09GOInJGTB2Wrk9xseEFKZZZ9LuedT3PDTcNYtsmjGOpI99n -Bjx8Oto0QuFmtEYE3saWmA9LSHokMnWRn6z3aOkquVVlzl1h0ydw2Df+n7mvoC5W -t6NlUe07qxS/TFED6F+KBZvuim6c779o+sjaC+NCydAXFJy3SuCvkychVSa1ZC+N -8f+mQAWFBVzKBxlcCxMoTFh/wqXvRdpg065lYZ1Tg3TCrvJcwhbtkj6EPnNgiLx2 -9CzP0H1907he0ZESEOnN3col49XtmS++dYFLJPlFRpTJKSFTnCZFqhMX5OfNeOI5 -wSsSnqaeG8XmDtkx2Q== ------END CERTIFICATE----- -# "Swisscom Root EV CA 2" -# D9 5F EA 3C A4 EE DC E7 4C D7 6E 75 FC 6D 1F F6 -# 2C 44 1F 0F A8 BC 77 F0 34 B1 9E 5D B2 58 01 5D ------BEGIN CERTIFICATE----- -MIIF4DCCA8igAwIBAgIRAPL6ZOJ0Y9ON/RAdBB92ylgwDQYJKoZIhvcNAQELBQAw -ZzELMAkGA1UEBhMCY2gxETAPBgNVBAoTCFN3aXNzY29tMSUwIwYDVQQLExxEaWdp -dGFsIENlcnRpZmljYXRlIFNlcnZpY2VzMR4wHAYDVQQDExVTd2lzc2NvbSBSb290 -IEVWIENBIDIwHhcNMTEwNjI0MDk0NTA4WhcNMzEwNjI1MDg0NTA4WjBnMQswCQYD -VQQGEwJjaDERMA8GA1UEChMIU3dpc3Njb20xJTAjBgNVBAsTHERpZ2l0YWwgQ2Vy -dGlmaWNhdGUgU2VydmljZXMxHjAcBgNVBAMTFVN3aXNzY29tIFJvb3QgRVYgQ0Eg -MjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMT3HS9X6lds93BdY7Bx -UglgRCgzo3pOCvrY6myLURYaVa5UJsTMRQdBTxB5f3HSek4/OE6zAMaVylvNwSqD -1ycfMQ4jFrclyxy0uYAyXhqdk/HoPGAsp15XGVhRXrwsVgu42O+LgrQ8uMIkqBPH -oCE2G3pXKSinLr9xJZDzRINpUKTk4RtiGZQJo/PDvO/0vezbE53PnUgJUmfANykR -HvvSEaeFGHR55E+FFOtSN+KxRdjMDUN/rhPSays/p8LiqG12W0OfvrSdsyaGOx9/ -5fLoZigWJdBLlzin5M8J0TbDC77aO0RYjb7xnglrPvMyxyuHxuxenPaHZa0zKcQv -idm5y8kDnftslFGXEBuGCxobP/YCfnvUxVFkKJ3106yDgYjTdLRZncHrYTNaRdHL -OdAGalNgHa/2+2m8atwBz735j9m9W8E6X47aD0upm50qKGsaCnw8qyIL5XctcfaC -NYGu+HuB5ur+rPQam3Rc6I8k9l2dRsQs0h4rIWqDJ2dVSqTjyDKXZpBy2uPUZC5f -46Fq9mDU5zXNysRojddxyNMkM3OxbPlq4SjbX8Y96L5V5jcb7STZDxmPX2MYWFCB -UWVv8p9+agTnNCRxunZLWB4ZvRVgRaoMEkABnRDixzgHcgplwLa7JSnaFp6LNYth -7eVxV4O1PHGf40+/fh6Bn0GXAgMBAAGjgYYwgYMwDgYDVR0PAQH/BAQDAgGGMB0G -A1UdIQQWMBQwEgYHYIV0AVMCAgYHYIV0AVMCAjASBgNVHRMBAf8ECDAGAQH/AgED -MB0GA1UdDgQWBBRF2aWBbj2ITY1x0kbBbkUe88SAnTAfBgNVHSMEGDAWgBRF2aWB -bj2ITY1x0kbBbkUe88SAnTANBgkqhkiG9w0BAQsFAAOCAgEAlDpzBp9SSzBc1P6x -XCX5145v9Ydkn+0UjrgEjihLj6p7jjm02Vj2e6E1CqGdivdj5eu9OYLU43otb98T -PLr+flaYC/NUn81ETm484T4VvwYmneTwkLbUwp4wLh/vx3rEUMfqe9pQy3omywC0 -Wqu1kx+AiYQElY2NfwmTv9SoqORjbdlk5LgpWgi/UOGED1V7XwgiG/W9mR4U9s70 -WBCCswo9GcG/W6uqmdjyMb3lOGbcWAXH7WMaLgqXfIeTK7KK4/HsGOV1timH59yL -Gn602MnTihdsfSlEvoqq9X46Lmgxk7lq2prg2+kupYTNHAq4Sgj5nPFhJpiTt3tm -7JFe3VE/23MPrQRYCd0EApUKPtN236YQHoA96M2kZNEzx5LH4k5E4wnJTsJdhw4S -nr8PyQUQ3nqjsTzyP6WqJ3mtMX0f/fwZacXduT98zca0wjAefm6S139hdlqP65VN -vBFuIXxZN5nQBrz5Bm0yFqXZaajh3DyAHmBR3NdUIR7KYndP+tiPsys6DXhyyWhB -WkdKwqPrGtcKqzwyVcgKEZzfdNbwQBUdyLmPtTbFr/giuMod89a2GQ+fYWVq6nTI -fI/DT11lgh/ZDYnadXL77/FHZxOzyNEZiCcmmpl5fx7kLD977vHeTYuWl8PVP3wb -I+2ksx0WckNLIOFZfsLorSa/ovc= ------END CERTIFICATE----- -# "SwissSign Gold CA - G2" -# 62 DD 0B E9 B9 F5 0A 16 3E A0 F8 E7 5C 05 3B 1E -# CA 57 EA 55 C8 68 8F 64 7C 68 81 F2 C8 35 7B 95 ------BEGIN CERTIFICATE----- -MIIFujCCA6KgAwIBAgIJALtAHEP1Xk+wMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV -BAYTAkNIMRUwEwYDVQQKEwxTd2lzc1NpZ24gQUcxHzAdBgNVBAMTFlN3aXNzU2ln -biBHb2xkIENBIC0gRzIwHhcNMDYxMDI1MDgzMDM1WhcNMzYxMDI1MDgzMDM1WjBF -MQswCQYDVQQGEwJDSDEVMBMGA1UEChMMU3dpc3NTaWduIEFHMR8wHQYDVQQDExZT -d2lzc1NpZ24gR29sZCBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC -CgKCAgEAr+TufoskDhJuqVAtFkQ7kpJcyrhdhJJCEyq8ZVeCQD5XJM1QiyUqt2/8 -76LQwB8CJEoTlo8jE+YoWACjR8cGp4QjK7u9lit/VcyLwVcfDmJlD909Vopz2q5+ -bbqBHH5CjCA12UNNhPqE21Is8w4ndwtrvxEvcnifLtg+5hg3Wipy+dpikJKVyh+c -6bM8K8vzARO/Ws/BtQpgvd21mWRTuKCWs2/iJneRjOBiEAKfNA+k1ZIzUd6+jbqE -emA8atufK+ze3gE/bk3lUIbLtK/tREDFylqM2tIrfKjuvqblCqoOpd8FUrdVxyJd -MmqXl2MT28nbeTZ7hTpKxVKJ+STnnXepgv9VHKVxaSvRAiTysybUa9oEVeXBCsdt -MDeQKuSeFDNeFhdVxVu1yzSJkvGdJo+hB9TGsnhQ2wwMC3wLjEHXuendjIj3o02y -MszYF9rNt85mndT9Xv+9lz4pded+p2JYryU0pUHHPbwNUMoDAw8IWh+Vc3hiv69y -FGkOpeUDDniOJihC8AcLYiAQZzlG+qkDzAQ4embvIIO1jEpWjpEA/I5cgt6IoMPi -aG59je883WX0XaxR7ySArqpWl2/5rX3aYT+YdzylkbYcjCbaZaIJbcHiVOO5ykxM -gI93e2CaHt+28kgeDrpOVG2Y4OGiGqJ3UM/EY5LsRxmd6+ZrzsECAwEAAaOBrDCB -qTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyV7 -lqRlUX64OfPAeGZe6Drn8O4wHwYDVR0jBBgwFoAUWyV7lqRlUX64OfPAeGZe6Drn -8O4wRgYDVR0gBD8wPTA7BglghXQBWQECAQEwLjAsBggrBgEFBQcCARYgaHR0cDov -L3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIBACe6 -45R88a7A3hfm5djV9VSwg/S7zV4Fe0+fdWavPOhWfvxyeDgD2StiGwC5+OlgzczO -UYrHUDFu4Up+GC9pWbY9ZIEr44OE5iKHjn3g7gKZYbge9LgriBIWhMIxkziWMaa5 -O1M/wySTVltpkuzFwbs4AOPsF6m43Md8AYOfMke6UiI0HTJ6CVanfCU2qT1L2sCC -bwq7EsiHSycR+R4tx5M/nttfJmtS2S6K8RTGRI0Vqbe/vd6mGu6uLftIdxf+u+yv -GPUqUfA5hJeVbG4bwyvEdGB5JbAKJ9/fXtI5z0V9QkvfsywexcZdylU6oJxpmo/a -77KwPJ+HbBIrZXAVUjEaJM9vMSNQH4xPjyPDdEFjHFWoFN0+4FFQz/EbMFYOkrCC -hdiDyyJkvC24JdVUorgG6q2SpCSgwYa1ShNqR88uC1aVVMvOmttqtKay20EIhid3 -92qgQmwLOM7XdVAyksLfKzAiSNDVQTglXaTpXZ/GlHXQRf0wl0OPkKsKx4ZzYEpp -Ld6leNcG2mqeSz53OiATIgHQv2ieY2BrNU0LbbqhPcCT4H8js1WtciVORvnSFu+w -ZMEBnunKoGqYDs/YYPIvSbjkQuE4NRb0yG5P94FW6LqjviOvrv1vA+ACOzB2+htt -Qc8Bsem4yWb02ybzOqR08kkkW8mw0FfB+j564ZfJ ------END CERTIFICATE----- -# "SwissSign Platinum CA - G2" -# 3B 22 2E 56 67 11 E9 92 30 0D C0 B1 5A B9 47 3D -# AF DE F8 C8 4D 0C EF 7D 33 17 B4 C1 82 1D 14 36 ------BEGIN CERTIFICATE----- -MIIFwTCCA6mgAwIBAgIITrIAZwwDXU8wDQYJKoZIhvcNAQEFBQAwSTELMAkGA1UE -BhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEjMCEGA1UEAxMaU3dpc3NTaWdu -IFBsYXRpbnVtIENBIC0gRzIwHhcNMDYxMDI1MDgzNjAwWhcNMzYxMDI1MDgzNjAw -WjBJMQswCQYDVQQGEwJDSDEVMBMGA1UEChMMU3dpc3NTaWduIEFHMSMwIQYDVQQD -ExpTd2lzc1NpZ24gUGxhdGludW0gQ0EgLSBHMjCCAiIwDQYJKoZIhvcNAQEBBQAD -ggIPADCCAgoCggIBAMrfogLi2vj8Bxax3mCq3pZcZB/HL37PZ/pEQtZ2Y5Wu669y -IIpFR4ZieIbWIDkm9K6j/SPnpZy1IiEZtzeTIsBQnIJ71NUERFzLtMKfkr4k2Htn -IuJpX+UFeNSH2XFwMyVTtIc7KZAoNppVRDBopIOXfw0enHb/FZ1glwCNioUD7IC+ -6ixuEFGSzH7VozPY1kneWCqv9hbrS3uQMpe5up1Y8fhXSQQeol0GcN1x2/ndi5ob -jM89o03Oy3z2u5yg+gnOI2Ky6Q0f4nIoj5+saCB9bzuohTEJfwvH6GXp43gOCWcw -izSC+13gzJ2BbWLuCB4ELE6b7P6pT1/9aXjvCR+htL/68++QHkwFix7qepF6w9fl -+zC8bBsQWJj3Gl/QKTIDE0ZNYWqFTFJ0LwYfexHihJfGmfNtf9dng34TaNhxKFrY -zt3oEBSa/m0jh26OWnA81Y0JAKeqvLAxN23IhBQeW71FYyBrS3SMvds6DsHPWhaP -pZjydomyExI7C3d3rLvlPClKknLKYRorXkzig3R3+jVIeoVNjZpTxN94ypeRSCtF -KwH3HBqi7Ri6Cr2D+m+8jVeTO9TUps4e8aCxzqv9KyiaTxvXw3LbpMS/XUz13XuW -ae5ogObnmLo2t/5u7Su9IPhlGdpVCX4l3P5hYnL5fhgC72O00Puv5TtjjGePAgMB -AAGjgawwgakwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O -BBYEFFCvzAeHFUdvOMW0ZdHelarp35zMMB8GA1UdIwQYMBaAFFCvzAeHFUdvOMW0 -ZdHelarp35zMMEYGA1UdIAQ/MD0wOwYJYIV0AVkBAQEBMC4wLAYIKwYBBQUHAgEW -IGh0dHA6Ly9yZXBvc2l0b3J5LnN3aXNzc2lnbi5jb20vMA0GCSqGSIb3DQEBBQUA -A4ICAQAIhab1Fgz8RBrBY+D5VUYI/HAcQiiWjrfFwUF1TglxeeVtlspLpYhg0DB0 -uMoI3LQwnkAHFmtllXcBrqS3NQuB2nEVqXQXOHtYyvkv+8Bldo1bAbl93oI9ZLi+ -FHSjClTTLJUYFzX1UWs/j6KWYTl4a0vlpqD4U99REJNi54Av4tHgvI42Rncz7Lj7 -jposiU0xEQ8mngS7twSNC/K5/FqdOxa3L8iYq/6KUFkuozv8KV2LwUvJ4ooTHbG/ -u0IdUt1O2BReEMYxB+9xJ/cbOQncguqLs5WGXv312l0xpuAxtpTmREl0xRbl9x8D -YSjFyMsSoEJL+WuICI20MhjzdZ/EfwBPBZWcoxcCw7NTm6ogOSkrZvqdr16zktK1 -puEa+S1BaYEUtLS17Yk9zvupnTVCRLEcFHOBzyoBNZox1S2PbYTfgE1X4z/FhHXa -icYwu+uPyyIIoK6q8QNsOktNCaUOcsZWayFCTiMlFGiudgp8DAdwZPmaL/YFOSbG -DI8Zf0NebvRbFS/bYV3mZy8/CJT5YLSYMdp08YSTcU1f+2BY0fvEwW2JorsgH51x -kcsymxM9Pn2SUjWskpSi0xjCfMfqr3YFFt1nJ8J+HAciIfNAChs0B0QTwoRqjt8Z -Wr9/6x3iGjjRXK9HkmuAtTClyY3YqzGBH9/CZjfTk6mFhnll0g== ------END CERTIFICATE----- -# "SwissSign Silver CA - G2" -# BE 6C 4D A2 BB B9 BA 59 B6 F3 93 97 68 37 42 46 -# C3 C0 05 99 3F A9 8F 02 0D 1D ED BE D4 8A 81 D5 ------BEGIN CERTIFICATE----- -MIIFvTCCA6WgAwIBAgIITxvUL1S7L0swDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UE -BhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMYU3dpc3NTaWdu -IFNpbHZlciBDQSAtIEcyMB4XDTA2MTAyNTA4MzI0NloXDTM2MTAyNTA4MzI0Nlow -RzELMAkGA1UEBhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMY -U3dpc3NTaWduIFNpbHZlciBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A -MIICCgKCAgEAxPGHf9N4Mfc4yfjDmUO8x/e8N+dOcbpLj6VzHVxumK4DV644N0Mv -Fz0fyM5oEMF4rhkDKxD6LHmD9ui5aLlV8gREpzn5/ASLHvGiTSf5YXu6t+WiE7br -YT7QbNHm+/pe7R20nqA1W6GSy/BJkv6FCgU+5tkL4k+73JU3/JHpMjUi0R86TieF -nbAVlDLaYQ1HTWBCrpJH6INaUFjpiou5XaHc3ZlKHzZnu0jkg7Y360g6rw9njxcH -6ATK72oxh9TAtvmUcXtnZLi2kUpCe2UuMGoM9ZDulebyzYLs2aFK7PayS+VFheZt -eJMELpyCbTapxDFkH4aDCyr0NQp4yVXPQbBH6TCfmb5hqAaEuSh6XzjZG6k4sIN/ -c8HDO0gqgg8hm7jMqDXDhBuDsz6+pJVpATqJAHgE2cn0mRmrVn5bi4Y5FZGkECwJ -MoBgs5PAKrYYC51+jUnyEEp/+dVGLxmSo5mnJqy7jDzmDrxHB9xzUfFwZC8I+bRH -HTBsROopN4WSaGa8gzj+ezku01DwH/teYLappvonQfGbGHLy9YR0SslnxFSuSGTf -jNFusB3hB48IHpmccelM2KX3RxIfdNFRnobzwqIjQAtz20um53MGjMGg6cFZrEb6 -5i/4z3GcRm25xBWNOHkDRUjvxF3XCO6HOSKGsg0PWEP3calILv3q1h8CAwEAAaOB -rDCBqTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU -F6DNweRBtjpbO8tFnb0cwpj6hlgwHwYDVR0jBBgwFoAUF6DNweRBtjpbO8tFnb0c -wpj6hlgwRgYDVR0gBD8wPTA7BglghXQBWQEDAQEwLjAsBggrBgEFBQcCARYgaHR0 -cDovL3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIB -AHPGgeAn0i0P4JUw4ppBf1AsX19iYamGamkYDHRJ1l2E6kFSGG9YrVBWIGrGvShp -WJHckRE1qTodvBqlYJ7YH39FkWnZfrt4csEGDyrOj4VwYaygzQu4OSlWhDJOhrs9 -xCrZ1x9y7v5RoSJBsXECYxqCsGKrXlcSH9/L3XWgwF15kIwb4FDm3jH+mHtwX6WQ -2K34ArZv02DdQEsixT2tOnqfGhpHkXkzuoLcMmkDlm4fS/Bx/uNncqCxv1yL5PqZ -IseEuRuNI5c/7SXgz2W79WEE790eslpBIlqhn10s6FvJbakMDHiqYMZWjwFaDGi8 -aRl5xB9+lwW/xekkUV7U1UtT7dkjWjYDZaPBA61BMPNGG4WQr2W11bHkFlt4dR2X -em1ZqSqPe97Dh4kQmUlzeMg9vVE1dCrV8X5pGyq7O70luJpaPXJhkGaH7gzWTdQR -dAtq/gsD/KNVV4n+SsuuWxcFyPKNIzFTONItaj+CuY0IavdeQXRuwxF+B6wpYJE/ -OMpXEA29MC/HpeZBoNquBYeaoKRlbEwJDIm6uNO5wJOKMPqN5ZprFQFOZ6raYlY+ -hAhm0sQ2fac+EPyI4NSA5QC9qvNOBqN6avlicuMJT+ubDgEj8Z+7fNzcbBGXJbLy -tGMU0gYqZ4yD9c7qB9iaah7s5Aq7KkzrCWA5zspi2C5u ------END CERTIFICATE----- -# "Symantec Class 1 Public Primary Certification Authority - G6" -# 9D 19 0B 2E 31 45 66 68 5B E8 A8 89 E2 7A A8 C7 -# D7 AE 1D 8A AD DB A3 C1 EC F9 D2 48 63 CD 34 B9 ------BEGIN CERTIFICATE----- -MIID9jCCAt6gAwIBAgIQJDJ18h0v0gkz97RqytDzmDANBgkqhkiG9w0BAQsFADCB -lDELMAkGA1UEBhMCVVMxHTAbBgNVBAoTFFN5bWFudGVjIENvcnBvcmF0aW9uMR8w -HQYDVQQLExZTeW1hbnRlYyBUcnVzdCBOZXR3b3JrMUUwQwYDVQQDEzxTeW1hbnRl -YyBDbGFzcyAxIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5 -IC0gRzYwHhcNMTExMDE4MDAwMDAwWhcNMzcxMjAxMjM1OTU5WjCBlDELMAkGA1UE -BhMCVVMxHTAbBgNVBAoTFFN5bWFudGVjIENvcnBvcmF0aW9uMR8wHQYDVQQLExZT -eW1hbnRlYyBUcnVzdCBOZXR3b3JrMUUwQwYDVQQDEzxTeW1hbnRlYyBDbGFzcyAx -IFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzYwggEi -MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDHOddJZKmZgiJM6kXZBxbje/SD -6Jlz+muxNuCad6BAwoGNAcfMjL2Pffd543pMA03Z+/2HOCgs3ZqLVAjbZ/sbjP4o -ki++t7JIp4Gh2F6Iw8w5QEFa0dzl2hCfL9oBTf0uRnz5LicKaTfukaMbasxEvxvH -w9QRslBglwm9LiL1QYRmn81ApqkAgMEflZKf3vNI79sdd2H8f9/ulqRy0LY+/3gn -r8uSFWkI22MQ4uaXrG7crPaizh5HmbmJtxLmodTNWRFnw2+F2EJOKL5ZVVkElauP -N4C/DfD8HzpkMViBeNfiNfYgPym4jxZuPkjctUwH4fIa6n4KedaovetdhitNAgMB -AAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW -BBQzQejIORIVk0jyljIuWvXalF9TYDANBgkqhkiG9w0BAQsFAAOCAQEAFeNzV7EX -tl9JaUSm9l56Z6zS3nVJq/4lVcc6yUQVEG6/MWvL2QeTfxyFYwDjMhLgzMv7OWyP -4lPiPEAz2aSMR+atWPuJr+PehilWNCxFuBL6RIluLRQlKCQBZdbqUqwFblYSCT3Q -dPTXvQbKqDqNVkL6jXI+dPEDct+HG14OelWWLDi3mIXNTTNEyZSPWjEwN0ujOhKz -5zbRIWhLLTjmU64cJVYIVgNnhJ3Gw84kYsdMNs+wBkS39V8C3dlU6S+QTnrIToNA -DJqXPDe/v+z28LSFdyjBC8hnghAXOKK3Buqbvzr46SMHv3TgmDgVVXjucgBcGaP0 -0jPg/73RVDkpDw== ------END CERTIFICATE----- -# "Symantec Class 2 Public Primary Certification Authority - G6" -# CB 62 7D 18 B5 8A D5 6D DE 33 1A 30 45 6B C6 5C -# 60 1A 4E 9B 18 DE DC EA 08 E7 DA AA 07 81 5F F0 ------BEGIN CERTIFICATE----- -MIID9jCCAt6gAwIBAgIQZIKe/DcedF38l/+XyLH/QTANBgkqhkiG9w0BAQsFADCB -lDELMAkGA1UEBhMCVVMxHTAbBgNVBAoTFFN5bWFudGVjIENvcnBvcmF0aW9uMR8w -HQYDVQQLExZTeW1hbnRlYyBUcnVzdCBOZXR3b3JrMUUwQwYDVQQDEzxTeW1hbnRl -YyBDbGFzcyAyIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5 -IC0gRzYwHhcNMTExMDE4MDAwMDAwWhcNMzcxMjAxMjM1OTU5WjCBlDELMAkGA1UE -BhMCVVMxHTAbBgNVBAoTFFN5bWFudGVjIENvcnBvcmF0aW9uMR8wHQYDVQQLExZT -eW1hbnRlYyBUcnVzdCBOZXR3b3JrMUUwQwYDVQQDEzxTeW1hbnRlYyBDbGFzcyAy -IFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzYwggEi -MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDNzOkFyGOFyz9AYxe9GPo15gRn -V2WYKaRPyVyPDzTS+NqoE2KquB5QZ3iwFkygOakVeq7t0qLA8JA3KRgmXOgNPLZs -ST/B4NzZS7YUGQum05bh1gnjGSYc+R9lS/kaQxwAg9bQqkmi1NvmYji6UBRDbfkx -+FYW2TgCkc/rbN27OU6Z4TBnRfHU8I3D3/7yOAchfQBeVkSz5GC9kSucq1sEcg+y -KNlyqwUgQiWpWwNqIBDMMfAr2jUs0Pual07wgksr2F82owstr2MNHSV/oW5cYqGN -KD6h/Bwg+AEvulWaEbAZ0shQeWsOagXXqgQ2sqPy4V93p3ec5R7c6d9qwWVdAgMB -AAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW -BBSHjCCVyJhK0daABkqQNETfHE2/sDANBgkqhkiG9w0BAQsFAAOCAQEAgY6ypWaW -tyGltu9vI1pf24HFQqV4wWn99DzX+VxrcHIa/FqXTQCAiIiCisNxDY7FiZss7Y0L -0nJU9X3UXENX6fOupQIR9nYrgVfdfdp0MP1UR/bgFm6mtApI5ud1Bw8pGTnOefS2 -bMVfmdUfS/rfbSw8DVSAcPCIC4DPxmiiuB1w2XaM/O6lyc+tHc+ZJVdaYkXLFmu9 -Sc2lo4xpeSWuuExsi0BmSxY/zwIa3eFsawdhanYVKZl/G92IgMG/tY9zxaaWI4Sm -KIYkM2oBLldzJbZev4/mHWGoQClnHYebHX+bn5nNMdZUvmK7OaxoEkiRIKXLsd3+ -b/xa5IJVWa8xqQ== ------END CERTIFICATE----- -# "SZAFIR ROOT CA" -# FA BC F5 19 7C DD 7F 45 8A C3 38 32 D3 28 40 21 -# DB 24 25 FD 6B EA 7A 2E 69 B7 48 6E 8F 51 F9 CC ------BEGIN CERTIFICATE----- -MIIDcTCCAlmgAwIBAgIVAOYJ/nrqAGiM4CS07SAbH+9StETRMA0GCSqGSIb3DQEB -BQUAMFAxCzAJBgNVBAYTAlBMMSgwJgYDVQQKDB9LcmFqb3dhIEl6YmEgUm96bGlj -emVuaW93YSBTLkEuMRcwFQYDVQQDDA5TWkFGSVIgUk9PVCBDQTAeFw0xMTEyMDYx -MTEwNTdaFw0zMTEyMDYxMTEwNTdaMFAxCzAJBgNVBAYTAlBMMSgwJgYDVQQKDB9L -cmFqb3dhIEl6YmEgUm96bGljemVuaW93YSBTLkEuMRcwFQYDVQQDDA5TWkFGSVIg -Uk9PVCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKxHL49ZMTml -6g3wpYwrvQKkvc0Kc6oJ5sxfgmp1qZfluwbv88BdocHSiXlY8NzrVYzuWBp7J/9K -ULMAoWoTIzOQ6C9TNm4YbA9A1jdX1wYNL5Akylf8W5L/I4BXhT9KnlI6x+a7BVAm -nr/Ttl+utT/Asms2fRfEsF2vZPMxH4UFqOAhFjxTkmJWf2Cu4nvRQJHcttB+cEAo -ag/hERt/+tzo4URz6x6r19toYmxx4FjjBkUhWQw1X21re//Hof2+0YgiwYT84zLb -eqDqCOMOXxvH480yGDkh/QoazWX3U75HQExT/iJlwnu7I1V6HXztKIwCBjsxffbH -3jOshCJtywcCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC -AQYwHQYDVR0OBBYEFFOSo33/gnbwM9TrkmdHYTMbaDsqMA0GCSqGSIb3DQEBBQUA -A4IBAQA5UFWd5EL/pBviIMm1zD2JLUCpp0mJG7JkwznIOzawhGmFFaxGoxAhQBEg -haP+E0KR66oAwVC6xe32QUVSHfWqWndzbODzLB8yj7WAR0cDM45ZngSBPBuFE3Wu -GLJX9g100ETfIX+4YBR/4NR/uvTnpnd9ete7Whl0ZfY94yuu4xQqB5QFv+P7IXXV -lTOjkjuGXEcyQAjQzbFaT9vIABSbeCXWBbjvOXukJy6WgAiclzGNSYprre8Ryydd -fmjW9HIGwsIO03EldivvqEYL1Hv1w/Pur+6FUEOaL68PEIUovfgwIB2BAw+vZDuw -cH0mX548PojGyg434cDjkSXa3mHF ------END CERTIFICATE----- -# "T-TeleSec GlobalRoot Class 2" -# 91 E2 F5 78 8D 58 10 EB A7 BA 58 73 7D E1 54 8A -# 8E CA CD 01 45 98 BC 0B 14 3E 04 1B 17 05 25 52 ------BEGIN CERTIFICATE----- -MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx -KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd -BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl -YyBHbG9iYWxSb290IENsYXNzIDIwHhcNMDgxMDAxMTA0MDE0WhcNMzMxMDAxMjM1 -OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy -aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50 -ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDIwggEiMA0G -CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqX9obX+hzkeXaXPSi5kfl82hVYAUd -AqSzm1nzHoqvNK38DcLZSBnuaY/JIPwhqgcZ7bBcrGXHX+0CfHt8LRvWurmAwhiC -FoT6ZrAIxlQjgeTNuUk/9k9uN0goOA/FvudocP05l03Sx5iRUKrERLMjfTlH6VJi -1hKTXrcxlkIF+3anHqP1wvzpesVsqXFP6st4vGCvx9702cu+fjOlbpSD8DT6Iavq -jnKgP6TeMFvvhk1qlVtDRKgQFRzlAVfFmPHmBiiRqiDFt1MmUUOyCxGVWOHAD3bZ -wI18gfNycJ5v/hqO2V81xrJvNHy+SE/iWjnX2J14np+GPgNeGYtEotXHAgMBAAGj -QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS/ -WSA2AHmgoCJrjNXyYdK4LMuCSjANBgkqhkiG9w0BAQsFAAOCAQEAMQOiYQsfdOhy -NsZt+U2e+iKo4YFWz827n+qrkRk4r6p8FU3ztqONpfSO9kSpp+ghla0+AGIWiPAC -uvxhI+YzmzB6azZie60EI4RYZeLbK4rnJVM3YlNfvNoBYimipidx5joifsFvHZVw -IEoHNN/q/xWA5brXethbdXwFeilHfkCoMRN3zUA7tFFHei4R40cR3p1m0IvVVGb6 -g1XqfMIpiRvpb7PO4gWEyS8+eIVibslfwXhjdFjASBgMmTnrpMwatXlajRWc2BQN -9noHV8cigwUtPJslJj0Ys6lDfMjIq2SPDqO/nBudMNva0Bkuqjzx+zOAduTNrRlP -BSeOE6Fuwg== ------END CERTIFICATE----- -# "T-TeleSec GlobalRoot Class 3" -# FD 73 DA D3 1C 64 4F F1 B4 3B EF 0C CD DA 96 71 -# 0B 9C D9 87 5E CA 7E 31 70 7A F3 E9 6D 52 2B BD ------BEGIN CERTIFICATE----- -MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx -KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd -BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl -YyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1 -OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy -aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50 -ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0G -CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN -8ELg63iIVl6bmlQdTQyK9tPPcPRStdiTBONGhnFBSivwKixVA9ZIw+A5OO3yXDw/ -RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuhdfsaa3Ox+M6pCSzyU9XDFES4 -hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Zf3WHHx+xGwpzJFu5 -ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W0eDrXltM -EnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj -QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1 -A/d2O2GCahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOy -WL6ukK2YJ5f+AbGwUgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ -1GSFS5mvJQQeyUapl96Cshtwn5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW30 -6gmv7PO15wWeph6KU1HWk4HMdJP2udqmJQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT -91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMivgkeGj5asuRrDFR6fUNOuIml -e9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7PHi4b6HQDWSieB4p -TpPDpFQUWw== ------END CERTIFICATE----- -# "TeliaSonera Root CA v1" -# DD 69 36 FE 21 F8 F0 77 C1 23 A1 A5 21 C1 22 24 -# F7 22 55 B7 3E 03 A7 26 06 93 E8 A2 4B 0F A3 89 ------BEGIN CERTIFICATE----- -MIIFODCCAyCgAwIBAgIRAJW+FqD3LkbxezmCcvqLzZYwDQYJKoZIhvcNAQEFBQAw -NzEUMBIGA1UECgwLVGVsaWFTb25lcmExHzAdBgNVBAMMFlRlbGlhU29uZXJhIFJv -b3QgQ0EgdjEwHhcNMDcxMDE4MTIwMDUwWhcNMzIxMDE4MTIwMDUwWjA3MRQwEgYD -VQQKDAtUZWxpYVNvbmVyYTEfMB0GA1UEAwwWVGVsaWFTb25lcmEgUm9vdCBDQSB2 -MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMK+6yfwIaPzaSZVfp3F -VRaRXP3vIb9TgHot0pGMYzHw7CTww6XScnwQbfQ3t+XmfHnqjLWCi65ItqwA3GV1 -7CpNX8GH9SBlK4GoRz6JI5UwFpB/6FcHSOcZrr9FZ7E3GwYq/t75rH2D+1665I+X -Z75Ljo1kB1c4VWk0Nj0TSO9P4tNmHqTPGrdeNjPUtAa9GAH9d4RQAEX1jF3oI7x+ -/jXh7VB7qTCNGdMJjmhnXb88lxhTuylixcpecsHHltTbLaC0H2kD7OriUPEMPPCs -81Mt8Bz17Ww5OXOAFshSsCPN4D7c3TxHoLs1iuKYaIu+5b9y7tL6pe0S7fyYGKkm -dtwoSxAgHNN/Fnct7W+A90m7UwW7XWjH1Mh1Fj+JWov3F0fUTPHSiXk+TT2YqGHe -Oh7S+F4D4MHJHIzTjU3TlTazN19jY5szFPAtJmtTfImMMsJu7D0hADnJoWjiUIMu -sDor8zagrC/kb2HCUQk5PotTubtn2txTuXZZNp1D5SDgPTJghSJRt8czu90VL6R4 -pgd7gUY2BIbdeTXHlSw7sKMXNeVzH7RcWe/a6hBle3rQf5+ztCo3O3CLm1u5K7fs -slESl1MpWtTwEhDcTwK7EpIvYtQ/aUN8Ddb8WHUBiJ1YFkveupD/RwGJBmr2X7KQ -arMCpgKIv7NHfirZ1fpoeDVNAgMBAAGjPzA9MA8GA1UdEwEB/wQFMAMBAf8wCwYD -VR0PBAQDAgEGMB0GA1UdDgQWBBTwj1k4ALP1j5qWDNXr+nuqF+gTEjANBgkqhkiG -9w0BAQUFAAOCAgEAvuRcYk4k9AwI//DTDGjkk0kiP0Qnb7tt3oNmzqjMDfz1mgbl -dxSR651Be5kqhOX//CHBXfDkH1e3damhXwIm/9fH907eT/j3HEbAek9ALCI18Bmx -0GtnLLCo4MBANzX2hFxc469CeP6nyQ1Q6g2EdvZR74NTxnr/DlZJLo961gzmJ1Tj -TQpgcmLNkQfWpb/ImWvtxBnmq0wROMVvMeJuScg/doAmAyYp4Db29iBT4xdwNBed -Y2gea+zDTYa4EzAvXUYNR0PVG6pZDrlcjQZIrXSHX8f8MVRBE+LHIQ6e4B4N4cB7 -Q4WQxYpYxmUKeFfyxiMPAdkgS94P+5KFdSpcc41teyWRyu5FrgZLAMzTsVlQ2jqI -OylDRl6XK1TOU2+NSueW+r9xDkKLfP0ooNBIytrEgUy7onOTJsjrDNYmiLbAJM+7 -vVvrdX3pCI6GMyx5dwlppYn8s3CQh3aP0yK7Qs69cwsgJirQmz1wHiRszYd2qReW -t88NkvuOGKmYSdGe/mBEciG5Ge3C9THxOUiIkCR1VBatzvT4aRRkOfujuLpwQMcn -HL/EVlP6Y2XQ8xwOFvVrhlhNGNTkDY6lnVuR3HYkUD/GKvvZt5y11ubQ2egZixVx -SK236thZiNSQvxaz2emsWWFUyBy6ysHK4bkgTI86k4mloMy/0/Z1pHWWbVY= ------END CERTIFICATE----- -# "thawte Primary Root CA" -# 8D 72 2F 81 A9 C1 13 C0 79 1D F1 36 A2 96 6D B2 -# 6C 95 0A 97 1D B4 6B 41 99 F4 EA 54 B7 8B FB 9F ------BEGIN CERTIFICATE----- -MIIEIDCCAwigAwIBAgIQNE7VVyDV7exJ9C/ON9srbTANBgkqhkiG9w0BAQUFADCB -qTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf -Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw -MDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxHzAdBgNV -BAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwHhcNMDYxMTE3MDAwMDAwWhcNMzYw -NzE2MjM1OTU5WjCBqTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5j -LjEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYG -A1UECxMvKGMpIDIwMDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNl -IG9ubHkxHzAdBgNVBAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwggEiMA0GCSqG -SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCsoPD7gFnUnMekz52hWXMJEEUMDSxuaPFs -W0hoSVk3/AszGcJ3f8wQLZU0HObrTQmnHNK4yZc2AreJ1CRfBsDMRJSUjQJib+ta -3RGNKJpchJAQeg29dGYvajig4tVUROsdB58Hum/u6f1OCyn1PoSgAfGcq/gcfomk -6KHYcWUNo1F77rzSImANuVud37r8UVsLr5iy6S7pBOhih94ryNdOwUxkHt3Ph1i6 -Sk/KaAcdHJ1KxtUvkcx8cXIcxcBn6zL9yZJclNqFwJu/U30rCfSMnZEfl2pSy94J -NqR32HuHUETVPm4pafs5SSYeCaWAe0At6+gnhcn+Yf1+5nyXHdWdAgMBAAGjQjBA -MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBR7W0XP -r87Lev0xkhpqtvNG61dIUDANBgkqhkiG9w0BAQUFAAOCAQEAeRHAS7ORtvzw6WfU -DW5FvlXok9LOAz/t2iWwHVfLHjp2oEzsUHboZHIMpKnxuIvW1oeEuzLlQRHAd9mz -YJ3rG9XRbkREqaYB7FViHXe4XI5ISXycO1cRrK1zN44veFyQaEfZYGDm/Ac9IiAX -xPcW6cTYcvnIc3zfFi8VqT79aie2oetaupgf1eNNZAqdE8hhuvU5HIe6uL17In/2 -/qxAeeWsEG89jxt5dovEN7MhGITlNgDrYyCZuen+MwS7QcjBAvlEYyCegc5C09Y/ -LHbTY5xZ3Y+m4Q6gLkH3LpVHz7z9M/P2C2F+fpErgUfCJzDupxBdN49cOSvkBPB7 -jVaMaA== ------END CERTIFICATE----- -# "thawte Primary Root CA - G3" -# 4B 03 F4 58 07 AD 70 F2 1B FC 2C AE 71 C9 FD E4 -# 60 4C 06 4C F5 FF B6 86 BA E5 DB AA D7 FD D3 4C ------BEGIN CERTIFICATE----- -MIIEKjCCAxKgAwIBAgIQYAGXt0an6rS0mtZLL/eQ+zANBgkqhkiG9w0BAQsFADCB -rjELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf -Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw -MDggdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAiBgNV -BAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMzAeFw0wODA0MDIwMDAwMDBa -Fw0zNzEyMDEyMzU5NTlaMIGuMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhhd3Rl -LCBJbmMuMSgwJgYDVQQLEx9DZXJ0aWZpY2F0aW9uIFNlcnZpY2VzIERpdmlzaW9u -MTgwNgYDVQQLEy8oYykgMjAwOCB0aGF3dGUsIEluYy4gLSBGb3IgYXV0aG9yaXpl -ZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9vdCBDQSAtIEcz -MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsr8nLPvb2FvdeHsbnndm -gcs+vHyu86YnmjSjaDFxODNi5PNxZnmxqWWjpYvVj2AtP0LMqmsywCPLLEHd5N/8 -YZzic7IilRFDGF/Eth9XbAoFWCLINkw6fKXRz4aviKdEAhN0cXMKQlkC+BsUa0Lf -b1+6a4KinVvnSr0eAXLbS3ToO39/fR8EtCab4LRarEc9VbjXsCZSKAExQGbY2SS9 -9irY7CFJXJv2eul/VTV+lmuNk5Mny5K76qxAwJ/C+IDPXfRa3M50hqY+bAtTyr2S -zhkGcuYMXDhpxwTWvGzOW/b3aJzcJRVIiKHpqfiYnODz1TEoYRFsZ5aNOZnLwkUk -OQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNV -HQ4EFgQUrWyqlGCc7eT/+j4KdCtjA/e2Wb8wDQYJKoZIhvcNAQELBQADggEBABpA -2JVlrAmSicY59BDlqQ5mU1143vokkbvnRFHfxhY0Cu9qRFHqKweKA3rD6z8KLFIW -oCtDuSWQP3CpMyVtRRooOyfPqsMpQhvfO0zAMzRbQYi/aytlryjvsvXDqmbOe1bu -t8jLZ8HJnBoYuMTDSQPxYA5QzUbF83d597YV4Djbxy8ooAw/dyZ02SUS2jHaGh7c -KUGRIjxpp7sC8rZcJwOJ9Abqm+RyguOhCcHpABnTPtRwa7pxpqpYrvS76Wy274fM -m7v/OeZWYdMKp8RcTGB7BXcmer/YB1IsYvdwY9k5vG8cwnncdimvzsUsZAReiDZu -MdRAGmI0Nj81Aa6sY6A= ------END CERTIFICATE----- -# "TRUST2408 OCES Primary CA" -# 92 D8 09 2E E7 7B C9 20 8F 08 97 DC 05 27 18 94 -# E6 3E F2 79 33 AE 53 7F B9 83 EE F0 EA E3 EE C8 ------BEGIN CERTIFICATE----- -MIIGHDCCBASgAwIBAgIES45gAzANBgkqhkiG9w0BAQsFADBFMQswCQYDVQQGEwJE -SzESMBAGA1UEChMJVFJVU1QyNDA4MSIwIAYDVQQDExlUUlVTVDI0MDggT0NFUyBQ -cmltYXJ5IENBMB4XDTEwMDMwMzEyNDEzNFoXDTM3MTIwMzEzMTEzNFowRTELMAkG -A1UEBhMCREsxEjAQBgNVBAoTCVRSVVNUMjQwODEiMCAGA1UEAxMZVFJVU1QyNDA4 -IE9DRVMgUHJpbWFyeSBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB -AJlJodr3U1Fa+v8HnyACHV81/wLevLS0KUk58VIABl6Wfs3LLNoj5soVAZv4LBi5 -gs7E8CZ9w0F2CopW8vzM8i5HLKE4eedPdnaFqHiBZ0q5aaaQArW+qKJx1rT/AaXt -alMB63/yvJcYlXS2lpexk5H/zDBUXeEQyvfmK+slAySWT6wKxIPDwVapauFY9QaG -+VBhCa5jBstWS7A5gQfEvYqn6csZ3jW472kW6OFNz6ftBcTwufomGJBMkonf4ZLr -6t0AdRi9jflBPz3MNNRGxyjIuAmFqGocYFA/OODBRjvSHB2DygqQ8k+9tlpvzMRr -kU7jq3RKL+83G1dJ3/LTjCLz4ryEMIC/OJ/gNZfE0qXddpPtzflIPtUFVffXdbFV -1t6XZFhJ+wBHQCpJobq/BjqLWUA86upsDbfwnePtmIPRCemeXkY0qabC+2Qmd2Fe -xyZphwTyMnbqy6FG1tB65dYf3mOqStmLa3RcHn9+2dwNfUkh0tjO2FXD7drWcU0O -I9DW8oAypiPhm/QCjMU6j6t+0pzqJ/S0tdAo+BeiXK5hwk6aR+sRb608QfBbRAs3 -U/q8jSPByenggac2BtTN6cl+AA1Mfcgl8iXWNFVGegzd/VS9vINClJCe3FNVoUnR -YCKkj+x0fqxvBLopOkJkmuZw/yhgMxljUi2qYYGn90OzAgMBAAGjggESMIIBDjAP -BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjARBgNVHSAECjAIMAYGBFUd -IAAwgZcGA1UdHwSBjzCBjDAsoCqgKIYmaHR0cDovL2NybC5vY2VzLnRydXN0MjQw -OC5jb20vb2Nlcy5jcmwwXKBaoFikVjBUMQswCQYDVQQGEwJESzESMBAGA1UEChMJ -VFJVU1QyNDA4MSIwIAYDVQQDExlUUlVTVDI0MDggT0NFUyBQcmltYXJ5IENBMQ0w -CwYDVQQDEwRDUkwxMB8GA1UdIwQYMBaAFPZt+LFIs0FDAduGROUYBbdezAY3MB0G -A1UdDgQWBBT2bfixSLNBQwHbhkTlGAW3XswGNzANBgkqhkiG9w0BAQsFAAOCAgEA -VPAQGrT7dIjD3/sIbQW86f9CBPu0c7JKN6oUoRUtKqgJ2KCdcB5ANhCoyznHpu3m -/dUfVUI5hc31CaPgZyY37hch1q4/c9INcELGZVE/FWfehkH+acpdNr7j8UoRZlkN -15b/0UUBfGeiiJG/ugo4llfoPrp8bUmXEGggK3wyqIPcJatPtHwlb6ympfC2b/Ld -v/0IdIOzIOm+A89Q0utx+1cOBq72OHy8gpGb6MfncVFMoL2fjP652Ypgtr8qN9Ka -/XOazktiIf+2Pzp7hLi92hRc9QMYexrV/nnFSQoWdU8TqULFUoZ3zTEC3F/g2yj+ -FhbrgXHGo5/A4O74X+lpbY2XV47aSuw+DzcPt/EhMj2of7SA55WSgbjPMbmNX0rb -oenSIte2HRFW5Tr2W+qqkc/StixgkKdyzGLoFx/xeTWdJkZKwyjqge2wJqws2upY -EiThhC497+/mTiSuXd69eVUwKyqYp9SD2rTtNmF6TCghRM/dNsJOl+osxDVGcwvt -WIVFF/Onlu5fu1NHXdqNEfzldKDUvCfii3L2iATTZyHwU9CALE+2eIA+PIaLgnM1 -1oCfUnYBkQurTrihvzz9PryCVkLxiqRmBVvUz+D4N5G/wvvKDS6t6cPCS+hqM482 -cbBsn0R9fFLO4El62S9eH1tqOzO20OAOK65yJIsOpSE= ------END CERTIFICATE----- -# "TrustCor ECA-1" -# 5A 88 5D B1 9C 01 D9 12 C5 75 93 88 93 8C AF BB -# DF 03 1A B2 D4 8E 91 EE 15 58 9B 42 97 1D 03 9C ------BEGIN CERTIFICATE----- -MIIEIDCCAwigAwIBAgIJAISCLF8cYtBAMA0GCSqGSIb3DQEBCwUAMIGcMQswCQYD -VQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEgQ2l0eTEk -MCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYDVQQLDB5U -cnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxFzAVBgNVBAMMDlRydXN0Q29y -IEVDQS0xMB4XDTE2MDIwNDEyMzIzM1oXDTI5MTIzMTE3MjgwN1owgZwxCzAJBgNV -BAYTAlBBMQ8wDQYDVQQIDAZQYW5hbWExFDASBgNVBAcMC1BhbmFtYSBDaXR5MSQw -IgYDVQQKDBtUcnVzdENvciBTeXN0ZW1zIFMuIGRlIFIuTC4xJzAlBgNVBAsMHlRy -dXN0Q29yIENlcnRpZmljYXRlIEF1dGhvcml0eTEXMBUGA1UEAwwOVHJ1c3RDb3Ig -RUNBLTEwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDPj+ARtZ+odnbb -3w9U73NjKYKtR8aja+3+XzP4Q1HpGjORMRegdMTUpwHmspI+ap3tDvl0mEDTPwOA -BoJA6LHip1GnHYMma6ve+heRK9jGrB6xnhkB1Zem6g23xFUfJ3zSCNV2HykVh0A5 -3ThFEXXQmqc04L/NyFIduUd+Dbi7xgz2c1cWWn5DkR9VOsZtRASqnKmcp0yJF4Ou -owReUoCLHhIlERnXDH19MURB6tuvsBzvgdAsxZohmz3tQjtQJvLsznFhBmIhVE5/ -wZ0+fyCMgMsq2JdiyIMzkX2woloPV+g7zPIlstR8L+xNxqE6FXrntl019fZISjZF -ZtS6mFjBAgMBAAGjYzBhMB0GA1UdDgQWBBREnkj1zG1I1KBLf/5ZJC+Dl5mahjAf -BgNVHSMEGDAWgBREnkj1zG1I1KBLf/5ZJC+Dl5mahjAPBgNVHRMBAf8EBTADAQH/ -MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAQEABT41XBVwm8nHc2Fv -civUwo/yQ10CzsSUuZQRg2dd4mdsdXa/uwyqNsatR5Nj3B5+1t4u/ukZMjgDfxT2 -AHMsWbEhBuH7rBiVDKP/mZb3Kyeb1STMHd3BOuCYRLDE5D53sXOpZCz2HAF8P11F -hcCF5yWPldwX8zyfGm6wyuMdKulMY/okYWLW2n62HGz1Ah3UKt1VkOsqEUc8Ll50 -soIipX1TH0XsJ5F95yIW6MBoNtjG8U+ARDL54dHRHareqKucBK+tIA5kmE2la8BI -WJZpTdwHjFGTot+fDz2LYLSCjaoITmJF4PkL0uDgPFveXHEnJcLmA4GLEFPjx1Wi -tJ/X5g== ------END CERTIFICATE----- -# "TrustCor RootCert CA-1" -# D4 0E 9C 86 CD 8F E4 68 C1 77 69 59 F4 9E A7 74 -# FA 54 86 84 B6 C4 06 F3 90 92 61 F4 DC E2 57 5C ------BEGIN CERTIFICATE----- -MIIEMDCCAxigAwIBAgIJANqb7HHzA7AZMA0GCSqGSIb3DQEBCwUAMIGkMQswCQYD -VQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEgQ2l0eTEk -MCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYDVQQLDB5U -cnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxHzAdBgNVBAMMFlRydXN0Q29y -IFJvb3RDZXJ0IENBLTEwHhcNMTYwMjA0MTIzMjE2WhcNMjkxMjMxMTcyMzE2WjCB -pDELMAkGA1UEBhMCUEExDzANBgNVBAgMBlBhbmFtYTEUMBIGA1UEBwwLUGFuYW1h -IENpdHkxJDAiBgNVBAoMG1RydXN0Q29yIFN5c3RlbXMgUy4gZGUgUi5MLjEnMCUG -A1UECwweVHJ1c3RDb3IgQ2VydGlmaWNhdGUgQXV0aG9yaXR5MR8wHQYDVQQDDBZU -cnVzdENvciBSb290Q2VydCBDQS0xMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB -CgKCAQEAv463leLCJhJrMxnHQFgKq1mqjQCj/IDHUHuO1CAmujIS2CNUSSUQIpid -RtLByZ5OGy4sDjjzGiVoHKZaBeYei0i/mJZ0PmnK6bV4pQa81QBeCQryJ3pS/C3V -seq0iWEk8xoT26nPUu0MJLq5nux+AHT6k61sKZKuUbS701e/s/OojZz0JEsq1pme -9J7+wH5COucLlVPat2gOkEz7cD+PSiyU8ybdY2mplNgQTsVHCJCZGxdNuWxu72CV -EY4hgLW9oHPY0LJ3xEXqWib7ZnZ2+AYfYW0PVcWDtxBWcgYHpfOxGgMFZA6dWorW -hnAbJN7+KIor0Gqw/Hqi3LJ5DotlDwIDAQABo2MwYTAdBgNVHQ4EFgQU7mtJPHo/ -DeOxCbeKyKsZn3MzUOcwHwYDVR0jBBgwFoAU7mtJPHo/DeOxCbeKyKsZn3MzUOcw -DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD -ggEBACUY1JGPE+6PHh0RU9otRCkZoB5rMZ5NDp6tPVxBb5UrJKF5mDo4Nvu7Zp5I -/5CQ7z3UuJu0h3U/IJvOcs+hVcFNZKIZBqEHMwwLKeXx6quj7LUKdJDHfXLy11yf -ke+Ri7fc7Waiz45mO7yfOgLgJ90WmMCV1Aqk5IGadZQ1nJBfiDcGrVmVCrDRZ9MZ -yonnMlo2HD6CqFqTvsbQZJG2z9m2GM/bftJlo6bEjhcxwft+dtvTheNYsnd6djts -L1Ac59v2Z3kf9YKVmgenFK+P3CghZwnS1k1aHBkcjndcw5QkPTJrS37UeJSDvjdN -zl/HHk484IkzlQsPpTLWPFp5LBk= ------END CERTIFICATE----- -# "TrustCor RootCert CA-2" -# 07 53 E9 40 37 8C 1B D5 E3 83 6E 39 5D AE A5 CB -# 83 9E 50 46 F1 BD 0E AE 19 51 CF 10 FE C7 C9 65 ------BEGIN CERTIFICATE----- -MIIGLzCCBBegAwIBAgIIJaHfyjPLWQIwDQYJKoZIhvcNAQELBQAwgaQxCzAJBgNV -BAYTAlBBMQ8wDQYDVQQIDAZQYW5hbWExFDASBgNVBAcMC1BhbmFtYSBDaXR5MSQw -IgYDVQQKDBtUcnVzdENvciBTeXN0ZW1zIFMuIGRlIFIuTC4xJzAlBgNVBAsMHlRy -dXN0Q29yIENlcnRpZmljYXRlIEF1dGhvcml0eTEfMB0GA1UEAwwWVHJ1c3RDb3Ig -Um9vdENlcnQgQ0EtMjAeFw0xNjAyMDQxMjMyMjNaFw0zNDEyMzExNzI2MzlaMIGk -MQswCQYDVQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEg -Q2l0eTEkMCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYD -VQQLDB5UcnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxHzAdBgNVBAMMFlRy -dXN0Q29yIFJvb3RDZXJ0IENBLTIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK -AoICAQCnIG7CKqJiJJWQdsg4foDSq8GbZQWU9MEKENUCrO2fk8eHyLAnK0IMPQo+ -QVqedd2NyuCb7GgypGmSaIwLgQ5WoD4a3SwlFIIvl9NkRvRUqdw6VC0xK5mC8tkq -1+9xALgxpL56JAfDQiDyitSSBBtlVkxs1Pu2YVpHI7TYabS3OtB0PAx1oYxOdqHp -2yqlO/rOsP9+aij9JxzIsekp8VduZLTQwRVtDr4uDkbIXvRR/u8OYzo7cbrPb1nK -DOObXUm4TOJXsZiKQlecdu/vvdFoqNL0Cbt3Nb4lggjEFixEIFapRBF37120Hape -az6LMvYHL1cEksr1/p3C6eizjkxLAjHZ5DxIgif3GIJ2SDpxsROhOdUuxTTCHWKF -3wP+TfSvPd9cW436cOGlfifHhi5qjxLGhF5DUVCcGZt45vz27Ud+ez1m7xMTiF88 -oWP7+ayHNZ/zgp6kPwqcMWmLmaSISo5uZk3vFsQPeSghYA2FFn3XVDjxklb9tTNM -g9zXEJ9L/cb4Qr26fHMC4P99zVvh1Kxhe1fVSntb1IVYJ12/+CtgrKAmrhQhJ8Z3 -mjOAPF5GP/fDsaOGM8boXg25NSyqRsGFAnWAoOsk+xWq5Gd/bnc/9ASKL3x74xdh -8N0JqSDIvgmk0H5Ew7IwSjiqqewYmgeCK9u4nBit2uBGF6zPXQIDAQABo2MwYTAd -BgNVHQ4EFgQU2f4hQG6UnrybPZx9mCAZ5YwwYrIwHwYDVR0jBBgwFoAU2f4hQG6U -nrybPZx9mCAZ5YwwYrIwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYw -DQYJKoZIhvcNAQELBQADggIBAJ5Fngw7tu/hOsh80QA9z+LqBrWyOrsGS2h60COX -dKcs8AjYeVrXWoSK2BKaG9l9XE1wxaX5q+WjiYndAfrs3fnpkpfbsEZC89NiqpX+ -MWcUaViQCqoL7jcjx1BRtPV+nuN79+TMQjItSQzL/0kMmx40/W5ulop5A7Zv2wnL -/V9lFDfhOPXzYRZY5LVtDQsEGz9QLX+zx3oaFoBg+Iof6Rsqxvm6ARppv9JYx1RX -CI/hOWB3S6xZhBqI8d3LT3jX5+EzLfzuQfogsL7L9ziUwOHQhQ+77Sxzq+3+knYa -ZH9bDTMJBzN7Bj8RpFxwPIXAz+OQqIN3+tvmxYxoZxBnpVIt8MSZj3+/0WvitUfW -2dCFmU2Umw9Lje4AWkcdEQOsQRivh7dvDDqPys/cA8GiCcjl/YBeyGBCARsaU1q7 -N6a3vLqE6R5sGtRk2tRD/pOLS/IseRYQ1JMLiI+h2IYURpFHmygk71dSTlxCnKr3 -Sewn6EAes6aJInKc9Q0ztFijMDvd1GpUk74aTfOTlPf8hAs/hCBcNANExdqtvArB -As8e5ZTZ845b2EzwnexhF7sUMlQMAimTHpKG9n/v55IFDlndmQguLvqcAFLTxWYp -5KeXRKQOKIETNcX2b2TmQcTVL8w0RSXPQQCWPUouwpaYT05KnJe32x+SMsj/D1Fu -1uwJ ------END CERTIFICATE----- -# "Trustis FPS Root CA" -# C1 B4 82 99 AB A5 20 8F E9 63 0A CE 55 CA 68 A0 -# 3E DA 5A 51 9C 88 02 A0 D3 A6 73 BE 8F 8E 55 7D ------BEGIN CERTIFICATE----- -MIIDZzCCAk+gAwIBAgIQGx+ttiD5JNM2a/fH8YygWTANBgkqhkiG9w0BAQUFADBF -MQswCQYDVQQGEwJHQjEYMBYGA1UEChMPVHJ1c3RpcyBMaW1pdGVkMRwwGgYDVQQL -ExNUcnVzdGlzIEZQUyBSb290IENBMB4XDTAzMTIyMzEyMTQwNloXDTI0MDEyMTEx -MzY1NFowRTELMAkGA1UEBhMCR0IxGDAWBgNVBAoTD1RydXN0aXMgTGltaXRlZDEc -MBoGA1UECxMTVHJ1c3RpcyBGUFMgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQAD -ggEPADCCAQoCggEBAMVQe547NdDfxIzNjpvto8A2mfRC6qc+gIMPpqdZh8mQRUN+ -AOqGeSoDvT03mYlmt+WKVoaTnGhLaASMk5MCPjDSNzoiYYkchU59j9WvezX2fihH -iTHcDnlkH5nSW7r+f2C/revnPDgpai/lkQtV/+xvWNUtyd5MZnGPDNcE2gfmHhjj -vSkCqPoc4Vu5g6hBSLwacY3nYuUtsuvffM/bq1rKMfFMIvMFE/eC+XN5DL7XSxzA -0RU8k0Fk0ea+IxciAIleH2ulrG6nS4zto3Lmr2NNL4XSFDWaLk6M6jKYKIahkQlB -OrTh4/L68MkKokHdqeMDx4gVOxzUGpTXn2RZEm0CAwEAAaNTMFEwDwYDVR0TAQH/ -BAUwAwEB/zAfBgNVHSMEGDAWgBS6+nEleYtXQSUhhgtx67JkDoshZzAdBgNVHQ4E -FgQUuvpxJXmLV0ElIYYLceuyZA6LIWcwDQYJKoZIhvcNAQEFBQADggEBAH5Y//01 -GX2cGE+esCu8jowU/yyg2kdbw++BLa8F6nRIW/M+TgfHbcWzk88iNVy2P3UnXwmW -zaD+vkAMXBJV+JOCyinpXj9WV4s4NvdFGkwozZ5BuO1WTISkQMi4sKUraXAEasP4 -1BIy+Q7DsdwyhEQsb8tGD+pmQQ9P8Vilpg0ND2HepZ5dfWWhPBfnqFVO76DH7cZE -f1T1o+CP8HxVIo8ptoGj4W1OLBuAZ+ytIJ8MYmHVl/9D7S3B2l0pKoU/rGXuhg8F -jZBf3+6f9L/uHfuY5H+QK4R4EA5sSVPvFVtlRkpdr7r7OnIdzfYliB6XzCGcKQEN -ZetX2fNXlrtIzYE= ------END CERTIFICATE----- -# "TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1" -# 46 ED C3 68 90 46 D5 3A 45 3F B3 10 4A B8 0D CA -# EC 65 8B 26 60 EA 16 29 DD 7E 86 79 90 64 87 16 ------BEGIN CERTIFICATE----- -MIIEYzCCA0ugAwIBAgIBATANBgkqhkiG9w0BAQsFADCB0jELMAkGA1UEBhMCVFIx -GDAWBgNVBAcTD0dlYnplIC0gS29jYWVsaTFCMEAGA1UEChM5VHVya2l5ZSBCaWxp -bXNlbCB2ZSBUZWtub2xvamlrIEFyYXN0aXJtYSBLdXJ1bXUgLSBUVUJJVEFLMS0w -KwYDVQQLEyRLYW11IFNlcnRpZmlrYXN5b24gTWVya2V6aSAtIEthbXUgU00xNjA0 -BgNVBAMTLVRVQklUQUsgS2FtdSBTTSBTU0wgS29rIFNlcnRpZmlrYXNpIC0gU3Vy -dW0gMTAeFw0xMzExMjUwODI1NTVaFw00MzEwMjUwODI1NTVaMIHSMQswCQYDVQQG -EwJUUjEYMBYGA1UEBxMPR2ViemUgLSBLb2NhZWxpMUIwQAYDVQQKEzlUdXJraXll -IEJpbGltc2VsIHZlIFRla25vbG9qaWsgQXJhc3Rpcm1hIEt1cnVtdSAtIFRVQklU -QUsxLTArBgNVBAsTJEthbXUgU2VydGlmaWthc3lvbiBNZXJrZXppIC0gS2FtdSBT -TTE2MDQGA1UEAxMtVFVCSVRBSyBLYW11IFNNIFNTTCBLb2sgU2VydGlmaWthc2kg -LSBTdXJ1bSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAr3UwM6q7 -a9OZLBI3hNmNe5eA027n/5tQlT6QlVZC1xl8JoSNkvoBHToP4mQ4t4y86Ij5iySr -LqP1N+RAjhgleYN1Hzv/bKjFxlb4tO2KRKOrbEz8HdDc72i9z+SqzvBV96I01INr -N3wcwv61A+xXzry0tcXtAA9TNypN9E8Mg/uGz8v+jE69h/mniyFXnHrfA2eJLJ2X -YacQuFWQfw4tJzh03+f92k4S400VIgLI4OD8D62K18lUUMw7D8oWgITQUVbDjlZ/ -iSIzL+aFCr2lqBs23tPcLG07xxO9WSMs5uWk99gL7eqQQESolbuT1dCANLZGeA4f -AJNG4e7p+exPFwIDAQABo0IwQDAdBgNVHQ4EFgQUZT/HiobGPN08VFw1+DrtUgxH -V8gwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL -BQADggEBACo/4fEyjq7hmFxLXs9rHmoJ0iKpEsdeV31zVmSAhHqT5Am5EM2fKifh -AHe+SMg1qIGf5LgsyX8OsNJLN13qudULXjS99HMpw+0mFZx+CFOKWI3QSyjfwbPf -IPP54+M638yclNhOT8NrF7f3cuitZjO1JVOr4PhMqZ398g26rrnZqsZr+ZO7rqu4 -lzwDGrpDxpa5RXI4s6ehlj2Re37AIVNMh+3yC1SVUZPVIqUNivGTDj5UDrDYyU7c -8jEyVupk+eq1nRZmQnLzf9OxMUP8pI4X8W0jq5Rm+K37DwhuJi1/FwcJsoz7UMCf -lo3Ptv0AnVoUmr8CRPXBwp8iXqIPoeM= ------END CERTIFICATE----- -# "TWCA Global Root CA" -# 59 76 90 07 F7 68 5D 0F CD 50 87 2F 9F 95 D5 75 -# 5A 5B 2B 45 7D 81 F3 69 2B 61 0A 98 67 2F 0E 1B ------BEGIN CERTIFICATE----- -MIIFQTCCAymgAwIBAgICDL4wDQYJKoZIhvcNAQELBQAwUTELMAkGA1UEBhMCVFcx -EjAQBgNVBAoTCVRBSVdBTi1DQTEQMA4GA1UECxMHUm9vdCBDQTEcMBoGA1UEAxMT -VFdDQSBHbG9iYWwgUm9vdCBDQTAeFw0xMjA2MjcwNjI4MzNaFw0zMDEyMzExNTU5 -NTlaMFExCzAJBgNVBAYTAlRXMRIwEAYDVQQKEwlUQUlXQU4tQ0ExEDAOBgNVBAsT -B1Jvb3QgQ0ExHDAaBgNVBAMTE1RXQ0EgR2xvYmFsIFJvb3QgQ0EwggIiMA0GCSqG -SIb3DQEBAQUAA4ICDwAwggIKAoICAQCwBdvI64zEbooh745NnHEKH1Jw7W2CnJfF -10xORUnLQEK1EjRsGcJ0pDFfhQKX7EMzClPSnIyOt7h52yvVavKOZsTuKwEHktSz -0ALfUPZVr2YOy+BHYC8rMjk1Ujoog/h7FsYYuGLWRyWRzvAZEk2tY/XTP3VfKfCh -MBwqoJimFb3u/Rk28OKRQ4/6ytYQJ0lM793B8YVwm8rqqFpD/G2Gb3PpN0Wp8DbH -zIh1HrtsBv+baz4X7GGqcXzGHaL3SekVtTzWoWH1EfcFbx39Eb7QMAfCKbAJTibc -46KokWofwpFFiFzlmLhxpRUZyXx1EcxwdE8tmx2RRP1WKKD+u4ZqyPpcC1jcxkt2 -yKsi2XMPpfRaAok/T54igu6idFMqPVMnaR1sjjIsZAAmY2E2TqNGtz99sy2sbZCi -laLOz9qC5wc0GZbpuCGqKX6mOL6OKUohZnkfs8O1CWfe1tQHRvMq2uYiN2DLgbYP -oA/pyJV/v1WRBXrPPRXAb94JlAGD1zQbzECl8LibZ9WYkTunhHiVJqRaCPgrdLQA -BDzfuBSO6N+pjWxnkjMdwLfS7JLIvgm/LCkFbwJrnu+8vyq8W8BQj0FwcYeyTbcE -qYSjMq+u7msXi7Kx/mzhkIyIqJdIzshNy/MGz19qCkKxHh53L46g5pIOBvwFItIm -4TFRfTLcDwIDAQABoyMwITAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB -/zANBgkqhkiG9w0BAQsFAAOCAgEAXzSBdu+WHdXltdkCY4QWwa6gcFGn90xHNcgL -1yg9iXHZqjNB6hQbbCEAwGxCGX6faVsgQt+i0trEfJdLjbDorMjupWkEmQqSpqsn -LhpNgb+E1HAerUf+/UqdM+DyucRFCCEK2mlpc3INvjT+lIutwx4116KD7+U4x6WF -H6vPNOw/KP4M8VeGTslV9xzU2KV9Bnpv1d8Q34FOIWWxtuEXeZVFBs5fzNxGiWNo -RI2T9GRwoD2dKAXDOXC4Ynsg/eTb6QihuJ49CcdP+yz4k3ZB3lLg4VfSnQO8d57+ -nile98FRYB/e2guyLXW3Q0iT5/Z5xoRdgFlglPx4mI88k1HtQJAH32RjJMtOcQWh -15QaiDLxInQirqWm2BJpTGCjAu4r7NRjkgtevi92a6O2JryPA9gK8kxkRr05YuWW -6zRjESjMlfGt7+/cgFhI6Uu46mWs6fyAtbXIRfmswZ/ZuepiiI7E8UuDEq3mi4TW -nsLrgxifarsbJGAzcMzs9zLzXNl5fe+epP7JI8Mk7hWSsT2RTyaGvWZzJBPqpK5j -wa19hAM8EHiGG3njxPPyBJUgriOCxLM6AGK/5jYk4Ve6xx6QddVfP5VhK8E7zeWz -aGHQRiapIVJpLesux+t3zqY6tQMzT3bR51xUAV3LePTJDL/PEo4XLSNolOer/qmy -KwbQBM0= ------END CERTIFICATE----- -# "TWCA Root Certification Authority" -# BF D8 8F E1 10 1C 41 AE 3E 80 1B F8 BE 56 35 0E -# E9 BA D1 A6 B9 BD 51 5E DC 5C 6D 5B 87 11 AC 44 ------BEGIN CERTIFICATE----- -MIIDezCCAmOgAwIBAgIBATANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJUVzES -MBAGA1UECgwJVEFJV0FOLUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFU -V0NBIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwODI4MDcyNDMz -WhcNMzAxMjMxMTU1OTU5WjBfMQswCQYDVQQGEwJUVzESMBAGA1UECgwJVEFJV0FO -LUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFUV0NBIFJvb3QgQ2VydGlm -aWNhdGlvbiBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB -AQCwfnK4pAOU5qfeCTiRShFAh6d8WWQUe7UREN3+v9XAu1bihSX0NXIP+FPQQeFE -AcK0HMMxQhZHhTMidrIKbw/lJVBPhYa+v5guEGcevhEFhgWQxFnQfHgQsIBct+HH -K3XLfJ+utdGdIzdjp9xCoi2SBBtQwXu4PhvJVgSLL1KbralW6cH/ralYhzC2gfeX -RfwZVzsrb+RH9JlF/h3x+JejiB03HFyP4HYlmlD4oFT/RJB2I9IyxsOrBr/8+7/z -rX2SYgJbKdM1o5OaQ2RgXbL6Mv87BK9NQGr5x+PvI/1ry+UPizgN7gr8/g+YnzAx -3WxSZfmLgb4i4RxYA7qRG4kHAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV -HRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqOFsmjd6LWvJPelSDGRjjCDWmujANBgkq -hkiG9w0BAQUFAAOCAQEAPNV3PdrfibqHDAhUaiBQkr6wQT25JmSDCi/oQMCXKCeC -MErJk/9q56YAf4lCmtYR5VPOL8zy2gXE/uJQxDqGfczafhAJO5I1KlOy/usrBdls -XebQ79NqZp4VKIV66IIArB6nCWlWQtNoURi+VJq/REG6Sb4gumlc7rh3zc5sH62D -lhh9DrUUOYTxKOkto557HnpyWoOzeW/vtPzQCqVYT0bf+215WfKEIlKuD8z7fDvn -aspHYcN6+NOSBB+4IIThNlQWx0DeO4pz3N/GCUzf7Nr/1FNCocnyYh0igzyXxfkZ -YiesZSLX0zzG5Y6yU8xJzrww/nsOM5D77dIUkR8Hrw== ------END CERTIFICATE----- -# "UCA Global Root" -# A1 F0 5C CB 80 C2 D7 10 EC 7D 47 9A BD CB B8 79 -# E5 8D 7E DB 71 49 FE 78 A8 78 84 E3 D0 BA D0 F9 ------BEGIN CERTIFICATE----- -MIIFkjCCA3qgAwIBAgIBCDANBgkqhkiG9w0BAQUFADA6MQswCQYDVQQGEwJDTjER -MA8GA1UEChMIVW5pVHJ1c3QxGDAWBgNVBAMTD1VDQSBHbG9iYWwgUm9vdDAeFw0w -ODAxMDEwMDAwMDBaFw0zNzEyMzEwMDAwMDBaMDoxCzAJBgNVBAYTAkNOMREwDwYD -VQQKEwhVbmlUcnVzdDEYMBYGA1UEAxMPVUNBIEdsb2JhbCBSb290MIICIjANBgkq -hkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA2rPlBlA/9nP3xDK/RqUlYjOHsGj+p9+I -A2N9Apb964fJ7uIIu527u+RBj8cwiQ9tJMAEbBSUgU2gDXRm8/CFr/hkGd656YGT -0CiFmUdCSiw8OCdKzP/5bBnXtfPvm65bNAbXj6ITBpyKhELVs6OQaG2BkO5NhOxM -cE4t3iQ5zhkAQ5N4+QiGHUPR9HK8BcBn+sBR0smFBySuOR56zUHSNqth6iur8CBV -mTxtLRwuLnWW2HKX4AzKaXPudSsVCeCObbvaE/9GqOgADKwHLx25urnRoPeZnnRc -GQVmMc8+KlL+b5/zub35wYH1N9ouTIElXfbZlJrTNYsgKDdfUet9Ysepk9H50DTL -qScmLCiQkjtVY7cXDlRzq6987DqrcDOsIfsiJrOGrCOp139tywgg8q9A9f9ER3Hd -J90TKKHqdjn5EKCgTUCkJ7JZFStsLSS3JGN490MYeg9NEePorIdCjedYcaSrbqLA -l3y74xNLytu7awj5abQEctXDRrl36v+6++nwOgw19o8PrgaEFt2UVdTvyie3AzzF -HCYq9TyopZWbhvGKiWf4xwxmse1Bv4KmAGg6IjTuHuvlb4l0T2qqaqhXZ1LUIGHB -zlPL/SR/XybfoQhplqCe/klD4tPq2sTxiDEhbhzhzfN1DiBEFsx9c3Q1RSw7gdQg -7LYJjD5IskkCAwEAAaOBojCBnzALBgNVHQ8EBAMCAQYwDAYDVR0TBAUwAwEB/zBj -BgNVHSUEXDBaBggrBgEFBQcDAQYIKwYBBQUHAwIGCCsGAQUFBwMDBggrBgEFBQcD -BAYIKwYBBQUHAwUGCCsGAQUFBwMGBggrBgEFBQcDBwYIKwYBBQUHAwgGCCsGAQUF -BwMJMB0GA1UdDgQWBBTZw9P4gJJnzF3SOqLXcaK0xDiALTANBgkqhkiG9w0BAQUF -AAOCAgEA0Ih5ygiq9ws0oE4Jwul+NUiJcIQjL1HDKy9e21NrW3UIKlS6Mg7VxnGF -sZdJgPaE0PC6t3GUyHlrpsVE6EKirSUtVy/m1jEp+hmJVCl+t35HNmktbjK81HXa -QnO4TuWDQHOyXd/URHOmYgvbqm4FjMh/Rk85hZCdvBtUKayl1/7lWFZXbSyZoUkh -1WHGjGHhdSTBAd0tGzbDLxLMC9Z4i3WA6UG5iLHKPKkWxk4V43I29tSgQYWvimVw -TbVEEFDs7d9t5tnGwBLxSzovc+k8qe4bqi81pZufTcU0hF8mFGmzI7GJchT46U1R -IgP/SobEHOh7eQrbRyWBfvw0hKxZuFhD5D1DCVR0wtD92e9uWfdyYJl2b/Unp7uD -pEqB7CmB9HdL4UISVdSGKhK28FWbAS7d9qjjGcPORy/AeGEYWsdl/J1GW1fcfA67 -loMQfFUYCQSu0feLKj6g5lDWMDbX54s4U+xJRODPpN/xU3uLWrb2EZBL1nXz/gLz -Ka/wI3J9FO2pXd96gZ6bkiL8HvgBRUGXx2sBYb4zaPKgZYRmvOAqpGjTcezHCN6j -w8k2SjTxF+KAryAhk5Qe5hXTVGLxtTgv48y5ZwSpuuXu+RBuyy5+E6+SFP7zJ3N7 -OPxzbbm5iPZujAv1/P8JDrMtXnt145Ik4ubhWD5LKAN1axibRww= ------END CERTIFICATE----- -# "UCA Root" -# 93 E6 5E C7 62 F0 55 DC 71 8A 33 25 82 C4 1A 04 -# 43 0D 72 E3 CB 87 E8 B8 97 B6 75 16 F0 D1 AA 39 ------BEGIN CERTIFICATE----- -MIIDhDCCAmygAwIBAgIBCTANBgkqhkiG9w0BAQUFADAzMQswCQYDVQQGEwJDTjER -MA8GA1UEChMIVW5pVHJ1c3QxETAPBgNVBAMTCFVDQSBSb290MB4XDTA0MDEwMTAw -MDAwMFoXDTI5MTIzMTAwMDAwMFowMzELMAkGA1UEBhMCQ04xETAPBgNVBAoTCFVu -aVRydXN0MREwDwYDVQQDEwhVQ0EgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEP -ADCCAQoCggEBALNdB8qGJn1r4vs4CQ7MgsJqGgCiFV/W6dQBt1YDAVmP9ThpJHbC -XivF9iu/r/tB/Q9a/KvXg3BNMJjRnrJ2u5LWu+kQKGkoNkTo8SzXWHwk1n8COvCB -a2FgP/Qz3m3l6ihST/ypHWN8C7rqrsRoRuTej8GnsrZYWm0dLNmMOreIy4XU9+gD -Xv2yTVDo1h//rgI/i0+WITyb1yXJHT/7mLFZ5PCpO6+zzYUs4mBGzG+OoOvwNMXx -QhhgrhLtRnUc5dipllq+3lrWeGeWW5N3UPJuG96WUUqm1ktDdSFmjXfsAoR2XEQQ -th1hbOSjIH23jboPkXXHjd+8AmCoKai9PUMCAwEAAaOBojCBnzALBgNVHQ8EBAMC -AQYwDAYDVR0TBAUwAwEB/zBjBgNVHSUEXDBaBggrBgEFBQcDAQYIKwYBBQUHAwIG -CCsGAQUFBwMDBggrBgEFBQcDBAYIKwYBBQUHAwUGCCsGAQUFBwMGBggrBgEFBQcD -BwYIKwYBBQUHAwgGCCsGAQUFBwMJMB0GA1UdDgQWBBTbHzXza0z/QjFkm827Wh4d -SBC37jANBgkqhkiG9w0BAQUFAAOCAQEAOGy3iPGt+lg3dNHocN6cJ1nL5BXXoMNg -14iABMUwTD3UGusGXllH5rxmy+AI/Og17GJ9ysDawXiv5UZv+4mCI4/211NmVaDe -JRI7cTYWVRJ2+z34VFsxugAG+H1V5ad2g6pcSpemKijfvcZsCyOVjjN/Hl5AHxNU -LJzltQ7dFyiuawHTUin1Ih+QOfTcYmjwPIZH7LgFRbu3DJaUxmfLI3HQjnQi1kHr -A6i26r7EARK1s11AdgYg1GS4KUYGis4fk5oQ7vuqWrTcL9Ury/bXBYSYBZELhPc9 -+tb5evosFeo2gkO3t7jj83EB7UNDogVFwygFBzXjAaU4HoDU18PZ3g== ------END CERTIFICATE----- -# "USERTrust ECC Certification Authority" -# 4F F4 60 D5 4B 9C 86 DA BF BC FC 57 12 E0 40 0D -# 2B ED 3F BC 4D 4F BD AA 86 E0 6A DC D2 A9 AD 7A ------BEGIN CERTIFICATE----- -MIICjzCCAhWgAwIBAgIQXIuZxVqUxdJxVt7NiYDMJjAKBggqhkjOPQQDAzCBiDEL -MAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNl -eSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMT -JVVTRVJUcnVzdCBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMjAx -MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgT -Ck5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVUaGUg -VVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBFQ0MgQ2VydGlm -aWNhdGlvbiBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQarFRaqflo -I+d61SRvU8Za2EurxtW20eZzca7dnNYMYf3boIkDuAUU7FfO7l0/4iGzzvfUinng -o4N+LZfQYcTxmdwlkWOrfzCjtHDix6EznPO/LlxTsV+zfTJ/ijTjeXmjQjBAMB0G -A1UdDgQWBBQ64QmG1M8ZwpZ2dEl23OA1xmNjmjAOBgNVHQ8BAf8EBAMCAQYwDwYD -VR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjA2Z6EWCNzklwBBHU6+4WMB -zzuqQhFkoJ2UOQIReVx7Hfpkue4WQrO/isIJxOzksU0CMQDpKmFHjFJKS04YcPbW -RNZu9YO6bVi9JNlWSOrvxKJGgYhqOkbRqZtNyWHa0V1Xahg= ------END CERTIFICATE----- -# "USERTrust RSA Certification Authority" -# E7 93 C9 B0 2F D8 AA 13 E2 1C 31 22 8A CC B0 81 -# 19 64 3B 74 9C 89 89 64 B1 74 6D 46 C3 D4 CB D2 ------BEGIN CERTIFICATE----- -MIIF3jCCA8agAwIBAgIQAf1tMPyjylGoG7xkDjUDLTANBgkqhkiG9w0BAQwFADCB -iDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0pl -cnNleSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNV -BAMTJVVTRVJUcnVzdCBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAw -MjAxMDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNV -BAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVU -aGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBSU0EgQ2Vy -dGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK -AoICAQCAEmUXNg7D2wiz0KxXDXbtzSfTTK1Qg2HiqiBNCS1kCdzOiZ/MPans9s/B -3PHTsdZ7NygRK0faOca8Ohm0X6a9fZ2jY0K2dvKpOyuR+OJv0OwWIJAJPuLodMkY -tJHUYmTbf6MG8YgYapAiPLz+E/CHFHv25B+O1ORRxhFnRghRy4YUVD+8M/5+bJz/ -Fp0YvVGONaanZshyZ9shZrHUm3gDwFA66Mzw3LyeTP6vBZY1H1dat//O+T23LLb2 -VN3I5xI6Ta5MirdcmrS3ID3KfyI0rn47aGYBROcBTkZTmzNg95S+UzeQc0PzMsNT -79uq/nROacdrjGCT3sTHDN/hMq7MkztReJVni+49Vv4M0GkPGw/zJSZrM233bkf6 -c0Plfg6lZrEpfDKEY1WJxA3Bk1QwGROs0303p+tdOmw1XNtB1xLaqUkL39iAigmT -Yo61Zs8liM2EuLE/pDkP2QKe6xJMlXzzawWpXhaDzLhn4ugTncxbgtNMs+1b/97l -c6wjOy0AvzVVdAlJ2ElYGn+SNuZRkg7zJn0cTRe8yexDJtC/QV9AqURE9JnnV4ee -UB9XVKg+/XRjL7FQZQnmWEIuQxpMtPAlR1n6BB6T1CZGSlCBst6+eLf8ZxXhyVeE -Hg9j1uliutZfVS7qXMYoCAQlObgOK6nyTJccBz8NUvXt7y+CDwIDAQABo0IwQDAd -BgNVHQ4EFgQUU3m/WqorSs9UgOHYm8Cd8rIDZsswDgYDVR0PAQH/BAQDAgEGMA8G -A1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAFzUfA3P9wF9QZllDHPF -Up/L+M+ZBn8b2kMVn54CVVeWFPFSPCeHlCjtHzoBN6J2/FNQwISbxmtOuowhT6KO -VWKR82kV2LyI48SqC/3vqOlLVSoGIG1VeCkZ7l8wXEskEVX/JJpuXior7gtNn3/3 -ATiUFJVDBwn7YKnuHKsSjKCaXqeYalltiz8I+8jRRa8YFWSQEg9zKC7F4iRO/Fjs -8PRF/iKz6y+O0tlFYQXBl2+odnKPi4w2r78NBc5xjeambx9spnFixdjQg3IM8WcR -iQycE0xyNN+81XHfqnHd4blsjDwSXWXavVcStkNr/+XeTWYRUc+ZruwXtuhxkYze -Sf7dNXGiFSeUHM9h4ya7b6NnJSFd5t0dCy5oGzuCr+yDZ4XUmFF0sbmZgIn/f3gZ -XHlKYC6SQK5MNyosycdiyA5d9zZbyuAlJQG03RoHnHcAP9Dc1ew91Pq7P8yF1m9/ -qS3fuQL39ZeatTXaw2ewh0qpKJ4jjv9cJ2vhsE/zB+4ALtRZh8tSQZXq9EfX7mRB -VXyNWQKV3WKdwrnuWih0hKWbt5DHDAff9Yk2dDLWKMGwsAvgnEzDHNb842m1R0aB -L6KCq9NjRHDEjf8tM7qtj3u1cIiuPhnPQCjY/MiQu12ZIvVS5ljFH4gxQ+6IHdfG -jjxDah2nGN59PRbxYvnKkKj9 ------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 ------BEGIN CERTIFICATE----- -MIIEGjCCAwICEQCLW3VWhFSFCwDPrzhIzrGkMA0GCSqGSIb3DQEBBQUAMIHKMQsw -CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl -cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu -LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT -aWduIENsYXNzIDEgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp -dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD -VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT -aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ -bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu -IENsYXNzIDEgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg -LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN2E1Lm0+afY8wR4 -nN493GwTFtl63SRRZsDHJlkNrAYIwpTRMx/wgzUfbhvI3qpuFU5UJ+/EbRrsC+MO -8ESlV8dAWB6jRx9x7GD2bZTIGDnt/kIYVt/kTEkQeE4BdjVjEjbdZrwBBDajVWjV -ojYJrKshJlQGrT/KFOCsyq0GHZXi+J3x4GD/wn91K0zM2v6HmSHquv4+VNfSWXjb -PG7PoBMAGrgnoeS+Z5bKoMWznN3JdZ7rMJpfo83ZrngZPyPpXNspva1VyBtUjGP2 -6KbqxzcSXKMpHgLZ2x87tNcPVkeBFQRKr4Mn0cVYiMHd9qqnoxjaaKptEVHhv2Vr -n5Z20T0CAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAq2aN17O6x5q25lXQBfGfMY1a -qtmqRiYPce2lrVNWYgFHKkTp/j90CxObufRNG7LRX7K20ohcs5/Ny9Sn2WCVhDr4 -wTcdYcrnsMXlkdpUpqwxga6X3s0IrLjAl4B/bnKk52kTlWUfxJM8/XmPBNQ+T+r3 -ns7NZ3xPZQL/kYVUc8f/NveGLezQXk//EZ9yBta4GvFMDSZl4kSAHsef493oCtrs -pSCAaWihT37ha88HQfqDjrw43bAuEbFrskLMmrz5SCJ5ShkPshw+IHTZasO+8ih4 -E1Z5T21Q6huwtVexN2ZYI/PcD98Kh8TvhgXVOBRgmaNL3gaWcSzy27YfpO8/7g== ------END CERTIFICATE----- -# "VeriSign Class 2 Public Primary Certification Authority - G3" -# 92 A9 D9 83 3F E1 94 4D B3 66 E8 BF AE 7A 95 B6 -# 48 0C 2D 6C 6C 2A 1B E6 5D 42 36 B6 08 FC A1 BB ------BEGIN CERTIFICATE----- -MIIEGTCCAwECEGFwy0mMX5hFKeewptlQW3owDQYJKoZIhvcNAQEFBQAwgcoxCzAJ -BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjEfMB0GA1UECxMWVmVy -aVNpZ24gVHJ1c3QgTmV0d29yazE6MDgGA1UECxMxKGMpIDE5OTkgVmVyaVNpZ24s -IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTFFMEMGA1UEAxM8VmVyaVNp -Z24gQ2xhc3MgMiBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0 -eSAtIEczMB4XDTk5MTAwMTAwMDAwMFoXDTM2MDcxNjIzNTk1OVowgcoxCzAJBgNV -BAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjEfMB0GA1UECxMWVmVyaVNp -Z24gVHJ1c3QgTmV0d29yazE6MDgGA1UECxMxKGMpIDE5OTkgVmVyaVNpZ24sIElu -Yy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTFFMEMGA1UEAxM8VmVyaVNpZ24g -Q2xhc3MgMiBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAt -IEczMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArwoNwtUs22e5LeWU -J92lvuCwTY+zYVY81nzD9M0+hsuiiOLh2KRpxbXiv8GmR1BeRjmL1Za6tW8UvxDO -JxOeBUebMXoT2B/Z0wI3i60sR/COgQanDTAM6/c8DyAd3HJG7qUCyFvDyVZpTMUY -wZF7C9UTAJu878NIPkZgIIUq1ZC2zYugzDLdt/1AVbJQHFauzI13TccgTacxdu9o -koqQHgiBVrKtaaNS0MscxCM9H5n+TOgWY47GCI72MfbS+uV23bUckqNJzc0BzWjN -qWm6o+sdDZykIKbBoMXRRkwXbdKsZj+WjOCE1Db/IlnF+RFgqF8EffIa9iVCYQ/E -Srg+iQIDAQABMA0GCSqGSIb3DQEBBQUAA4IBAQA0JhU8wI1NQ0kdvekhktdmnLfe -xbjQ5F1fdiLAJvmEOjr5jLX77GDx6M4EsMjdpwOPMPOY36TmpDHf0xwLRtxyID+u -7gU8pDM/CzmscHhzS5kr3zDCVLCoO1Wh/hYozUK9dG6A2ydEp85EXdQbkJgNHkKU -sQAsBNB0owIFImNjzYO1+8FtYmtpdf1dcEG59b98377BMnMiIYtYgXsVkXq642RI -sH/7NiXaldDxJBQX3RiAa0YjOVT1jmIJBB2UkKab5iXiQkWquJCtvgiPqQtCGJTP -cjnhsUPgKM+351psE2tJs//jGHyJizNdrDPXp/naOlXJWBD5qu9ats9LS98q ------END CERTIFICATE----- -# "VeriSign Class 3 Public Primary Certification Authority - G3" -# EB 04 CF 5E B1 F3 9A FA 76 2F 2B B1 20 F2 96 CB -# A5 20 C1 B9 7D B1 58 95 65 B8 1C B9 A1 7B 72 44 ------BEGIN CERTIFICATE----- -MIIEGjCCAwICEQCbfgZJoz5iudXukEhxKe9XMA0GCSqGSIb3DQEBBQUAMIHKMQsw -CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl -cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu -LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT -aWduIENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp -dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD -VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT -aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ -bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu -IENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg -LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMu6nFL8eB8aHm8b -N3O9+MlrlBIwT/A2R/XQkQr1F8ilYcEWQE37imGQ5XYgwREGfassbqb1EUGO+i2t -KmFZpGcmTNDovFJbcCAEWNF6yaRpvIMXZK0Fi7zQWM6NjPXr8EJJC52XJ2cybuGu -kxUccLwgTS8Y3pKI6GyFVxEa6X7jJhFUokWWVYPKMIno3Nij7SqAP395ZVc+FSBm -CC+Vk7+qRy+oRpfwEuL+wgorUeZ25rdGt+INpsyow0xZVYnm6FNcHOqd8GIWC6fJ -Xwzw3sJ2zq/3avL6QaaiMxTJ5Xpj055iN9WFZZ4O5lMkdBteHRJTW8cs54NJOxWu -imi5V5cCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAERSWwauSCPc/L8my/uRan2Te -2yFPhpk0djZX3dAVL8WtfxUfN2JzPtTnX84XA9s1+ivbrmAJXx5fj267Cz3qWhMe -DGBvtcC1IyIuBwvLqXTLR7sdwdela8wv0kL9Sd2nic9TutoAWii/gt/4uhMdUIaC -/Y4wjylGsB49Ndo4YhYYSq3mtlFs3q9i6wHQHiT+eo8SGhJouPtmmRQURVyu565p -F4ErWjfJXir0xuKhXFSbplQAz/DxwceYMBo7Nhbbo27q/a2ywtrvAkcTisDxszGt -TxzhT5yvDwyd93gN2PQ1VoDat20Xj50egWTh/sVFuq1ruQp6Tk9LhO5L8X3dEQ== ------END CERTIFICATE----- -# "VeriSign Class 3 Public Primary Certification Authority - G4" -# 69 DD D7 EA 90 BB 57 C9 3E 13 5D C8 5E A6 FC D5 -# 48 0B 60 32 39 BD C4 54 FC 75 8B 2A 26 CF 7F 79 ------BEGIN CERTIFICATE----- -MIIDhDCCAwqgAwIBAgIQL4D+I4wOIg9IZxIokYesszAKBggqhkjOPQQDAzCByjEL -MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW -ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2ln -biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp -U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y -aXR5IC0gRzQwHhcNMDcxMTA1MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCByjELMAkG -A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZWZXJp -U2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2lnbiwg -SW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJpU2ln -biBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5 -IC0gRzQwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASnVnp8Utpkmw4tXNherJI9/gHm -GUo9FANL+mAnINmDiWn6VMaaGF5VKmTeBvaNSjutEDxlPZCIBIngMGGzrl0Bp3ve -fLK+ymVhAIau2o970ImtTR1ZmkGxvEeA3J5iw/mjgbIwga8wDwYDVR0TAQH/BAUw -AwEB/zAOBgNVHQ8BAf8EBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJ -aW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYj -aHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFLMW -kf3upm7ktS5Jj4d4gYDs5bG1MAoGCCqGSM49BAMDA2gAMGUCMGYhDBgmYFo4e1ZC -4Kf8NoRRkSAsdk1DPcQdhCPQrNZ8NQbOzWm9kA3bbEhCHQ6qQgIxAJw9SDkjOVga -FRJZap7v1VmyHVIsmXHNxynfGyphe3HR3vPA5Q06Sqotp9iGKt0uEA== ------END CERTIFICATE----- -# "VeriSign Class 3 Public Primary Certification Authority - G5" -# 9A CF AB 7E 43 C8 D8 80 D0 6B 26 2A 94 DE EE E4 -# B4 65 99 89 C3 D0 CA F1 9B AF 64 05 E4 1A B7 DF ------BEGIN CERTIFICATE----- -MIIE0zCCA7ugAwIBAgIQGNrRniZ96LtKIVjNzGs7SjANBgkqhkiG9w0BAQUFADCB -yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL -ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp -U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW -ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0 -aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMzYwNzE2MjM1OTU5WjCByjEL -MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW -ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJpU2ln -biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp -U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y -aXR5IC0gRzUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvJAgIKXo1 -nmAMqudLO07cfLw8RRy7K+D+KQL5VwijZIUVJ/XxrcgxiV0i6CqqpkKzj/i5Vbex -t0uz/o9+B1fs70PbZmIVYc9gDaTY3vjgw2IIPVQT60nKWVSFJuUrjxuf6/WhkcIz -SdhDY2pSS9KP6HBRTdGJaXvHcPaz3BJ023tdS1bTlr8Vd6Gw9KIl8q8ckmcY5fQG -BO+QueQA5N06tRn/Arr0PO7gi+s3i+z016zy9vA9r911kTMZHRxAy3QkGSGT2RT+ -rCpSx4/VBEnkjWNHiDxpg8v+R70rfk/Fla4OndTRQ8Bnc+MUCH7lP59zuDMKz10/ -NIeWiu5T6CUVAgMBAAGjgbIwga8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8E -BAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJaW1hZ2UvZ2lmMCEwHzAH -BgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYjaHR0cDovL2xvZ28udmVy -aXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFH/TZafC3ey78DAJ80M5+gKv -MzEzMA0GCSqGSIb3DQEBBQUAA4IBAQCTJEowX2LP2BqYLz3q3JktvXf2pXkiOOzE -p6B4Eq1iDkVwZMXnl2YtmAl+X6/WzChl8gGqCBpH3vn5fJJaCGkgDdk+bW48DW7Y -5gaRQBi5+MHt39tBquCWIMnNZBU4gcmU7qKEKQsTb47bDN0lAtukixlE0kF6BWlK -WE9gyn6CagsCqiUXObXbf+eEZSqVir2G3l6BFoMtEMze/aiCKm0oHw0LxOXnGiYZ -4fQRbxC1lfznQgUy286dUV4otp6F01vvpX1FQHKOtw5rDgb7MzVIcbidJ4vEZV8N -hnacRHr2lVz2XTIIM6RUthg/aFzyQkqFOFSDX9HoLPKsEdao7WNq ------END CERTIFICATE----- -# "VeriSign Universal Root Certification Authority" -# 23 99 56 11 27 A5 71 25 DE 8C EF EA 61 0D DF 2F -# A0 78 B5 C8 06 7F 4E 82 82 90 BF B8 60 E8 4B 3C ------BEGIN CERTIFICATE----- -MIIEuTCCA6GgAwIBAgIQQBrEZCGzEyEDDrvkEhrFHTANBgkqhkiG9w0BAQsFADCB -vTELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL -ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwOCBWZXJp -U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MTgwNgYDVQQDEy9W -ZXJpU2lnbiBVbml2ZXJzYWwgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe -Fw0wODA0MDIwMDAwMDBaFw0zNzEyMDEyMzU5NTlaMIG9MQswCQYDVQQGEwJVUzEX -MBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlTaWduIFRydXN0 -IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA4IFZlcmlTaWduLCBJbmMuIC0gRm9y -IGF1dGhvcml6ZWQgdXNlIG9ubHkxODA2BgNVBAMTL1ZlcmlTaWduIFVuaXZlcnNh -bCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEF -AAOCAQ8AMIIBCgKCAQEAx2E3XrEBNNti1xWb/1hajCMj1mCOkdeQmIN65lgZOIzF -9uVkhbSicfvtvbnazU0AtMgtc6XHaXGVHzk8skQHnOgO+k1KxCHfKWGPMiJhgsWH -H26MfF8WIFFE0XBPV+rjHOPMee5Y2A7Cs0WTwCznmhcrewA3ekEzeOEz4vMQGn+H -LL729fdC4uW/h2KJXwBL38Xd5HVEMkE6HnFuacsLdUYI0crSK5XQz/u5QGtkjFdN -/BMReYTtXlT2NJ8IAfMQJQYXStrxHXpma5hgZqTZ79IugvHw7wnqRMkVauIDbjPT -rJ9VAMf2CGqUuV/c4DPxhGD5WycRtPwW8rtWaoAljQIDAQABo4GyMIGvMA8GA1Ud -EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMG0GCCsGAQUFBwEMBGEwX6FdoFsw -WTBXMFUWCWltYWdlL2dpZjAhMB8wBwYFKw4DAhoEFI/l0xqGrI2Oa8PPgGrUSBgs -exkuMCUWI2h0dHA6Ly9sb2dvLnZlcmlzaWduLmNvbS92c2xvZ28uZ2lmMB0GA1Ud -DgQWBBS2d/ppSEefUxLVwuoHMnYH0ZcHGTANBgkqhkiG9w0BAQsFAAOCAQEASvj4 -sAPmLGd75JR3Y8xuTPl9Dg3cyLk1uXBPY/ok+myDjEedO2Pzmvl2MpWRsXe8rJq+ -seQxIcaBlVZaDrHC1LGmWazxY8u4TB1ZkErvkBYoH1quEPuBUDgMbMzxPcP1Y+Oz -4yHJJDnp/RVmRvQbEdBNc6N9Rvk97ahfYtTxP/jgdFcrGJ2BtMQo2pSXpXDrrB2+ -BxHw1dvd5Yzw1TKwg+ZX4o+/vqGqvz0dtdQ46tewXDpPaj+PwGZsY6rp2aQW9IHR -lRQOfc2VNNnSj3BzgXucfr2YYdhFh5iQxeuGMMY1v/D/w1WIg0vvBZIGcfK4mJO3 -7M2CYfE45k+XmCpajQ== ------END CERTIFICATE----- -# "Visa eCommerce Root" -# 69 FA C9 BD 55 FB 0A C7 8D 53 BB EE 5C F1 D5 97 -# 98 9F D0 AA AB 20 A2 51 51 BD F1 73 3E E7 D1 22 ------BEGIN CERTIFICATE----- -MIIDojCCAoqgAwIBAgIQE4Y1TR0/BvLB+WUF1ZAcYjANBgkqhkiG9w0BAQUFADBr -MQswCQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRl -cm5hdGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNv -bW1lcmNlIFJvb3QwHhcNMDIwNjI2MDIxODM2WhcNMjIwNjI0MDAxNjEyWjBrMQsw -CQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRlcm5h -dGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNvbW1l -cmNlIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvV95WHm6h -2mCxlCfLF9sHP4CFT8icttD0b0/Pmdjh28JIXDqsOTPHH2qLJj0rNfVIsZHBAk4E -lpF7sDPwsRROEW+1QK8bRaVK7362rPKgH1g/EkZgPI2h4H3PVz4zHvtH8aoVlwdV -ZqW1LS7YgFmypw23RuwhY/81q6UCzyr0TP579ZRdhE2o8mCP2w4lPJ9zcc+U30rq -299yOIzzlr3xF7zSujtFWsan9sYXiwGd/BmoKoMWuDpI/k4+oKsGGelT84ATB+0t -vz8KPFUgOSwsAGl0lUq8ILKpeeUYiZGo3BxN77t+Nwtd/jmliFKMAGzsGHxBvfaL -dXe6YJ2E5/4tAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD -AgEGMB0GA1UdDgQWBBQVOIMPPyw/cDMezUb+B4wg4NfDtzANBgkqhkiG9w0BAQUF -AAOCAQEAX/FBfXxcCLkr4NWSR/pnXKUTwwMhmytMiUbPWU3J/qVAtmPN3XEolWcR -zCSs00Rsca4BIGsDoo8Ytyk6feUWYFN4PMCvFYP3j1IzJL1kk5fui/fbGKhtcbP3 -LBfQdCVp9/5rPJS+TUtBjE7ic9DjkCJzQ83z7+pzzkWKsKZJ/0x9nXGIxHYdkFsd -7v3M9+79YKWxehZx0RbQfBI8bGmX265fOZpwLwU8GUYEmSA20GBuYQa7FkKMcPcw -++DbZqMAAb3mLNqRX6BGi01qnD093QVG/na/oAo85ADmJ7f/hC3euiInlhBx6yLt -398znM/jra6O1I7mT1GvFpLgXPYHDw== ------END CERTIFICATE----- -# "Visa Information Delivery Root CA" -# C5 7A 3A CB E8 C0 6B A1 98 8A 83 48 5B F3 26 F2 -# 44 87 75 37 98 49 DE 01 CA 43 57 1A F3 57 E7 4B ------BEGIN CERTIFICATE----- -MIID+TCCAuGgAwIBAgIQW1fXqEywr9nTb0ugMbTW4jANBgkqhkiG9w0BAQUFADB5 -MQswCQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRl -cm5hdGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xKjAoBgNVBAMTIVZpc2EgSW5m -b3JtYXRpb24gRGVsaXZlcnkgUm9vdCBDQTAeFw0wNTA2MjcxNzQyNDJaFw0yNTA2 -MjkxNzQyNDJaMHkxCzAJBgNVBAYTAlVTMQ0wCwYDVQQKEwRWSVNBMS8wLQYDVQQL -EyZWaXNhIEludGVybmF0aW9uYWwgU2VydmljZSBBc3NvY2lhdGlvbjEqMCgGA1UE -AxMhVmlzYSBJbmZvcm1hdGlvbiBEZWxpdmVyeSBSb290IENBMIIBIjANBgkqhkiG -9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyREA4R/QkkfpLx0cYjga/EhIPZpchH0MZsRZ -FfP6C2ITtf/Wc+MtgD4yTK0yoiXvni3d+aCtEgK3GDvkdgYrgF76ROJFZwUQjQ9l -x42gRT05DbXvWFoy7dTglCZ9z/Tt2Cnktv9oxKgmkeHY/CyfpCBg1S8xth2JlGMR -0ug/GMO5zANuegZOv438p5Lt5So+du2Gl+RMFQqEPwqN5uJSqAe0VtmB4gWdQ8on -Bj2ZAM2R73QW7UW0Igt2vA4JaSiNtaAG/Y/58VXWHGgbq7rDtNK1R30X0kJV0rGA -ib3RSwB3LpG7bOjbIucV5mQgJoVjoA1e05w6g1x/KmNTmOGRVwIDAQABo30wezAP -BgNVHRMBAf8EBTADAQH/MDkGA1UdIAQyMDAwLgYFZ4EDAgEwJTAVBggrBgEFBQcC -ARYJMS4yLjMuNC41MAwGCCsGAQUFBwICMAAwDgYDVR0PAQH/BAQDAgEGMB0GA1Ud -DgQWBBRPitp2/2d3I5qmgH1924h1hfeBejANBgkqhkiG9w0BAQUFAAOCAQEACUW1 -QdUHdDJydgDPmYt+telnG/Su+DPaf1cregzlN43bJaJosMP7NwjoJY/H2He4XLWb -5rXEkl+xH1UyUwF7mtaUoxbGxEvt8hPZSTB4da2mzXgwKvXuHyzF5Qjy1hOB0/pS -WaF9ARpVKJJ7TOJQdGKBsF2Ty4fSCLqZLgfxbqwMsd9sysXI3rDXjIhekqvbgeLz -PqZr+pfgFhwCCLSMQWl5Ll3u7Qk9wR094DZ6jj6+JCVCRUS3HyabH4OlM0Vc2K+j -INsF/64Or7GNtRf9HYEJvrPxHINxl3JVwhYj4ASeaO4KwhVbwtw94Tc/XrGcexDo -c5lC3rAi4/UZqweYCw== ------END CERTIFICATE----- -# "VRK Gov. Root CA" -# F0 08 73 3E C5 00 DC 49 87 63 CC 92 64 C6 FC EA -# 40 EC 22 00 0E 92 7D 05 3C E9 C9 0B FA 04 6C B2 ------BEGIN CERTIFICATE----- -MIIEGjCCAwKgAwIBAgIDAYagMA0GCSqGSIb3DQEBBQUAMIGjMQswCQYDVQQGEwJG -STEQMA4GA1UECBMHRmlubGFuZDEhMB8GA1UEChMYVmFlc3RvcmVraXN0ZXJpa2Vz -a3VzIENBMSkwJwYDVQQLEyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBTZXJ2aWNl -czEZMBcGA1UECxMQVmFybWVubmVwYWx2ZWx1dDEZMBcGA1UEAxMQVlJLIEdvdi4g -Um9vdCBDQTAeFw0wMjEyMTgxMzUzMDBaFw0yMzEyMTgxMzUxMDhaMIGjMQswCQYD -VQQGEwJGSTEQMA4GA1UECBMHRmlubGFuZDEhMB8GA1UEChMYVmFlc3RvcmVraXN0 -ZXJpa2Vza3VzIENBMSkwJwYDVQQLEyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSBT -ZXJ2aWNlczEZMBcGA1UECxMQVmFybWVubmVwYWx2ZWx1dDEZMBcGA1UEAxMQVlJL -IEdvdi4gUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALCF -FdrIAzfQo0Y3bBseljDCWoUSZyPyu5/nioFgJ/gTqTy894aqqvTzJSm0/nWuHoGG -igWyHWWyOOi0zCia+xc28ZPVec7Bg4shT8MNrUHfeJ1I4x9CRPw8bSEga60ihCRC -jxdNwlAfZM0tOSJWiP2yY51U2kJpwMhP1xjiPshphJQ9LIDGfM6911Mf64i5psu7 -hVfvV3ZdDIvTXhJBnyHAOfQmbQj6OLOhd7HuFtjQaNq0mKWgZUZKa41+qk1guPjI -DfxxPu45h4G02fhukO4/DmHXHSto5i7hQkQmeCxY8n0Wf2HASSQqiYe2XS8pGfim -545SnkFLWg6quMJmQlMCAwEAAaNVMFMwDwYDVR0TAQH/BAUwAwEB/zARBglghkgB -hvhCAQEEBAMCAAcwDgYDVR0PAQH/BAQDAgHGMB0GA1UdDgQWBBTb6eGb0tEkC/yr -46Bn6q6cS3f0sDANBgkqhkiG9w0BAQUFAAOCAQEArX1ID1QRnljurw2bEi8hpM2b -uoRH5sklVSPj3xhYKizbXvfNVPVRJHtiZ+GxH0mvNNDrsczZog1Sf0JLiGCXzyVy -t08pLWKfT6HAVVdWDsRol5EfnGTCKTIB6dTI2riBmCguGMcs/OubUpbf9MiQGS0j -8/G7cdqehSO9Gu8u5Hp5t8OdhkktY7ktdM9lDzJmid87Ie4pbzlj2RXBbvbfgD5Q -eBmK3QOjFKU3p7UsfLYRh+cF8ry23tT/l4EohP7+bEaFEEGfTXWMB9SZZ291im/k -UJL2mdUQuMSpe/cXjUu/15WfCdxEDx4yw8DP03kN5Mc7h/CQNIghYkmSBAQfvA== ------END CERTIFICATE----- -# "XRamp Global Certification Authority" -# CE CD DC 90 50 99 D8 DA DF C5 B1 D2 09 B7 37 CB -# E2 C1 8C FB 2C 10 C0 FF 0B CF 0D 32 86 FC 1A A2 ------BEGIN CERTIFICATE----- -MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB -gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk -MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY -UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx -NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3 -dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy -dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB -dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6 -38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP -KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q -DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4 -qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa -JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi -PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P -BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs -jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0 -eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD -ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR -vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt -qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa -IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy -i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ -O+7ETPTsJ3xCwnR8gooJybQDJbw= ------END CERTIFICATE----- -` diff --git a/src/crypto/x509/root_ios_gen.go b/src/crypto/x509/root_ios_gen.go deleted file mode 100644 index 15eb1592ca..0000000000 --- a/src/crypto/x509/root_ios_gen.go +++ /dev/null @@ -1,180 +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. - -//go:build ignore - -// Generates root_ios.go. -// -// As of iOS 13, there is no API for querying the system trusted X.509 root -// certificates. -// -// Apple publishes the trusted root certificates for iOS and macOS on -// opensource.apple.com so we embed them into the x509 package. -// -// Note that this ignores distrusted and revoked certificates. -package main - -import ( - "archive/tar" - "bytes" - "compress/gzip" - "crypto/sha256" - "crypto/tls" - "crypto/x509" - "encoding/pem" - "flag" - "fmt" - "go/format" - "io" - "log" - "net/http" - "os" - "path" - "sort" - "strings" - "time" -) - -func main() { - var output = flag.String("output", "root_ios.go", "file name to write") - var version = flag.String("version", "", "security_certificates version") - flag.Parse() - if *version == "" { - log.Fatal("Select the latest security_certificates version from " + - "https://opensource.apple.com/source/security_certificates/") - } - - url := "https://opensource.apple.com/tarballs/security_certificates/security_certificates-%s.tar.gz" - hc := &http.Client{Timeout: 1 * time.Minute} - resp, err := hc.Get(fmt.Sprintf(url, *version)) - if err != nil { - log.Fatal(err) - } - defer resp.Body.Close() - if resp.StatusCode != http.StatusOK { - log.Fatalf("HTTP status not OK: %s", resp.Status) - } - - zr, err := gzip.NewReader(resp.Body) - if err != nil { - log.Fatal(err) - } - defer zr.Close() - - var certs []*x509.Certificate - pool := x509.NewCertPool() - - tr := tar.NewReader(zr) - for { - hdr, err := tr.Next() - if err == io.EOF { - break - } - if err != nil { - log.Fatal(err) - } - - rootsDirectory := fmt.Sprintf("security_certificates-%s/certificates/roots/", *version) - if dir, file := path.Split(hdr.Name); hdr.Typeflag != tar.TypeReg || - dir != rootsDirectory || strings.HasPrefix(file, ".") { - continue - } - - der, err := io.ReadAll(tr) - if err != nil { - log.Fatal(err) - } - - c, err := x509.ParseCertificate(der) - if err != nil { - log.Printf("Failed to parse certificate %q: %v", hdr.Name, err) - continue - } - - certs = append(certs, c) - pool.AddCert(c) - } - - // Quick smoke test to check the pool is well formed, and that we didn't end - // up trusting roots in the removed folder. - for _, c := range certs { - if c.Subject.CommonName == "Symantec Class 2 Public Primary Certification Authority - G4" { - log.Fatal("The pool includes a removed root!") - } - } - conn, err := tls.Dial("tcp", "mail.google.com:443", &tls.Config{ - RootCAs: pool, - }) - if err != nil { - log.Fatal(err) - } - conn.Close() - - certName := func(c *x509.Certificate) string { - if c.Subject.CommonName != "" { - return c.Subject.CommonName - } - if len(c.Subject.OrganizationalUnit) > 0 { - return c.Subject.OrganizationalUnit[0] - } - return c.Subject.Organization[0] - } - sort.Slice(certs, func(i, j int) bool { - if strings.ToLower(certName(certs[i])) != strings.ToLower(certName(certs[j])) { - return strings.ToLower(certName(certs[i])) < strings.ToLower(certName(certs[j])) - } - if !certs[i].NotBefore.Equal(certs[j].NotBefore) { - return certs[i].NotBefore.Before(certs[j].NotBefore) - } - fi, fj := sha256.Sum256(certs[i].Raw), sha256.Sum256(certs[j].Raw) - return bytes.Compare(fi[:], fj[:]) < 0 - }) - - out := new(bytes.Buffer) - fmt.Fprintf(out, header, *version) - fmt.Fprintf(out, "const systemRootsPEM = `\n") - - for _, c := range certs { - fmt.Fprintf(out, "# %q\n", certName(c)) - h := sha256.Sum256(c.Raw) - fmt.Fprintf(out, "# % X\n", h[:len(h)/2]) - fmt.Fprintf(out, "# % X\n", h[len(h)/2:]) - b := &pem.Block{ - Type: "CERTIFICATE", - Bytes: c.Raw, - } - if err := pem.Encode(out, b); err != nil { - log.Fatal(err) - } - } - - fmt.Fprintf(out, "`") - - source, err := format.Source(out.Bytes()) - if err != nil { - log.Fatal(err) - } - if err := os.WriteFile(*output, source, 0644); err != nil { - log.Fatal(err) - } -} - -const header = `// Code generated by root_ios_gen.go -version %s; DO NOT EDIT. -// Update the version in root.go and regenerate with "go generate". - -//go:build ios && !x509omitbundledroots -// +build ios,!x509omitbundledroots - -package x509 - -func (c *Certificate) systemVerify(opts *VerifyOptions) (chains [][]*Certificate, err error) { - return nil, nil -} - -func loadSystemRoots() (*CertPool, error) { - p := NewCertPool() - p.AppendCertsFromPEM([]byte(systemRootsPEM)) - return p, nil -} -` diff --git a/src/crypto/x509/root_omit.go b/src/crypto/x509/root_omit.go deleted file mode 100644 index 299d74835e..0000000000 --- a/src/crypto/x509/root_omit.go +++ /dev/null @@ -1,25 +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. - -//go:build ((darwin && arm64) || (darwin && amd64 && ios)) && x509omitbundledroots - -// This file provides the loadSystemRoots func when the -// "x509omitbundledroots" build tag has disabled bundling a copy, -// which currently on happens on darwin/arm64 (root_darwin_arm64.go). -// This then saves 256 KiB of binary size and another 560 KiB of -// runtime memory size retaining the parsed roots forever. Constrained -// environments can construct minimal x509 root CertPools on the fly -// in the crypto/tls.Config.VerifyPeerCertificate hook. - -package x509 - -import "errors" - -func loadSystemRoots() (*CertPool, error) { - return nil, errors.New("x509: system root bundling disabled") -} - -func (c *Certificate) systemVerify(opts *VerifyOptions) (chains [][]*Certificate, err error) { - return nil, nil -} diff --git a/src/crypto/x509/root_omit_test.go b/src/crypto/x509/root_omit_test.go deleted file mode 100644 index 1709e2ea8b..0000000000 --- a/src/crypto/x509/root_omit_test.go +++ /dev/null @@ -1,22 +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. - -//go:build ((darwin && arm64) || (darwin && amd64 && ios)) && x509omitbundledroots - -package x509 - -import ( - "strings" - "testing" -) - -func TestOmitBundledRoots(t *testing.T) { - cp, err := loadSystemRoots() - if err == nil { - t.Fatalf("loadSystemRoots = (pool %p, error %v); want non-nil error", cp, err) - } - if !strings.Contains(err.Error(), "root bundling disabled") { - t.Errorf("unexpected error doesn't mention bundling: %v", err) - } -} diff --git a/src/crypto/x509/verify.go b/src/crypto/x509/verify.go index 1822a609da..59852d9d68 100644 --- a/src/crypto/x509/verify.go +++ b/src/crypto/x509/verify.go @@ -742,7 +742,7 @@ func (c *Certificate) Verify(opts VerifyOptions) (chains [][]*Certificate, err e } // Use platform verifiers, where available - if opts.Roots == nil && (runtime.GOOS == "windows" || runtime.GOOS == "darwin") { + if opts.Roots == nil && (runtime.GOOS == "windows" || runtime.GOOS == "darwin" || runtime.GOOS == "ios") { return c.systemVerify(&opts) } diff --git a/src/crypto/x509/verify_test.go b/src/crypto/x509/verify_test.go index 5b3bf9340a..05d521c09d 100644 --- a/src/crypto/x509/verify_test.go +++ b/src/crypto/x509/verify_test.go @@ -1836,7 +1836,7 @@ func TestLongChain(t *testing.T) { } func TestSystemRootsError(t *testing.T) { - if runtime.GOOS == "windows" || runtime.GOOS == "darwin" { + if runtime.GOOS == "windows" || runtime.GOOS == "darwin" || runtime.GOOS == "ios" { t.Skip("Windows and darwin do not use (or support) systemRoots") } diff --git a/src/crypto/x509/x509_test.go b/src/crypto/x509/x509_test.go index 949bd7f08b..3345f57075 100644 --- a/src/crypto/x509/x509_test.go +++ b/src/crypto/x509/x509_test.go @@ -1975,7 +1975,7 @@ func TestMultipleRDN(t *testing.T) { } func TestSystemCertPool(t *testing.T) { - if runtime.GOOS == "windows" || runtime.GOOS == "darwin" { + if runtime.GOOS == "windows" || runtime.GOOS == "darwin" || runtime.GOOS == "ios" { t.Skip("not implemented on Windows (Issue 16736, 18609) or darwin (Issue 46287)") } a, err := SystemCertPool() From f19e4001808863d2ebfe9d1975476513d030c381 Mon Sep 17 00:00:00 2001 From: Tobias Klauser Date: Sat, 6 Nov 2021 11:09:56 +0100 Subject: [PATCH 013/752] all: remove more leftover // +build lines CL 344955 and CL 359476 removed almost all // +build lines, but leaving some assembly files and generating scripts. Also, some files were added with // +build lines after CL 359476 was merged. Remove these or rename files where more appropriate. For #41184 Change-Id: I7eb85a498ed9788b42a636e775f261d755504ffa Reviewed-on: https://go-review.googlesource.com/c/go/+/361480 Trust: Tobias Klauser Run-TryBot: Tobias Klauser TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/crypto/cipher/xor_ppc64x.s | 1 - src/crypto/md5/md5block_ppc64x.s | 1 - src/crypto/x509/internal/macos/corefoundation.s | 1 - src/crypto/x509/internal/macos/security.s | 1 - src/debug/pe/file_cgo_test.go | 1 - src/internal/bytealg/compare_mips64x.s | 1 - src/internal/bytealg/compare_mipsx.s | 1 - src/internal/bytealg/compare_ppc64x.s | 1 - src/internal/bytealg/count_ppc64x.s | 1 - src/internal/bytealg/equal_mips64x.s | 1 - src/internal/bytealg/equal_mipsx.s | 1 - src/internal/bytealg/equal_ppc64x.s | 1 - src/internal/bytealg/index_ppc64x.s | 1 - src/internal/bytealg/indexbyte_mips64x.s | 1 - src/internal/bytealg/indexbyte_mipsx.s | 1 - src/internal/bytealg/indexbyte_ppc64x.s | 1 - src/internal/cpu/cpu_x86.s | 1 - src/reflect/asm_mips64x.s | 1 - src/reflect/asm_mipsx.s | 1 - src/reflect/asm_ppc64x.s | 1 - src/reflect/float32reg_ppc64x.s | 1 - src/runtime/asan_amd64.s | 1 - src/runtime/asan_arm64.s | 1 - src/runtime/asm_mips64x.s | 1 - src/runtime/asm_mipsx.s | 1 - src/runtime/asm_ppc64x.s | 1 - src/runtime/atomic_mips64x.s | 1 - src/runtime/atomic_mipsx.s | 1 - src/runtime/atomic_ppc64x.s | 1 - src/runtime/duff_mips64x.s | 1 - src/runtime/duff_ppc64x.s | 1 - src/runtime/internal/atomic/atomic_mips64x.s | 1 - src/runtime/internal/atomic/atomic_mipsx.s | 1 - src/runtime/internal/atomic/atomic_ppc64x.s | 1 - src/runtime/internal/atomic/sys_nonlinux_arm.s | 1 - src/runtime/libfuzzer_amd64.s | 1 - src/runtime/libfuzzer_arm64.s | 1 - src/runtime/memclr_386.s | 1 - src/runtime/memclr_amd64.s | 1 - src/runtime/memclr_mips64x.s | 1 - src/runtime/memclr_mipsx.s | 1 - src/runtime/memclr_ppc64x.s | 1 - src/runtime/memmove_386.s | 1 - src/runtime/memmove_amd64.s | 1 - src/runtime/memmove_mips64x.s | 1 - src/runtime/memmove_mipsx.s | 1 - src/runtime/memmove_ppc64x.s | 1 - src/runtime/msan_amd64.s | 1 - src/runtime/msan_arm64.s | 1 - src/runtime/preempt_mips64x.s | 1 - src/runtime/preempt_mipsx.s | 1 - src/runtime/preempt_ppc64x.s | 1 - src/runtime/race_amd64.s | 1 - src/runtime/race_arm64.s | 1 - src/runtime/race_ppc64le.s | 1 - src/runtime/rt0_linux_mips64x.s | 2 -- src/runtime/rt0_linux_mipsx.s | 2 -- src/runtime/sys_linux_mips64x.s | 2 -- src/runtime/sys_linux_mipsx.s | 2 -- src/runtime/sys_linux_ppc64x.s | 2 -- src/runtime/time_linux_amd64.s | 1 - src/runtime/time_windows_386.s | 1 - src/runtime/time_windows_amd64.s | 1 - src/runtime/time_windows_arm.s | 1 - src/runtime/time_windows_arm64.s | 1 - src/runtime/tls_arm.s | 1 - src/runtime/tls_mips64x.s | 1 - src/runtime/tls_mipsx.s | 1 - src/runtime/tls_ppc64x.s | 1 - src/runtime/zcallback_windows.s | 1 - src/sync/atomic/asm.s | 1 - src/sync/atomic/race.s | 1 - src/syscall/asan.go | 1 - src/syscall/asan0.go | 3 +-- src/syscall/asm9_unix2_amd64.s | 1 - src/syscall/asm_linux_mips64x.s | 2 -- src/syscall/asm_linux_mipsx.s | 2 -- src/syscall/asm_linux_ppc64x.s | 2 -- src/syscall/{asm9_unix1_amd64.s => asm_netbsd_amd64.s} | 3 --- src/syscall/asm_unix_386.s | 1 - src/syscall/asm_unix_amd64.s | 1 - src/syscall/mksyscall.pl | 1 - src/syscall/mksyscall_libc.pl | 1 - 83 files changed, 1 insertion(+), 94 deletions(-) rename src/syscall/{asm9_unix1_amd64.s => asm_netbsd_amd64.s} (96%) diff --git a/src/crypto/cipher/xor_ppc64x.s b/src/crypto/cipher/xor_ppc64x.s index 2ba6d9639c..a2ec95c0be 100644 --- a/src/crypto/cipher/xor_ppc64x.s +++ b/src/crypto/cipher/xor_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "textflag.h" diff --git a/src/crypto/md5/md5block_ppc64x.s b/src/crypto/md5/md5block_ppc64x.s index 8c28ec2473..69a20e7cad 100644 --- a/src/crypto/md5/md5block_ppc64x.s +++ b/src/crypto/md5/md5block_ppc64x.s @@ -11,7 +11,6 @@ // in the public domain. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "textflag.h" diff --git a/src/crypto/x509/internal/macos/corefoundation.s b/src/crypto/x509/internal/macos/corefoundation.s index 376099caa3..e60bd8712d 100644 --- a/src/crypto/x509/internal/macos/corefoundation.s +++ b/src/crypto/x509/internal/macos/corefoundation.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build darwin && !ios -// +build darwin,!ios #include "textflag.h" diff --git a/src/crypto/x509/internal/macos/security.s b/src/crypto/x509/internal/macos/security.s index 9c1c133489..77406a0553 100644 --- a/src/crypto/x509/internal/macos/security.s +++ b/src/crypto/x509/internal/macos/security.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build darwin && !ios -// +build darwin,!ios #include "textflag.h" diff --git a/src/debug/pe/file_cgo_test.go b/src/debug/pe/file_cgo_test.go index 13eb4e62b2..9280de1a49 100644 --- a/src/debug/pe/file_cgo_test.go +++ b/src/debug/pe/file_cgo_test.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build cgo -// +build cgo package pe diff --git a/src/internal/bytealg/compare_mips64x.s b/src/internal/bytealg/compare_mips64x.s index b472e510bc..117a9ef631 100644 --- a/src/internal/bytealg/compare_mips64x.s +++ b/src/internal/bytealg/compare_mips64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips64 || mips64le -// +build mips64 mips64le #include "go_asm.h" #include "textflag.h" diff --git a/src/internal/bytealg/compare_mipsx.s b/src/internal/bytealg/compare_mipsx.s index dcc4916e56..857ac13389 100644 --- a/src/internal/bytealg/compare_mipsx.s +++ b/src/internal/bytealg/compare_mipsx.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips || mipsle -// +build mips mipsle #include "go_asm.h" #include "textflag.h" diff --git a/src/internal/bytealg/compare_ppc64x.s b/src/internal/bytealg/compare_ppc64x.s index 390a72688b..2793e44e8b 100644 --- a/src/internal/bytealg/compare_ppc64x.s +++ b/src/internal/bytealg/compare_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "go_asm.h" #include "textflag.h" diff --git a/src/internal/bytealg/count_ppc64x.s b/src/internal/bytealg/count_ppc64x.s index dbafd06edc..43d547bb8a 100644 --- a/src/internal/bytealg/count_ppc64x.s +++ b/src/internal/bytealg/count_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64le || ppc64 -// +build ppc64le ppc64 #include "go_asm.h" #include "textflag.h" diff --git a/src/internal/bytealg/equal_mips64x.s b/src/internal/bytealg/equal_mips64x.s index c2f7d3997e..d92f225e8d 100644 --- a/src/internal/bytealg/equal_mips64x.s +++ b/src/internal/bytealg/equal_mips64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips64 || mips64le -// +build mips64 mips64le #include "go_asm.h" #include "textflag.h" diff --git a/src/internal/bytealg/equal_mipsx.s b/src/internal/bytealg/equal_mipsx.s index 11e5549e45..4c46dd4fce 100644 --- a/src/internal/bytealg/equal_mipsx.s +++ b/src/internal/bytealg/equal_mipsx.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips || mipsle -// +build mips mipsle #include "go_asm.h" #include "textflag.h" diff --git a/src/internal/bytealg/equal_ppc64x.s b/src/internal/bytealg/equal_ppc64x.s index d59154101a..bd8caa7f18 100644 --- a/src/internal/bytealg/equal_ppc64x.s +++ b/src/internal/bytealg/equal_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "go_asm.h" #include "textflag.h" diff --git a/src/internal/bytealg/index_ppc64x.s b/src/internal/bytealg/index_ppc64x.s index ab47495427..2d2a7146f1 100644 --- a/src/internal/bytealg/index_ppc64x.s +++ b/src/internal/bytealg/index_ppc64x.s @@ -22,7 +22,6 @@ // implementation on power9. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "go_asm.h" #include "textflag.h" diff --git a/src/internal/bytealg/indexbyte_mips64x.s b/src/internal/bytealg/indexbyte_mips64x.s index 0f377f5a4c..5689f84b47 100644 --- a/src/internal/bytealg/indexbyte_mips64x.s +++ b/src/internal/bytealg/indexbyte_mips64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips64 || mips64le -// +build mips64 mips64le #include "go_asm.h" #include "textflag.h" diff --git a/src/internal/bytealg/indexbyte_mipsx.s b/src/internal/bytealg/indexbyte_mipsx.s index bed015bbd6..1c2b104d3c 100644 --- a/src/internal/bytealg/indexbyte_mipsx.s +++ b/src/internal/bytealg/indexbyte_mipsx.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips || mipsle -// +build mips mipsle #include "go_asm.h" #include "textflag.h" diff --git a/src/internal/bytealg/indexbyte_ppc64x.s b/src/internal/bytealg/indexbyte_ppc64x.s index 27e1ad7e0d..87ef8ecffc 100644 --- a/src/internal/bytealg/indexbyte_ppc64x.s +++ b/src/internal/bytealg/indexbyte_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "go_asm.h" #include "textflag.h" diff --git a/src/internal/cpu/cpu_x86.s b/src/internal/cpu/cpu_x86.s index 0df5da1cc7..edef21905c 100644 --- a/src/internal/cpu/cpu_x86.s +++ b/src/internal/cpu/cpu_x86.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build 386 || amd64 -// +build 386 amd64 #include "textflag.h" diff --git a/src/reflect/asm_mips64x.s b/src/reflect/asm_mips64x.s index 8d01c5fb7e..f21e34df1b 100644 --- a/src/reflect/asm_mips64x.s +++ b/src/reflect/asm_mips64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips64 || mips64le -// +build mips64 mips64le #include "textflag.h" #include "funcdata.h" diff --git a/src/reflect/asm_mipsx.s b/src/reflect/asm_mipsx.s index 6ea8233108..636c8a5c71 100644 --- a/src/reflect/asm_mipsx.s +++ b/src/reflect/asm_mipsx.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips || mipsle -// +build mips mipsle #include "textflag.h" #include "funcdata.h" diff --git a/src/reflect/asm_ppc64x.s b/src/reflect/asm_ppc64x.s index 1ccfb25b94..3b529be685 100644 --- a/src/reflect/asm_ppc64x.s +++ b/src/reflect/asm_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "textflag.h" #include "funcdata.h" diff --git a/src/reflect/float32reg_ppc64x.s b/src/reflect/float32reg_ppc64x.s index 391edfa7ce..a4deb18427 100644 --- a/src/reflect/float32reg_ppc64x.s +++ b/src/reflect/float32reg_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "textflag.h" diff --git a/src/runtime/asan_amd64.s b/src/runtime/asan_amd64.s index 01bd612dc3..e8de80399b 100644 --- a/src/runtime/asan_amd64.s +++ b/src/runtime/asan_amd64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build asan -// +build asan #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/asan_arm64.s b/src/runtime/asan_arm64.s index eb0f9bd71e..acae200fb5 100644 --- a/src/runtime/asan_arm64.s +++ b/src/runtime/asan_arm64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build asan -// +build asan #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/asm_mips64x.s b/src/runtime/asm_mips64x.s index e0e5cbb704..3597ebec57 100644 --- a/src/runtime/asm_mips64x.s +++ b/src/runtime/asm_mips64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips64 || mips64le -// +build mips64 mips64le #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/asm_mipsx.s b/src/runtime/asm_mipsx.s index 1b550719d1..4a086b8eb3 100644 --- a/src/runtime/asm_mipsx.s +++ b/src/runtime/asm_mipsx.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips || mipsle -// +build mips mipsle #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/asm_ppc64x.s b/src/runtime/asm_ppc64x.s index 0e7ef7b2b8..ae14213999 100644 --- a/src/runtime/asm_ppc64x.s +++ b/src/runtime/asm_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/atomic_mips64x.s b/src/runtime/atomic_mips64x.s index e2118e6a20..dd6380ce40 100644 --- a/src/runtime/atomic_mips64x.s +++ b/src/runtime/atomic_mips64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips64 || mips64le -// +build mips64 mips64le #include "textflag.h" diff --git a/src/runtime/atomic_mipsx.s b/src/runtime/atomic_mipsx.s index 1eacd273b4..ac255fe7e6 100644 --- a/src/runtime/atomic_mipsx.s +++ b/src/runtime/atomic_mipsx.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips || mipsle -// +build mips mipsle #include "textflag.h" diff --git a/src/runtime/atomic_ppc64x.s b/src/runtime/atomic_ppc64x.s index b63de2dbd3..4742b6cf56 100644 --- a/src/runtime/atomic_ppc64x.s +++ b/src/runtime/atomic_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "textflag.h" diff --git a/src/runtime/duff_mips64x.s b/src/runtime/duff_mips64x.s index a897d7fd9b..3a8524c78b 100644 --- a/src/runtime/duff_mips64x.s +++ b/src/runtime/duff_mips64x.s @@ -3,7 +3,6 @@ // See mkduff.go for comments. //go:build mips64 || mips64le -// +build mips64 mips64le #include "textflag.h" diff --git a/src/runtime/duff_ppc64x.s b/src/runtime/duff_ppc64x.s index eeecf13df1..a3caaa8817 100644 --- a/src/runtime/duff_ppc64x.s +++ b/src/runtime/duff_ppc64x.s @@ -3,7 +3,6 @@ // See mkduff.go for comments. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "textflag.h" diff --git a/src/runtime/internal/atomic/atomic_mips64x.s b/src/runtime/internal/atomic/atomic_mips64x.s index fedfc4a175..b4411d87da 100644 --- a/src/runtime/internal/atomic/atomic_mips64x.s +++ b/src/runtime/internal/atomic/atomic_mips64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips64 || mips64le -// +build mips64 mips64le #include "textflag.h" diff --git a/src/runtime/internal/atomic/atomic_mipsx.s b/src/runtime/internal/atomic/atomic_mipsx.s index c0835d66ed..390e9ce7ac 100644 --- a/src/runtime/internal/atomic/atomic_mipsx.s +++ b/src/runtime/internal/atomic/atomic_mipsx.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips || mipsle -// +build mips mipsle #include "textflag.h" diff --git a/src/runtime/internal/atomic/atomic_ppc64x.s b/src/runtime/internal/atomic/atomic_ppc64x.s index 226b3b6216..04f0eadd06 100644 --- a/src/runtime/internal/atomic/atomic_ppc64x.s +++ b/src/runtime/internal/atomic/atomic_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "textflag.h" diff --git a/src/runtime/internal/atomic/sys_nonlinux_arm.s b/src/runtime/internal/atomic/sys_nonlinux_arm.s index 04036ca970..b55bf908a2 100644 --- a/src/runtime/internal/atomic/sys_nonlinux_arm.s +++ b/src/runtime/internal/atomic/sys_nonlinux_arm.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !linux -// +build !linux #include "textflag.h" diff --git a/src/runtime/libfuzzer_amd64.s b/src/runtime/libfuzzer_amd64.s index 13645fc7af..253fe15198 100644 --- a/src/runtime/libfuzzer_amd64.s +++ b/src/runtime/libfuzzer_amd64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build libfuzzer -// +build libfuzzer #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/libfuzzer_arm64.s b/src/runtime/libfuzzer_arm64.s index 4ad8242804..ae0efd8c9b 100644 --- a/src/runtime/libfuzzer_arm64.s +++ b/src/runtime/libfuzzer_arm64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build libfuzzer -// +build libfuzzer #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/memclr_386.s b/src/runtime/memclr_386.s index 2627792ced..a72e5f228d 100644 --- a/src/runtime/memclr_386.s +++ b/src/runtime/memclr_386.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !plan9 -// +build !plan9 #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/memclr_amd64.s b/src/runtime/memclr_amd64.s index 918a4b9e0e..700bbd7b9b 100644 --- a/src/runtime/memclr_amd64.s +++ b/src/runtime/memclr_amd64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !plan9 -// +build !plan9 #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/memclr_mips64x.s b/src/runtime/memclr_mips64x.s index bc037013fe..cf3a9c4ab4 100644 --- a/src/runtime/memclr_mips64x.s +++ b/src/runtime/memclr_mips64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips64 || mips64le -// +build mips64 mips64le #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/memclr_mipsx.s b/src/runtime/memclr_mipsx.s index 3d21c3c414..ee3009d46b 100644 --- a/src/runtime/memclr_mipsx.s +++ b/src/runtime/memclr_mipsx.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips || mipsle -// +build mips mipsle #include "textflag.h" diff --git a/src/runtime/memclr_ppc64x.s b/src/runtime/memclr_ppc64x.s index 91aa417ca2..64132cee96 100644 --- a/src/runtime/memclr_ppc64x.s +++ b/src/runtime/memclr_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "textflag.h" diff --git a/src/runtime/memmove_386.s b/src/runtime/memmove_386.s index 389ef88477..6d7e17fcbc 100644 --- a/src/runtime/memmove_386.s +++ b/src/runtime/memmove_386.s @@ -24,7 +24,6 @@ // THE SOFTWARE. //go:build !plan9 -// +build !plan9 #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/memmove_amd64.s b/src/runtime/memmove_amd64.s index fa0c0e414f..eeb5033fd9 100644 --- a/src/runtime/memmove_amd64.s +++ b/src/runtime/memmove_amd64.s @@ -24,7 +24,6 @@ // THE SOFTWARE. //go:build !plan9 -// +build !plan9 #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/memmove_mips64x.s b/src/runtime/memmove_mips64x.s index fef3c6be82..b69178ccd3 100644 --- a/src/runtime/memmove_mips64x.s +++ b/src/runtime/memmove_mips64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips64 || mips64le -// +build mips64 mips64le #include "textflag.h" diff --git a/src/runtime/memmove_mipsx.s b/src/runtime/memmove_mipsx.s index cd02fc25c4..494288cf33 100644 --- a/src/runtime/memmove_mipsx.s +++ b/src/runtime/memmove_mipsx.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips || mipsle -// +build mips mipsle #include "textflag.h" diff --git a/src/runtime/memmove_ppc64x.s b/src/runtime/memmove_ppc64x.s index b36b23f8ef..e69e71a4a1 100644 --- a/src/runtime/memmove_ppc64x.s +++ b/src/runtime/memmove_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "textflag.h" diff --git a/src/runtime/msan_amd64.s b/src/runtime/msan_amd64.s index 1bb57a3b7e..89ed3048d0 100644 --- a/src/runtime/msan_amd64.s +++ b/src/runtime/msan_amd64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build msan -// +build msan #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/msan_arm64.s b/src/runtime/msan_arm64.s index 93ade8dd89..b9eff34ab6 100644 --- a/src/runtime/msan_arm64.s +++ b/src/runtime/msan_arm64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build msan -// +build msan #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/preempt_mips64x.s b/src/runtime/preempt_mips64x.s index c1249e382e..996b592ae0 100644 --- a/src/runtime/preempt_mips64x.s +++ b/src/runtime/preempt_mips64x.s @@ -1,7 +1,6 @@ // Code generated by mkpreempt.go; DO NOT EDIT. //go:build mips64 || mips64le -// +build mips64 mips64le #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/preempt_mipsx.s b/src/runtime/preempt_mipsx.s index 70b79e05b9..7b169acd99 100644 --- a/src/runtime/preempt_mipsx.s +++ b/src/runtime/preempt_mipsx.s @@ -1,7 +1,6 @@ // Code generated by mkpreempt.go; DO NOT EDIT. //go:build mips || mipsle -// +build mips mipsle #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/preempt_ppc64x.s b/src/runtime/preempt_ppc64x.s index 7ed4021dde..2c4d02edfe 100644 --- a/src/runtime/preempt_ppc64x.s +++ b/src/runtime/preempt_ppc64x.s @@ -1,7 +1,6 @@ // Code generated by mkpreempt.go; DO NOT EDIT. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/race_amd64.s b/src/runtime/race_amd64.s index d42e415dca..f055acf77d 100644 --- a/src/runtime/race_amd64.s +++ b/src/runtime/race_amd64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build race -// +build race #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/race_arm64.s b/src/runtime/race_arm64.s index 2b2413b6b7..798e23294a 100644 --- a/src/runtime/race_arm64.s +++ b/src/runtime/race_arm64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build race -// +build race #include "go_asm.h" #include "funcdata.h" diff --git a/src/runtime/race_ppc64le.s b/src/runtime/race_ppc64le.s index 625c81a255..68cc5c8805 100644 --- a/src/runtime/race_ppc64le.s +++ b/src/runtime/race_ppc64le.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build race -// +build race #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/rt0_linux_mips64x.s b/src/runtime/rt0_linux_mips64x.s index fabd8570b5..e9328b7326 100644 --- a/src/runtime/rt0_linux_mips64x.s +++ b/src/runtime/rt0_linux_mips64x.s @@ -3,8 +3,6 @@ // license that can be found in the LICENSE file. //go:build linux && (mips64 || mips64le) -// +build linux -// +build mips64 mips64le #include "textflag.h" diff --git a/src/runtime/rt0_linux_mipsx.s b/src/runtime/rt0_linux_mipsx.s index 9f5842b51a..3cbb7fc377 100644 --- a/src/runtime/rt0_linux_mipsx.s +++ b/src/runtime/rt0_linux_mipsx.s @@ -3,8 +3,6 @@ // license that can be found in the LICENSE file. //go:build linux && (mips || mipsle) -// +build linux -// +build mips mipsle #include "textflag.h" diff --git a/src/runtime/sys_linux_mips64x.s b/src/runtime/sys_linux_mips64x.s index 08e44d671b..0df2597993 100644 --- a/src/runtime/sys_linux_mips64x.s +++ b/src/runtime/sys_linux_mips64x.s @@ -3,8 +3,6 @@ // license that can be found in the LICENSE file. //go:build linux && (mips64 || mips64le) -// +build linux -// +build mips64 mips64le // // System calls and other sys.stuff for mips64, Linux diff --git a/src/runtime/sys_linux_mipsx.s b/src/runtime/sys_linux_mipsx.s index c828431899..2207e9ab98 100644 --- a/src/runtime/sys_linux_mipsx.s +++ b/src/runtime/sys_linux_mipsx.s @@ -3,8 +3,6 @@ // license that can be found in the LICENSE file. //go:build linux && (mips || mipsle) -// +build linux -// +build mips mipsle // // System calls and other sys.stuff for mips, Linux diff --git a/src/runtime/sys_linux_ppc64x.s b/src/runtime/sys_linux_ppc64x.s index 9347afaf19..dc3d89fae7 100644 --- a/src/runtime/sys_linux_ppc64x.s +++ b/src/runtime/sys_linux_ppc64x.s @@ -3,8 +3,6 @@ // license that can be found in the LICENSE file. //go:build linux && (ppc64 || ppc64le) -// +build linux -// +build ppc64 ppc64le // // System calls and other sys.stuff for ppc64, Linux diff --git a/src/runtime/time_linux_amd64.s b/src/runtime/time_linux_amd64.s index 67cfdd8fdf..1416d23230 100644 --- a/src/runtime/time_linux_amd64.s +++ b/src/runtime/time_linux_amd64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !faketime -// +build !faketime #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/time_windows_386.s b/src/runtime/time_windows_386.s index 19ce6910d7..b8b636ef30 100644 --- a/src/runtime/time_windows_386.s +++ b/src/runtime/time_windows_386.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !faketime -// +build !faketime #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/time_windows_amd64.s b/src/runtime/time_windows_amd64.s index 70f6a008cd..226f2b5136 100644 --- a/src/runtime/time_windows_amd64.s +++ b/src/runtime/time_windows_amd64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !faketime -// +build !faketime #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/time_windows_arm.s b/src/runtime/time_windows_arm.s index 6552d75ff1..711af88307 100644 --- a/src/runtime/time_windows_arm.s +++ b/src/runtime/time_windows_arm.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !faketime -// +build !faketime #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/time_windows_arm64.s b/src/runtime/time_windows_arm64.s index ef5b848473..e0c7d28e15 100644 --- a/src/runtime/time_windows_arm64.s +++ b/src/runtime/time_windows_arm64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !faketime -// +build !faketime #include "go_asm.h" #include "textflag.h" diff --git a/src/runtime/tls_arm.s b/src/runtime/tls_arm.s index 879caac9e1..83fd37e6ec 100644 --- a/src/runtime/tls_arm.s +++ b/src/runtime/tls_arm.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !windows -// +build !windows #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/tls_mips64x.s b/src/runtime/tls_mips64x.s index 779d64ba31..ec2748e5b2 100644 --- a/src/runtime/tls_mips64x.s +++ b/src/runtime/tls_mips64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips64 || mips64le -// +build mips64 mips64le #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/tls_mipsx.s b/src/runtime/tls_mipsx.s index ada8d06a9e..acc3eb5a17 100644 --- a/src/runtime/tls_mipsx.s +++ b/src/runtime/tls_mipsx.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build mips || mipsle -// +build mips mipsle #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/tls_ppc64x.s b/src/runtime/tls_ppc64x.s index 7e935d0eb2..17aec9fc1e 100644 --- a/src/runtime/tls_ppc64x.s +++ b/src/runtime/tls_ppc64x.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build ppc64 || ppc64le -// +build ppc64 ppc64le #include "go_asm.h" #include "go_tls.h" diff --git a/src/runtime/zcallback_windows.s b/src/runtime/zcallback_windows.s index 561527c90d..bd23d71333 100644 --- a/src/runtime/zcallback_windows.s +++ b/src/runtime/zcallback_windows.s @@ -1,7 +1,6 @@ // Code generated by wincallback.go using 'go generate'. DO NOT EDIT. //go:build 386 || amd64 -// +build 386 amd64 // runtime·callbackasm is called by external code to // execute Go implemented callback function. It is not diff --git a/src/sync/atomic/asm.s b/src/sync/atomic/asm.s index 7b8c9b9430..2022304665 100644 --- a/src/sync/atomic/asm.s +++ b/src/sync/atomic/asm.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build !race -// +build !race #include "textflag.h" diff --git a/src/sync/atomic/race.s b/src/sync/atomic/race.s index 0866487cc7..90bd69f321 100644 --- a/src/sync/atomic/race.s +++ b/src/sync/atomic/race.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build race -// +build race // This file is here only to allow external functions. // The operations are implemented in src/runtime/race_amd64.s diff --git a/src/syscall/asan.go b/src/syscall/asan.go index 3199130211..eff30781e4 100644 --- a/src/syscall/asan.go +++ b/src/syscall/asan.go @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build asan -// +build asan package syscall diff --git a/src/syscall/asan0.go b/src/syscall/asan0.go index 7b69f4a64b..08bc44dea1 100644 --- a/src/syscall/asan0.go +++ b/src/syscall/asan0.go @@ -1,9 +1,8 @@ -// Copyright 2020 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. //go:build !asan -// +build !asan package syscall diff --git a/src/syscall/asm9_unix2_amd64.s b/src/syscall/asm9_unix2_amd64.s index 7e5e3c52ad..649bc6024c 100644 --- a/src/syscall/asm9_unix2_amd64.s +++ b/src/syscall/asm9_unix2_amd64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build dragonfly || freebsd -// +build dragonfly freebsd #include "textflag.h" #include "funcdata.h" diff --git a/src/syscall/asm_linux_mips64x.s b/src/syscall/asm_linux_mips64x.s index d18a7b8944..a75d0f7a2a 100644 --- a/src/syscall/asm_linux_mips64x.s +++ b/src/syscall/asm_linux_mips64x.s @@ -3,8 +3,6 @@ // license that can be found in the LICENSE file. //go:build linux && (mips64 || mips64le) -// +build linux -// +build mips64 mips64le #include "textflag.h" diff --git a/src/syscall/asm_linux_mipsx.s b/src/syscall/asm_linux_mipsx.s index cafa6a35c7..04f90f6edf 100644 --- a/src/syscall/asm_linux_mipsx.s +++ b/src/syscall/asm_linux_mipsx.s @@ -3,8 +3,6 @@ // license that can be found in the LICENSE file. //go:build linux && (mips || mipsle) -// +build linux -// +build mips mipsle #include "textflag.h" #include "funcdata.h" diff --git a/src/syscall/asm_linux_ppc64x.s b/src/syscall/asm_linux_ppc64x.s index eac7272f1d..044a479c00 100644 --- a/src/syscall/asm_linux_ppc64x.s +++ b/src/syscall/asm_linux_ppc64x.s @@ -3,8 +3,6 @@ // license that can be found in the LICENSE file. //go:build linux && (ppc64 || ppc64le) -// +build linux -// +build ppc64 ppc64le #include "textflag.h" diff --git a/src/syscall/asm9_unix1_amd64.s b/src/syscall/asm_netbsd_amd64.s similarity index 96% rename from src/syscall/asm9_unix1_amd64.s rename to src/syscall/asm_netbsd_amd64.s index e4609d075c..9e4dd20ad3 100644 --- a/src/syscall/asm9_unix1_amd64.s +++ b/src/syscall/asm_netbsd_amd64.s @@ -2,9 +2,6 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build netbsd -// +build netbsd - #include "textflag.h" #include "funcdata.h" diff --git a/src/syscall/asm_unix_386.s b/src/syscall/asm_unix_386.s index 9f9b7f362d..22700194cb 100644 --- a/src/syscall/asm_unix_386.s +++ b/src/syscall/asm_unix_386.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build freebsd || netbsd -// +build freebsd netbsd #include "textflag.h" #include "funcdata.h" diff --git a/src/syscall/asm_unix_amd64.s b/src/syscall/asm_unix_amd64.s index c53e1a42b6..8ee46b86b5 100644 --- a/src/syscall/asm_unix_amd64.s +++ b/src/syscall/asm_unix_amd64.s @@ -3,7 +3,6 @@ // license that can be found in the LICENSE file. //go:build dragonfly || freebsd || netbsd -// +build dragonfly freebsd netbsd #include "textflag.h" #include "funcdata.h" diff --git a/src/syscall/mksyscall.pl b/src/syscall/mksyscall.pl index 758948bc53..25ab911b7c 100755 --- a/src/syscall/mksyscall.pl +++ b/src/syscall/mksyscall.pl @@ -387,7 +387,6 @@ print < Date: Fri, 5 Nov 2021 09:47:54 +0800 Subject: [PATCH 014/752] cmd/compile: avoid adding LECall to the entry block when has opendefers The openDeferRecord always insert vardef/varlive pairs into the entry block, it may destroy the mem chain when LECall's args are writing into the same block. So create a new block before that happens. Fixes #49282 Change-Id: Ibda6c4a45d960dd412a641f5e02276f663c80785 Reviewed-on: https://go-review.googlesource.com/c/go/+/361410 Run-TryBot: Alberto Donizetti TryBot-Result: Go Bot Trust: Alberto Donizetti Trust: Than McIntosh Reviewed-by: David Chase --- src/cmd/compile/internal/ssagen/ssa.go | 12 +++++++ test/fixedbugs/issue49282.go | 44 ++++++++++++++++++++++++++ 2 files changed, 56 insertions(+) create mode 100644 test/fixedbugs/issue49282.go diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go index b84199790f..0853242e6f 100644 --- a/src/cmd/compile/internal/ssagen/ssa.go +++ b/src/cmd/compile/internal/ssagen/ssa.go @@ -5075,6 +5075,18 @@ func (s *state) call(n *ir.CallExpr, k callKind, returnResultAddr bool) *ssa.Val for _, p := range params.InParams() { // includes receiver for interface calls ACArgs = append(ACArgs, p.Type) } + + // Split the entry block if there are open defers, because later calls to + // openDeferSave may cause a mismatch between the mem for an OpDereference + // and the call site which uses it. See #49282. + if s.curBlock.ID == s.f.Entry.ID && s.hasOpenDefers { + b := s.endBlock() + b.Kind = ssa.BlockPlain + curb := s.f.NewBlock(ssa.BlockPlain) + b.AddEdgeTo(curb) + s.startBlock(curb) + } + for i, n := range args { callArgs = append(callArgs, s.putArg(n, t.Params().Field(i).Type)) } diff --git a/test/fixedbugs/issue49282.go b/test/fixedbugs/issue49282.go new file mode 100644 index 0000000000..7543075ca1 --- /dev/null +++ b/test/fixedbugs/issue49282.go @@ -0,0 +1,44 @@ +// 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 + +//go:noinline +func g(d uintptr, a, m []int, s struct { + a, b, c, d, e int +}, u uint) { + _ = a + _ = m + _ = s + func() { + for i := 0; i < 5; i++ { + _ = a + _ = m + _, _ = s, s + } + }() +} + +var One float64 = 1.0 + +func f(d uintptr) { + var a, m []int + var s struct { + a, b, c, d, e int + } + + g(d, a, m, s, uint(One)) // Uint of not-a-constant inserts a conditional, necessary to bug + + defer func() uint { + return 0 + }() +} + +var d uintptr + +func h() { + f(d) +} From 3544082f75fd3d2df7af237ed9aef3ddd499ab9c Mon Sep 17 00:00:00 2001 From: Roland Shoemaker Date: Fri, 1 Oct 2021 10:14:32 -0700 Subject: [PATCH 015/752] crypto/x509: verification with system and custom roots Make system cert pools special, such that when one has extra roots added to it we run verifications twice, once using the platform verifier, if available, and once using the Go verifier, merging the results. This change re-enables SystemCertPool on Windows, but explicitly does not return anything from CertPool.Subjects (which matches the behavior of macOS). CertPool.Subjects is also marked deprecated. Fixes #46287 Fixes #16736 Change-Id: Idc1843f715ae2b2d0108e55ab942c287181a340a Reviewed-on: https://go-review.googlesource.com/c/go/+/353589 Reviewed-by: Filippo Valsorda Trust: Roland Shoemaker --- src/crypto/x509/cert_pool.go | 27 ++++--- src/crypto/x509/hybrid_pool_test.go | 95 +++++++++++++++++++++++++ src/crypto/x509/root_darwin.go | 2 +- src/crypto/x509/root_windows.go | 48 ++----------- src/crypto/x509/root_windows_test.go | 102 +++++++++++++++++++++++++++ src/crypto/x509/verify.go | 17 ++++- 6 files changed, 229 insertions(+), 62 deletions(-) create mode 100644 src/crypto/x509/hybrid_pool_test.go create mode 100644 src/crypto/x509/root_windows_test.go diff --git a/src/crypto/x509/cert_pool.go b/src/crypto/x509/cert_pool.go index d760dc11c6..873ffeee1d 100644 --- a/src/crypto/x509/cert_pool.go +++ b/src/crypto/x509/cert_pool.go @@ -8,8 +8,6 @@ import ( "bytes" "crypto/sha256" "encoding/pem" - "errors" - "runtime" "sync" ) @@ -29,6 +27,12 @@ type CertPool struct { // call getCert and otherwise negate savings from lazy getCert // funcs). haveSum map[sum224]bool + + // systemPool indicates whether this is a special pool derived from the + // system roots. If it includes additional roots, it requires doing two + // verifications, one using the roots provided by the caller, and one using + // the system platform verifier. + systemPool bool } // lazyCert is minimal metadata about a Cert and a func to retrieve it @@ -75,9 +79,10 @@ func (s *CertPool) cert(n int) (*Certificate, error) { func (s *CertPool) copy() *CertPool { p := &CertPool{ - byName: make(map[string][]int, len(s.byName)), - lazyCerts: make([]lazyCert, len(s.lazyCerts)), - haveSum: make(map[sum224]bool, len(s.haveSum)), + byName: make(map[string][]int, len(s.byName)), + lazyCerts: make([]lazyCert, len(s.lazyCerts)), + haveSum: make(map[sum224]bool, len(s.haveSum)), + systemPool: s.systemPool, } for k, v := range s.byName { indexes := make([]int, len(v)) @@ -103,15 +108,6 @@ func (s *CertPool) copy() *CertPool { // // New changes in the system cert pool might not be reflected in subsequent calls. func SystemCertPool() (*CertPool, error) { - if runtime.GOOS == "windows" { - // Issue 16736, 18609: - return nil, errors.New("crypto/x509: system root pool is not available on Windows") - } else if runtime.GOOS == "darwin" { - return nil, errors.New("crypto/x509: system root pool is not available on macOS") - } else if runtime.GOOS == "ios" { - return nil, errors.New("crypto/x509: system root pool is not available on iOS") - } - if sysRoots := systemRootsPool(); sysRoots != nil { return sysRoots.copy(), nil } @@ -243,6 +239,9 @@ func (s *CertPool) AppendCertsFromPEM(pemCerts []byte) (ok bool) { // Subjects returns a list of the DER-encoded subjects of // all of the certificates in the pool. +// +// Deprecated: if s was returned by SystemCertPool, Subjects +// will not include the system roots. func (s *CertPool) Subjects() [][]byte { res := make([][]byte, s.len()) for i, lc := range s.lazyCerts { diff --git a/src/crypto/x509/hybrid_pool_test.go b/src/crypto/x509/hybrid_pool_test.go new file mode 100644 index 0000000000..d4dd9d5c22 --- /dev/null +++ b/src/crypto/x509/hybrid_pool_test.go @@ -0,0 +1,95 @@ +// 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 x509_test + +import ( + "crypto/ecdsa" + "crypto/elliptic" + "crypto/rand" + "crypto/tls" + "crypto/x509" + "crypto/x509/pkix" + "internal/testenv" + "math/big" + "runtime" + "testing" + "time" +) + +func TestHybridPool(t *testing.T) { + if !(runtime.GOOS == "windows" || runtime.GOOS == "darwin" || runtime.GOOS == "ios") { + t.Skipf("platform verifier not available on %s", runtime.GOOS) + } + if !testenv.HasExternalNetwork() { + t.Skip() + } + + // Get the google.com chain, which should be valid on all platforms we + // are testing + c, err := tls.Dial("tcp", "google.com:443", &tls.Config{InsecureSkipVerify: true}) + if err != nil { + t.Fatalf("tls connection failed: %s", err) + } + googChain := c.ConnectionState().PeerCertificates + + rootTmpl := &x509.Certificate{ + SerialNumber: big.NewInt(1), + Subject: pkix.Name{CommonName: "Go test root"}, + IsCA: true, + BasicConstraintsValid: true, + NotBefore: time.Now().Add(-time.Hour), + NotAfter: time.Now().Add(time.Hour * 10), + } + k, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) + if err != nil { + t.Fatalf("failed to generate test key: %s", err) + } + rootDER, err := x509.CreateCertificate(rand.Reader, rootTmpl, rootTmpl, k.Public(), k) + if err != nil { + t.Fatalf("failed to create test cert: %s", err) + } + root, err := x509.ParseCertificate(rootDER) + if err != nil { + t.Fatalf("failed to parse test cert: %s", err) + } + + pool, err := x509.SystemCertPool() + if err != nil { + t.Fatalf("SystemCertPool failed: %s", err) + } + opts := x509.VerifyOptions{Roots: pool} + + _, err = googChain[0].Verify(opts) + if err != nil { + t.Fatalf("verification failed for google.com chain (empty pool): %s", err) + } + + pool.AddCert(root) + + _, err = googChain[0].Verify(opts) + if err != nil { + t.Fatalf("verification failed for google.com chain (hybrid pool): %s", err) + } + + certTmpl := &x509.Certificate{ + SerialNumber: big.NewInt(1), + NotBefore: time.Now().Add(-time.Hour), + NotAfter: time.Now().Add(time.Hour * 10), + DNSNames: []string{"example.com"}, + } + certDER, err := x509.CreateCertificate(rand.Reader, certTmpl, rootTmpl, k.Public(), k) + if err != nil { + t.Fatalf("failed to create test cert: %s", err) + } + cert, err := x509.ParseCertificate(certDER) + if err != nil { + t.Fatalf("failed to parse test cert: %s", err) + } + + _, err = cert.Verify(opts) + if err != nil { + t.Fatalf("verification failed for custom chain (hybrid pool): %s", err) + } +} diff --git a/src/crypto/x509/root_darwin.go b/src/crypto/x509/root_darwin.go index 7bc6ce09fa..a7ff1e78bb 100644 --- a/src/crypto/x509/root_darwin.go +++ b/src/crypto/x509/root_darwin.go @@ -107,5 +107,5 @@ func exportCertificate(cert macOS.CFRef) (*Certificate, error) { } func loadSystemRoots() (*CertPool, error) { - return nil, nil + return &CertPool{systemPool: true}, nil } diff --git a/src/crypto/x509/root_windows.go b/src/crypto/x509/root_windows.go index f77ea3a698..d65d8768d9 100644 --- a/src/crypto/x509/root_windows.go +++ b/src/crypto/x509/root_windows.go @@ -10,6 +10,10 @@ import ( "unsafe" ) +func loadSystemRoots() (*CertPool, error) { + return &CertPool{systemPool: true}, nil +} + // Creates a new *syscall.CertContext representing the leaf certificate in an in-memory // certificate store containing itself and all of the intermediate certificates specified // in the opts.Intermediates CertPool. @@ -271,47 +275,3 @@ func (c *Certificate) systemVerify(opts *VerifyOptions) (chains [][]*Certificate return chains, nil } - -func loadSystemRoots() (*CertPool, error) { - // TODO: restore this functionality on Windows. We tried to do - // it in Go 1.8 but had to revert it. See Issue 18609. - // Returning (nil, nil) was the old behavior, prior to CL 30578. - // The if statement here avoids vet complaining about - // unreachable code below. - if true { - return nil, nil - } - - const CRYPT_E_NOT_FOUND = 0x80092004 - - store, err := syscall.CertOpenSystemStore(0, syscall.StringToUTF16Ptr("ROOT")) - if err != nil { - return nil, err - } - defer syscall.CertCloseStore(store, 0) - - roots := NewCertPool() - var cert *syscall.CertContext - for { - cert, err = syscall.CertEnumCertificatesInStore(store, cert) - if err != nil { - if errno, ok := err.(syscall.Errno); ok { - if errno == CRYPT_E_NOT_FOUND { - break - } - } - return nil, err - } - if cert == nil { - break - } - // Copy the buf, since ParseCertificate does not create its own copy. - buf := (*[1 << 20]byte)(unsafe.Pointer(cert.EncodedCert))[:cert.Length:cert.Length] - buf2 := make([]byte, cert.Length) - copy(buf2, buf) - if c, err := ParseCertificate(buf2); err == nil { - roots.AddCert(c) - } - } - return roots, nil -} diff --git a/src/crypto/x509/root_windows_test.go b/src/crypto/x509/root_windows_test.go new file mode 100644 index 0000000000..ce6d9273d9 --- /dev/null +++ b/src/crypto/x509/root_windows_test.go @@ -0,0 +1,102 @@ +// 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 x509_test + +import ( + "crypto/tls" + "crypto/x509" + "internal/testenv" + "testing" + "time" +) + +func TestPlatformVerifier(t *testing.T) { + if !testenv.HasExternalNetwork() { + t.Skip() + } + + getChain := func(host string) []*x509.Certificate { + t.Helper() + c, err := tls.Dial("tcp", host+":443", &tls.Config{InsecureSkipVerify: true}) + if err != nil { + t.Fatalf("tls connection failed: %s", err) + } + return c.ConnectionState().PeerCertificates + } + + tests := []struct { + name string + host string + verifyName string + verifyTime time.Time + expectedErr string + }{ + { + // whatever google.com serves should, hopefully, be trusted + name: "valid chain", + host: "google.com", + }, + { + name: "expired leaf", + host: "expired.badssl.com", + expectedErr: "x509: certificate has expired or is not yet valid: ", + }, + { + name: "wrong host for leaf", + host: "wrong.host.badssl.com", + verifyName: "wrong.host.badssl.com", + expectedErr: "x509: certificate is valid for *.badssl.com, badssl.com, not wrong.host.badssl.com", + }, + { + name: "self-signed leaf", + host: "self-signed.badssl.com", + expectedErr: "x509: certificate signed by unknown authority", + }, + { + name: "untrusted root", + host: "untrusted-root.badssl.com", + expectedErr: "x509: certificate signed by unknown authority", + }, + { + name: "expired leaf (custom time)", + host: "google.com", + verifyTime: time.Time{}.Add(time.Hour), + expectedErr: "x509: certificate has expired or is not yet valid: ", + }, + { + name: "valid chain (custom time)", + host: "google.com", + verifyTime: time.Now(), + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + chain := getChain(tc.host) + var opts x509.VerifyOptions + if len(chain) > 1 { + opts.Intermediates = x509.NewCertPool() + for _, c := range chain[1:] { + opts.Intermediates.AddCert(c) + } + } + if tc.verifyName != "" { + opts.DNSName = tc.verifyName + } + if !tc.verifyTime.IsZero() { + opts.CurrentTime = tc.verifyTime + } + + _, err := chain[0].Verify(opts) + if err != nil && tc.expectedErr == "" { + t.Errorf("unexpected verification error: %s", err) + } else if err != nil && err.Error() != tc.expectedErr { + t.Errorf("unexpected verification error: got %q, want %q", err.Error(), tc.expectedErr) + } else if err == nil && tc.expectedErr != "" { + t.Errorf("unexpected verification success: want %q", tc.expectedErr) + } + }) + } +} diff --git a/src/crypto/x509/verify.go b/src/crypto/x509/verify.go index 59852d9d68..1562ee57af 100644 --- a/src/crypto/x509/verify.go +++ b/src/crypto/x509/verify.go @@ -741,9 +741,20 @@ func (c *Certificate) Verify(opts VerifyOptions) (chains [][]*Certificate, err e } } - // Use platform verifiers, where available - if opts.Roots == nil && (runtime.GOOS == "windows" || runtime.GOOS == "darwin" || runtime.GOOS == "ios") { - return c.systemVerify(&opts) + // Use platform verifiers, where available, if Roots is from SystemCertPool. + if runtime.GOOS == "windows" || runtime.GOOS == "darwin" || runtime.GOOS == "ios" { + if opts.Roots == nil { + return c.systemVerify(&opts) + } + if opts.Roots != nil && opts.Roots.systemPool { + platformChains, err := c.systemVerify(&opts) + // If the platform verifier succeeded, or there are no additional + // roots, return the platform verifier result. Otherwise, continue + // with the Go verifier. + if err == nil || opts.Roots.len() == 0 { + return platformChains, err + } + } } if opts.Roots == nil { From 565f457e81a97f80412c9979fc3510c17849381e Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 4 Nov 2021 16:22:49 -0700 Subject: [PATCH 016/752] cmd/compile/internal/types2: always parse tests assuming generic code We don't need to distinguish anymore as this is the new default. This removes the need to prefix test package names with "generic_". Change-Id: If9eaa0a5cffcd19deb529aca6798206f2d396ca1 Reviewed-on: https://go-review.googlesource.com/c/go/+/361408 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Go Bot Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/api_test.go | 99 +++++++++---------- .../internal/types2/instantiate_test.go | 8 +- 2 files changed, 50 insertions(+), 57 deletions(-) diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go index 30cfbe0ee4..a59c9a4eee 100644 --- a/src/cmd/compile/internal/types2/api_test.go +++ b/src/cmd/compile/internal/types2/api_test.go @@ -17,21 +17,14 @@ import ( . "cmd/compile/internal/types2" ) -// genericPkg is a source prefix for packages that contain generic code. -const genericPkg = "package generic_" - // brokenPkg is a source prefix for packages that are not expected to parse // or type-check cleanly. They are always parsed assuming that they contain // generic code. const brokenPkg = "package broken_" func parseSrc(path, src string) (*syntax.File, error) { - var mode syntax.Mode - if strings.HasPrefix(src, genericPkg) || strings.HasPrefix(src, brokenPkg) { - mode = syntax.AllowGenerics - } errh := func(error) {} // dummy error handler so that parsing continues in presence of errors - return syntax.Parse(syntax.NewFileBase(path), strings.NewReader(src), errh, nil, mode) + return syntax.Parse(syntax.NewFileBase(path), strings.NewReader(src), errh, nil, syntax.AllowGenerics) } func pkgFor(path, source string, info *Info) (*Package, error) { @@ -326,25 +319,25 @@ func TestTypesInfo(t *testing.T) { {brokenPkg + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string]invalid type`}, // parameterized functions - {genericPkg + `p0; func f[T any](T) {}; var _ = f[int]`, `f`, `func[T interface{}](T)`}, - {genericPkg + `p1; func f[T any](T) {}; var _ = f[int]`, `f[int]`, `func(int)`}, - {genericPkg + `p2; func f[T any](T) {}; func _() { f(42) }`, `f`, `func(int)`}, - {genericPkg + `p3; func f[T any](T) {}; func _() { f[int](42) }`, `f[int]`, `func(int)`}, - {genericPkg + `p4; func f[T any](T) {}; func _() { f[int](42) }`, `f`, `func[T interface{}](T)`}, - {genericPkg + `p5; func f[T any](T) {}; func _() { f(42) }`, `f(42)`, `()`}, + {`package p0; func f[T any](T) {}; var _ = f[int]`, `f`, `func[T interface{}](T)`}, + {`package p1; func f[T any](T) {}; var _ = f[int]`, `f[int]`, `func(int)`}, + {`package p2; func f[T any](T) {}; func _() { f(42) }`, `f`, `func(int)`}, + {`package p3; func f[T any](T) {}; func _() { f[int](42) }`, `f[int]`, `func(int)`}, + {`package p4; func f[T any](T) {}; func _() { f[int](42) }`, `f`, `func[T interface{}](T)`}, + {`package p5; func f[T any](T) {}; func _() { f(42) }`, `f(42)`, `()`}, // type parameters - {genericPkg + `t0; type t[] int; var _ t`, `t`, `generic_t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t - {genericPkg + `t1; type t[P any] int; var _ t[int]`, `t`, `generic_t1.t[P interface{}]`}, - {genericPkg + `t2; type t[P interface{}] int; var _ t[int]`, `t`, `generic_t2.t[P interface{}]`}, - {genericPkg + `t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `generic_t3.t[P, Q interface{}]`}, + {`package t0; type t[] int; var _ t`, `t`, `t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t + {`package t1; type t[P any] int; var _ t[int]`, `t`, `t1.t[P interface{}]`}, + {`package t2; type t[P interface{}] int; var _ t[int]`, `t`, `t2.t[P interface{}]`}, + {`package t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `t3.t[P, Q interface{}]`}, {brokenPkg + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `broken_t4.t[P, Q interface{m()}]`}, // instantiated types must be sanitized - {genericPkg + `g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `generic_g0.t[int]`}, + {`package g0; type t[P any] int; var x struct{ f t[int] }; var _ = x.f`, `x.f`, `g0.t[int]`}, // issue 45096 - {genericPkg + `issue45096; func _[T interface{ ~int8 | ~int16 | ~int32 }](x T) { _ = x < 0 }`, `0`, `T`}, + {`package issue45096; func _[T interface{ ~int8 | ~int16 | ~int32 }](x T) { _ = x < 0 }`, `0`, `T`}, // issue 47895 {`package p; import "unsafe"; type S struct { f int }; var s S; var _ = unsafe.Offsetof(s.f)`, `s.f`, `int`}, @@ -391,138 +384,138 @@ func TestInstanceInfo(t *testing.T) { targs []string typ string }{ - {genericPkg + `p0; func f[T any](T) {}; func _() { f(42) }`, + {`package p0; func f[T any](T) {}; func _() { f(42) }`, `f`, []string{`int`}, `func(int)`, }, - {genericPkg + `p1; func f[T any](T) T { panic(0) }; func _() { f('@') }`, + {`package p1; func f[T any](T) T { panic(0) }; func _() { f('@') }`, `f`, []string{`rune`}, `func(rune) rune`, }, - {genericPkg + `p2; func f[T any](...T) T { panic(0) }; func _() { f(0i) }`, + {`package p2; func f[T any](...T) T { panic(0) }; func _() { f(0i) }`, `f`, []string{`complex128`}, `func(...complex128) complex128`, }, - {genericPkg + `p3; func f[A, B, C any](A, *B, []C) {}; func _() { f(1.2, new(string), []byte{}) }`, + {`package p3; func f[A, B, C any](A, *B, []C) {}; func _() { f(1.2, new(string), []byte{}) }`, `f`, []string{`float64`, `string`, `byte`}, `func(float64, *string, []byte)`, }, - {genericPkg + `p4; func f[A, B any](A, *B, ...[]B) {}; func _() { f(1.2, new(byte)) }`, + {`package p4; func f[A, B any](A, *B, ...[]B) {}; func _() { f(1.2, new(byte)) }`, `f`, []string{`float64`, `byte`}, `func(float64, *byte, ...[]byte)`, }, // we don't know how to translate these but we can type-check them - {genericPkg + `q0; type T struct{}; func (T) m[P any](P) {}; func _(x T) { x.m(42) }`, + {`package q0; type T struct{}; func (T) m[P any](P) {}; func _(x T) { x.m(42) }`, `m`, []string{`int`}, `func(int)`, }, - {genericPkg + `q1; type T struct{}; func (T) m[P any](P) P { panic(0) }; func _(x T) { x.m(42) }`, + {`package q1; type T struct{}; func (T) m[P any](P) P { panic(0) }; func _(x T) { x.m(42) }`, `m`, []string{`int`}, `func(int) int`, }, - {genericPkg + `q2; type T struct{}; func (T) m[P any](...P) P { panic(0) }; func _(x T) { x.m(42) }`, + {`package q2; type T struct{}; func (T) m[P any](...P) P { panic(0) }; func _(x T) { x.m(42) }`, `m`, []string{`int`}, `func(...int) int`, }, - {genericPkg + `q3; type T struct{}; func (T) m[A, B, C any](A, *B, []C) {}; func _(x T) { x.m(1.2, new(string), []byte{}) }`, + {`package q3; type T struct{}; func (T) m[A, B, C any](A, *B, []C) {}; func _(x T) { x.m(1.2, new(string), []byte{}) }`, `m`, []string{`float64`, `string`, `byte`}, `func(float64, *string, []byte)`, }, - {genericPkg + `q4; type T struct{}; func (T) m[A, B any](A, *B, ...[]B) {}; func _(x T) { x.m(1.2, new(byte)) }`, + {`package q4; type T struct{}; func (T) m[A, B any](A, *B, ...[]B) {}; func _(x T) { x.m(1.2, new(byte)) }`, `m`, []string{`float64`, `byte`}, `func(float64, *byte, ...[]byte)`, }, - {genericPkg + `r0; type T[P any] struct{}; func (_ T[P]) m[Q any](Q) {}; func _[P any](x T[P]) { x.m(42) }`, + {`package r0; type T[P any] struct{}; func (_ T[P]) m[Q any](Q) {}; func _[P any](x T[P]) { x.m(42) }`, `m`, []string{`int`}, `func(int)`, }, // TODO(gri) record method type parameters in syntax.FuncType so we can check this - // {genericPkg + `r1; type T interface{ m[P any](P) }; func _(x T) { x.m(4.2) }`, + // {`package r1; type T interface{ m[P any](P) }; func _(x T) { x.m(4.2) }`, // `x.m`, // []string{`float64`}, // `func(float64)`, // }, - {genericPkg + `s1; func f[T any, P interface{~*T}](x T) {}; func _(x string) { f(x) }`, + {`package s1; func f[T any, P interface{~*T}](x T) {}; func _(x string) { f(x) }`, `f`, []string{`string`, `*string`}, `func(x string)`, }, - {genericPkg + `s2; func f[T any, P interface{~*T}](x []T) {}; func _(x []int) { f(x) }`, + {`package s2; func f[T any, P interface{~*T}](x []T) {}; func _(x []int) { f(x) }`, `f`, []string{`int`, `*int`}, `func(x []int)`, }, - {genericPkg + `s3; type C[T any] interface{~chan<- T}; func f[T any, P C[T]](x []T) {}; func _(x []int) { f(x) }`, + {`package s3; type C[T any] interface{~chan<- T}; func f[T any, P C[T]](x []T) {}; func _(x []int) { f(x) }`, `f`, []string{`int`, `chan<- int`}, `func(x []int)`, }, - {genericPkg + `s4; type C[T any] interface{~chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T) {}; func _(x []int) { f(x) }`, + {`package s4; type C[T any] interface{~chan<- T}; func f[T any, P C[T], Q C[[]*P]](x []T) {}; func _(x []int) { f(x) }`, `f`, []string{`int`, `chan<- int`, `chan<- []*chan<- int`}, `func(x []int)`, }, - {genericPkg + `t1; func f[T any, P interface{~*T}]() T { panic(0) }; func _() { _ = f[string] }`, + {`package t1; func f[T any, P interface{~*T}]() T { panic(0) }; func _() { _ = f[string] }`, `f`, []string{`string`, `*string`}, `func() string`, }, - {genericPkg + `t2; func f[T any, P interface{~*T}]() T { panic(0) }; func _() { _ = (f[string]) }`, + {`package t2; func f[T any, P interface{~*T}]() T { panic(0) }; func _() { _ = (f[string]) }`, `f`, []string{`string`, `*string`}, `func() string`, }, - {genericPkg + `t3; type C[T any] interface{~chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T { return nil }; func _() { _ = f[int] }`, + {`package t3; type C[T any] interface{~chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T { return nil }; func _() { _ = f[int] }`, `f`, []string{`int`, `chan<- int`, `chan<- []*chan<- int`}, `func() []int`, }, - {genericPkg + `t4; type C[T any] interface{~chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T { return nil }; func _() { _ = f[int] }`, + {`package t4; type C[T any] interface{~chan<- T}; func f[T any, P C[T], Q C[[]*P]]() []T { return nil }; func _() { _ = f[int] }`, `f`, []string{`int`, `chan<- int`, `chan<- []*chan<- int`}, `func() []int`, }, - {genericPkg + `i0; import lib "generic_lib"; func _() { lib.F(42) }`, + {`package i0; import lib "generic_lib"; func _() { lib.F(42) }`, `F`, []string{`int`}, `func(int)`, }, - {genericPkg + `type0; type T[P interface{~int}] struct{ x P }; var _ T[int]`, + {`package type0; type T[P interface{~int}] struct{ x P }; var _ T[int]`, `T`, []string{`int`}, `struct{x int}`, }, - {genericPkg + `type1; type T[P interface{~int}] struct{ x P }; var _ (T[int])`, + {`package type1; type T[P interface{~int}] struct{ x P }; var _ (T[int])`, `T`, []string{`int`}, `struct{x int}`, }, - {genericPkg + `type2; type T[P interface{~int}] struct{ x P }; var _ T[(int)]`, + {`package type2; type T[P interface{~int}] struct{ x P }; var _ T[(int)]`, `T`, []string{`int`}, `struct{x int}`, }, - {genericPkg + `type3; type T[P1 interface{~[]P2}, P2 any] struct{ x P1; y P2 }; var _ T[[]int, int]`, + {`package type3; type T[P1 interface{~[]P2}, P2 any] struct{ x P1; y P2 }; var _ T[[]int, int]`, `T`, []string{`[]int`, `int`}, `struct{x []int; y int}`, }, - {genericPkg + `type4; import lib "generic_lib"; var _ lib.T[int]`, + {`package type4; import lib "generic_lib"; var _ lib.T[int]`, `T`, []string{`int`}, `[]int`, @@ -1958,7 +1951,7 @@ func f(x T) T { return foo.F(x) } func TestInstantiate(t *testing.T) { // eventually we like more tests but this is a start - const src = genericPkg + "p; type T[P any] *T[P]" + const src = "package p; type T[P any] *T[P]" pkg, err := pkgFor(".", src, nil) if err != nil { t.Fatal(err) @@ -1996,7 +1989,7 @@ func TestInstantiateErrors(t *testing.T) { } for _, test := range tests { - src := genericPkg + "p; " + test.src + src := "package p; " + test.src pkg, err := pkgFor(".", src, nil) if err != nil { t.Fatal(err) @@ -2031,11 +2024,11 @@ func TestInstanceIdentity(t *testing.T) { } imports[name] = pkg } - makePkg(genericPkg + `lib; type T[P any] struct{}`) - makePkg(genericPkg + `a; import "generic_lib"; var A generic_lib.T[int]`) - makePkg(genericPkg + `b; import "generic_lib"; var B generic_lib.T[int]`) - a := imports["generic_a"].Scope().Lookup("A") - b := imports["generic_b"].Scope().Lookup("B") + makePkg(`package lib; type T[P any] struct{}`) + makePkg(`package a; import "lib"; var A lib.T[int]`) + makePkg(`package b; import "lib"; var B lib.T[int]`) + a := imports["a"].Scope().Lookup("A") + b := imports["b"].Scope().Lookup("B") if !Identical(a.Type(), b.Type()) { t.Errorf("mismatching types: a.A: %s, b.B: %s", a.Type(), b.Type()) } diff --git a/src/cmd/compile/internal/types2/instantiate_test.go b/src/cmd/compile/internal/types2/instantiate_test.go index a99fc5d032..4f10dd929f 100644 --- a/src/cmd/compile/internal/types2/instantiate_test.go +++ b/src/cmd/compile/internal/types2/instantiate_test.go @@ -10,7 +10,7 @@ import ( ) func TestInstantiateEquality(t *testing.T) { - const src = genericPkg + "p; type T[P any] int" + const src = "package p; type T[P any] int" pkg, err := pkgFor(".", src, nil) if err != nil { t.Fatal(err) @@ -32,7 +32,7 @@ func TestInstantiateEquality(t *testing.T) { } } func TestInstantiateNonEquality(t *testing.T) { - const src = genericPkg + "p; type T[P any] int" + const src = "package p; type T[P any] int" pkg1, err := pkgFor(".", src, nil) if err != nil { t.Fatal(err) @@ -63,7 +63,7 @@ func TestInstantiateNonEquality(t *testing.T) { } func TestMethodInstantiation(t *testing.T) { - const prefix = genericPkg + `p + const prefix = `package p type T[P any] struct{} @@ -102,7 +102,7 @@ var X T[int] } func TestImmutableSignatures(t *testing.T) { - const src = genericPkg + `p + const src = `package p type T[P any] struct{} From 7ca772a5bc5d7f2a391f7f2a0febc54d84acb9d7 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 4 Nov 2021 16:00:34 -0700 Subject: [PATCH 017/752] cmd/compile/internal/types2: make object test an external test Change-Id: I15c969a799404067f34f600da15b1a97d4857315 Reviewed-on: https://go-review.googlesource.com/c/go/+/361409 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Go Bot Reviewed-by: Robert Findley --- .../compile/internal/types2/object_test.go | 21 ++++++++----------- 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/src/cmd/compile/internal/types2/object_test.go b/src/cmd/compile/internal/types2/object_test.go index ed3c123023..2fb57d2377 100644 --- a/src/cmd/compile/internal/types2/object_test.go +++ b/src/cmd/compile/internal/types2/object_test.go @@ -2,17 +2,14 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -package types2 +package types2_test import ( "cmd/compile/internal/syntax" - "strings" "testing" -) -func parseSrc(path, src string) (*syntax.File, error) { - return syntax.Parse(syntax.NewFileBase(path), strings.NewReader(src), nil, nil, 0) -} + . "cmd/compile/internal/types2" +) func TestIsAlias(t *testing.T) { check := func(obj *TypeName, want bool) { @@ -42,12 +39,12 @@ func TestIsAlias(t *testing.T) { {NewTypeName(nopos, nil, "t0", nil), false}, // no type yet {NewTypeName(nopos, pkg, "t0", nil), false}, // no type yet {t1, false}, // type name refers to named type and vice versa - {NewTypeName(nopos, nil, "t2", &emptyInterface), true}, // type name refers to unnamed type - {NewTypeName(nopos, pkg, "t3", n1), true}, // type name refers to named type with different type name - {NewTypeName(nopos, nil, "t4", Typ[Int32]), true}, // type name refers to basic type with different name - {NewTypeName(nopos, nil, "int32", Typ[Int32]), false}, // type name refers to basic type with same name - {NewTypeName(nopos, pkg, "int32", Typ[Int32]), true}, // type name is declared in user-defined package (outside Universe) - {NewTypeName(nopos, nil, "rune", Typ[Rune]), true}, // type name refers to basic type rune which is an alias already + {NewTypeName(nopos, nil, "t2", NewInterfaceType(nil, nil)), true}, // type name refers to unnamed type + {NewTypeName(nopos, pkg, "t3", n1), true}, // type name refers to named type with different type name + {NewTypeName(nopos, nil, "t4", Typ[Int32]), true}, // type name refers to basic type with different name + {NewTypeName(nopos, nil, "int32", Typ[Int32]), false}, // type name refers to basic type with same name + {NewTypeName(nopos, pkg, "int32", Typ[Int32]), true}, // type name is declared in user-defined package (outside Universe) + {NewTypeName(nopos, nil, "rune", Typ[Rune]), true}, // type name refers to basic type rune which is an alias already {t5, false}, // type name refers to type parameter and vice versa } { check(test.name, test.alias) From cfb3dc7710ba35d9932ba9f5242730a97f9ae603 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 4 Nov 2021 12:50:25 -0700 Subject: [PATCH 018/752] cmd/compile/internal/types2: clearer object string for type parameters - print "type parameter" rather than just "type" - print the type bound rather than the underlying type - added an object string test Change-Id: Ibb572ff35b74f2c6ccb27641154f096770541130 Reviewed-on: https://go-review.googlesource.com/c/go/+/361401 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Go Bot Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/object.go | 21 +++-- .../compile/internal/types2/object_test.go | 78 +++++++++++++++++++ .../internal/types2/typestring_test.go | 7 +- 3 files changed, 98 insertions(+), 8 deletions(-) diff --git a/src/cmd/compile/internal/types2/object.go b/src/cmd/compile/internal/types2/object.go index c7d6709c26..d86c166c72 100644 --- a/src/cmd/compile/internal/types2/object.go +++ b/src/cmd/compile/internal/types2/object.go @@ -458,6 +458,9 @@ func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) { case *TypeName: tname = obj buf.WriteString("type") + if isTypeParam(typ) { + buf.WriteString(" parameter") + } case *Var: if obj.isField { @@ -503,18 +506,22 @@ func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) { } if tname != nil { - // We have a type object: Don't print anything more for - // basic types since there's no more information (names - // are the same; see also comment in TypeName.IsAlias). - if _, ok := typ.(*Basic); ok { + switch t := typ.(type) { + case *Basic: + // Don't print anything more for basic types since there's + // no more information. return - } - if named, _ := typ.(*Named); named != nil && named.TypeParams().Len() > 0 { - newTypeWriter(buf, qf).tParamList(named.TypeParams().list()) + case *Named: + if t.TypeParams().Len() > 0 { + newTypeWriter(buf, qf).tParamList(t.TypeParams().list()) + } } if tname.IsAlias() { buf.WriteString(" =") + } else if t, _ := typ.(*TypeParam); t != nil { + typ = t.bound } else { + // TODO(gri) should this be fromRHS for *Named? typ = under(typ) } } diff --git a/src/cmd/compile/internal/types2/object_test.go b/src/cmd/compile/internal/types2/object_test.go index 2fb57d2377..93b3dfb44b 100644 --- a/src/cmd/compile/internal/types2/object_test.go +++ b/src/cmd/compile/internal/types2/object_test.go @@ -6,6 +6,8 @@ package types2_test import ( "cmd/compile/internal/syntax" + "internal/testenv" + "strings" "testing" . "cmd/compile/internal/types2" @@ -86,3 +88,79 @@ func TestEmbeddedMethod(t *testing.T) { t.Fatalf("%s (%p) != %s (%p)", orig, orig, embed, embed) } } + +var testObjects = []struct { + src string + obj string + want string +}{ + {"import \"io\"; var r io.Reader", "r", "var p.r io.Reader"}, + + {"const c = 1.2", "c", "const p.c untyped float"}, + {"const c float64 = 3.14", "c", "const p.c float64"}, + + {"type t struct{f int}", "t", "type p.t struct{f int}"}, + {"type t func(int)", "t", "type p.t func(int)"}, + {"type t[P any] struct{f P}", "t", "type p.t[P interface{}] struct{f P}"}, + {"type t[P any] struct{f P}", "t.P", "type parameter P interface{}"}, + {"type C interface{m()}; type t[P C] struct{}", "t.P", "type parameter P p.C"}, + + {"type t = struct{f int}", "t", "type p.t = struct{f int}"}, + {"type t = func(int)", "t", "type p.t = func(int)"}, + + {"var v int", "v", "var p.v int"}, + + {"func f(int) string", "f", "func p.f(int) string"}, + {"func g[P any](x P){}", "g", "func p.g[P interface{}](x P)"}, + {"func g[P interface{~int}](x P){}", "g.P", "type parameter P interface{~int}"}, +} + +func TestObjectString(t *testing.T) { + testenv.MustHaveGoBuild(t) + + for _, test := range testObjects { + src := "package p; " + test.src + pkg, err := makePkg(src) + if err != nil { + t.Errorf("%s: %s", src, err) + continue + } + + names := strings.Split(test.obj, ".") + if len(names) != 1 && len(names) != 2 { + t.Errorf("%s: invalid object path %s", test.src, test.obj) + continue + } + obj := pkg.Scope().Lookup(names[0]) + if obj == nil { + t.Errorf("%s: %s not found", test.src, names[0]) + continue + } + if len(names) == 2 { + if typ, ok := obj.Type().(interface{ TypeParams() *TypeParamList }); ok { + obj = lookupTypeParamObj(typ.TypeParams(), names[1]) + if obj == nil { + t.Errorf("%s: %s not found", test.src, test.obj) + continue + } + } else { + t.Errorf("%s: %s has no type parameters", test.src, names[0]) + continue + } + } + + if got := obj.String(); got != test.want { + t.Errorf("%s: got %s, want %s", test.src, got, test.want) + } + } +} + +func lookupTypeParamObj(list *TypeParamList, name string) Object { + for i := 0; i < list.Len(); i++ { + tpar := list.At(i) + if tpar.Obj().Name() == name { + return tpar.Obj() + } + } + return nil +} diff --git a/src/cmd/compile/internal/types2/typestring_test.go b/src/cmd/compile/internal/types2/typestring_test.go index 0ed2934961..eda6835588 100644 --- a/src/cmd/compile/internal/types2/typestring_test.go +++ b/src/cmd/compile/internal/types2/typestring_test.go @@ -129,7 +129,12 @@ func TestTypeString(t *testing.T) { t.Errorf("%s: %s", src, err) continue } - typ := pkg.Scope().Lookup("T").Type().Underlying() + obj := pkg.Scope().Lookup("T") + if obj == nil { + t.Errorf("%s: T not found", test.src) + continue + } + typ := obj.Type().Underlying() if got := typ.String(); got != test.str { t.Errorf("%s: got %s, want %s", test.src, got, test.str) } From 61d789db3a52e4570596f1fd15122358deb73b77 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 4 Nov 2021 21:31:08 -0700 Subject: [PATCH 019/752] cmd/compile/internal/types2: report error for incomplete struct composite literal type Mark a struct as "complete" with a non-nil (but possibly zero length) fields list. Add a test when type-checking struct composite literals, the same way we do for other composite literal types. Fixes #49276. Change-Id: If44a3d790bf7032ddcd155af49bdc47b1cdff4fc Reviewed-on: https://go-review.googlesource.com/c/go/+/361412 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Go Bot Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/expr.go | 6 +++ src/cmd/compile/internal/types2/struct.go | 14 +++++- src/cmd/compile/internal/types2/subst.go | 4 +- .../types2/testdata/fixedbugs/issue49276.go | 46 +++++++++++++++++++ 4 files changed, 67 insertions(+), 3 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue49276.go diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index 95b96f2334..d618ebd372 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -1260,6 +1260,12 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin switch utyp := structure(base).(type) { case *Struct: + // Prevent crash if the struct referred to is not yet set up. + // See analogous comment for *Array. + if utyp.fields == nil { + check.error(e, "illegal cycle in type declaration") + goto Error + } if len(e.ElemList) == 0 { break } diff --git a/src/cmd/compile/internal/types2/struct.go b/src/cmd/compile/internal/types2/struct.go index 933d7ef947..8c39f5e3c4 100644 --- a/src/cmd/compile/internal/types2/struct.go +++ b/src/cmd/compile/internal/types2/struct.go @@ -14,7 +14,7 @@ import ( // A Struct represents a struct type. type Struct struct { - fields []*Var + fields []*Var // fields != nil indicates the struct is set up (possibly with len(fields) == 0) tags []string // field tags; nil if there are no tags } @@ -32,7 +32,9 @@ func NewStruct(fields []*Var, tags []string) *Struct { if len(tags) > len(fields) { panic("more tags than fields") } - return &Struct{fields: fields, tags: tags} + s := &Struct{fields: fields, tags: tags} + s.markComplete() + return s } // NumFields returns the number of fields in the struct (including blank and embedded fields). @@ -55,8 +57,15 @@ func (s *Struct) String() string { return TypeString(s, nil) } // ---------------------------------------------------------------------------- // Implementation +func (s *Struct) markComplete() { + if s.fields == nil { + s.fields = make([]*Var, 0) + } +} + func (check *Checker) structType(styp *Struct, e *syntax.StructType) { if e.FieldList == nil { + styp.markComplete() return } @@ -160,6 +169,7 @@ func (check *Checker) structType(styp *Struct, e *syntax.StructType) { styp.fields = fields styp.tags = tags + styp.markComplete() } func embeddedFieldIdent(e syntax.Expr) *syntax.Name { diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go index 269b284ac4..a4e46b2097 100644 --- a/src/cmd/compile/internal/types2/subst.go +++ b/src/cmd/compile/internal/types2/subst.go @@ -91,7 +91,9 @@ func (subst *subster) typ(typ Type) Type { case *Struct: if fields, copied := subst.varList(t.fields); copied { - return &Struct{fields: fields, tags: t.tags} + s := &Struct{fields: fields, tags: t.tags} + s.markComplete() + return s } case *Pointer: diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49276.go b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49276.go new file mode 100644 index 0000000000..8839087b50 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49276.go @@ -0,0 +1,46 @@ +// 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 "unsafe" + +type S /* ERROR illegal cycle in declaration of S */ struct { + _ [unsafe.Sizeof(s)]byte +} + +var s S + +// Since f is a pointer, this case could be valid. +// But it's pathological and not worth the expense. +type T struct { + f *[unsafe.Sizeof(T /* ERROR illegal cycle in type declaration */ {})]int +} + +// a mutually recursive case using unsafe.Sizeof +type ( + A1 struct { + _ [unsafe.Sizeof(B1{})]int + } + + B1 struct { + _ [unsafe.Sizeof(A1 /* ERROR illegal cycle in type declaration */ {})]int + } +) + +// a mutually recursive case using len +type ( + A2 struct { + f [len(B2{}.f)]int + } + + B2 struct { + f [len(A2 /* ERROR illegal cycle in type declaration */ {}.f)]int + } +) + +// test case from issue +type a struct { + _ [42 - unsafe.Sizeof(a /* ERROR illegal cycle in type declaration */ {})]byte +} From 85493d53e3bffbd08de3a97672a5a6f10b4901a8 Mon Sep 17 00:00:00 2001 From: Arran Walker Date: Thu, 21 Oct 2021 10:39:05 +0100 Subject: [PATCH 020/752] archive/zip: don't read data descriptor early Go 1.17 introduced an unnecessary change to when a zip's data descriptor is read for file entries, how it is parsed and how the crc32 field is used. Before Go 1.17, the data descriptor was read immediately after a file entry's content. This continuous read is a pattern existing applications have come to rely upon (for example, where reads at specific offsets might be translated to HTTP range requests). In Go 1.17, all data descriptors are immediately read upon opening the file. This results in scattered and non-continuous reads of the archive, and depending on the underlying reader, might have severe performance implications. In addition, an additional object is now initialized for each entry, but is mostly redundant. Previously, the crc32 field in the data descriptor would return an error if it did not match the central directory's entry. This check has seemingly been unintentionally removed. If the central directory crc32 is invalid and a data descriptor is present, no error is returned. This change reverts to the previous handling of data descriptors, before CL 312310. Fixes #48374 Fixes #49089 Change-Id: I5df2878c4fcc9e500064e7175f3ab9727c82f100 Reviewed-on: https://go-review.googlesource.com/c/go/+/357489 Run-TryBot: Ian Lance Taylor Reviewed-by: Ian Lance Taylor Trust: Dmitri Shuralyov --- src/archive/zip/reader.go | 96 ++++++++------------------ src/archive/zip/reader_test.go | 122 --------------------------------- src/archive/zip/struct.go | 8 --- 3 files changed, 28 insertions(+), 198 deletions(-) diff --git a/src/archive/zip/reader.go b/src/archive/zip/reader.go index e40a2c656b..2843a5d658 100644 --- a/src/archive/zip/reader.go +++ b/src/archive/zip/reader.go @@ -125,7 +125,6 @@ func (z *Reader) init(r io.ReaderAt, size int64) error { if err != nil { return err } - f.readDataDescriptor() z.File = append(z.File, f) } if uint16(len(z.File)) != uint16(end.directoryRecords) { // only compare 16 bits here @@ -186,10 +185,15 @@ func (f *File) Open() (io.ReadCloser, error) { return nil, ErrAlgorithm } var rc io.ReadCloser = dcomp(r) + var desr io.Reader + if f.hasDataDescriptor() { + desr = io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset+size, dataDescriptorLen) + } rc = &checksumReader{ rc: rc, hash: crc32.NewIEEE(), f: f, + desr: desr, } return rc, nil } @@ -205,49 +209,13 @@ func (f *File) OpenRaw() (io.Reader, error) { return r, nil } -func (f *File) readDataDescriptor() { - if !f.hasDataDescriptor() { - return - } - - bodyOffset, err := f.findBodyOffset() - if err != nil { - f.descErr = err - return - } - - // In section 4.3.9.2 of the spec: "However ZIP64 format MAY be used - // regardless of the size of a file. When extracting, if the zip64 - // extended information extra field is present for the file the - // compressed and uncompressed sizes will be 8 byte values." - // - // Historically, this package has used the compressed and uncompressed - // sizes from the central directory to determine if the package is - // zip64. - // - // For this case we allow either the extra field or sizes to determine - // the data descriptor length. - zip64 := f.zip64 || f.isZip64() - n := int64(dataDescriptorLen) - if zip64 { - n = dataDescriptor64Len - } - size := int64(f.CompressedSize64) - r := io.NewSectionReader(f.zipr, f.headerOffset+bodyOffset+size, n) - dd, err := readDataDescriptor(r, zip64) - if err != nil { - f.descErr = err - return - } - f.CRC32 = dd.crc32 -} - type checksumReader struct { rc io.ReadCloser hash hash.Hash32 nread uint64 // number of bytes read so far f *File - err error // sticky error + desr io.Reader // if non-nil, where to read the data descriptor + err error // sticky error } func (r *checksumReader) Stat() (fs.FileInfo, error) { @@ -268,12 +236,12 @@ func (r *checksumReader) Read(b []byte) (n int, err error) { if r.nread != r.f.UncompressedSize64 { return 0, io.ErrUnexpectedEOF } - if r.f.hasDataDescriptor() { - if r.f.descErr != nil { - if r.f.descErr == io.EOF { + if r.desr != nil { + if err1 := readDataDescriptor(r.desr, r.f); err1 != nil { + if err1 == io.EOF { err = io.ErrUnexpectedEOF } else { - err = r.f.descErr + err = err1 } } else if r.hash.Sum32() != r.f.CRC32 { err = ErrChecksum @@ -485,10 +453,8 @@ parseExtras: return nil } -func readDataDescriptor(r io.Reader, zip64 bool) (*dataDescriptor, error) { - // Create enough space for the largest possible size - var buf [dataDescriptor64Len]byte - +func readDataDescriptor(r io.Reader, f *File) error { + var buf [dataDescriptorLen]byte // The spec says: "Although not originally assigned a // signature, the value 0x08074b50 has commonly been adopted // as a signature value for the data descriptor record. @@ -497,9 +463,10 @@ func readDataDescriptor(r io.Reader, zip64 bool) (*dataDescriptor, error) { // descriptors and should account for either case when reading // ZIP files to ensure compatibility." // - // First read just those 4 bytes to see if the signature exists. + // dataDescriptorLen includes the size of the signature but + // first read just those 4 bytes to see if it exists. if _, err := io.ReadFull(r, buf[:4]); err != nil { - return nil, err + return err } off := 0 maybeSig := readBuf(buf[:4]) @@ -508,28 +475,21 @@ func readDataDescriptor(r io.Reader, zip64 bool) (*dataDescriptor, error) { // bytes. off += 4 } - - end := dataDescriptorLen - 4 - if zip64 { - end = dataDescriptor64Len - 4 + if _, err := io.ReadFull(r, buf[off:12]); err != nil { + return err } - if _, err := io.ReadFull(r, buf[off:end]); err != nil { - return nil, err - } - b := readBuf(buf[:end]) - - out := &dataDescriptor{ - crc32: b.uint32(), + b := readBuf(buf[:12]) + if b.uint32() != f.CRC32 { + return ErrChecksum } - if zip64 { - out.compressedSize = b.uint64() - out.uncompressedSize = b.uint64() - } else { - out.compressedSize = uint64(b.uint32()) - out.uncompressedSize = uint64(b.uint32()) - } - return out, nil + // The two sizes that follow here can be either 32 bits or 64 bits + // but the spec is not very clear on this and different + // interpretations has been made causing incompatibilities. We + // already have the sizes from the central directory so we can + // just ignore these. + + return nil } func readDirectoryEnd(r io.ReaderAt, size int64) (dir *directoryEnd, err error) { diff --git a/src/archive/zip/reader_test.go b/src/archive/zip/reader_test.go index a54915316c..d1a9bdd334 100644 --- a/src/archive/zip/reader_test.go +++ b/src/archive/zip/reader_test.go @@ -1214,128 +1214,6 @@ func TestCVE202127919(t *testing.T) { } } -func TestReadDataDescriptor(t *testing.T) { - tests := []struct { - desc string - in []byte - zip64 bool - want *dataDescriptor - wantErr error - }{{ - desc: "valid 32 bit with signature", - in: []byte{ - 0x50, 0x4b, 0x07, 0x08, // signature - 0x00, 0x01, 0x02, 0x03, // crc32 - 0x04, 0x05, 0x06, 0x07, // compressed size - 0x08, 0x09, 0x0a, 0x0b, // uncompressed size - }, - want: &dataDescriptor{ - crc32: 0x03020100, - compressedSize: 0x07060504, - uncompressedSize: 0x0b0a0908, - }, - }, { - desc: "valid 32 bit without signature", - in: []byte{ - 0x00, 0x01, 0x02, 0x03, // crc32 - 0x04, 0x05, 0x06, 0x07, // compressed size - 0x08, 0x09, 0x0a, 0x0b, // uncompressed size - }, - want: &dataDescriptor{ - crc32: 0x03020100, - compressedSize: 0x07060504, - uncompressedSize: 0x0b0a0908, - }, - }, { - desc: "valid 64 bit with signature", - in: []byte{ - 0x50, 0x4b, 0x07, 0x08, // signature - 0x00, 0x01, 0x02, 0x03, // crc32 - 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size - 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, // uncompressed size - }, - zip64: true, - want: &dataDescriptor{ - crc32: 0x03020100, - compressedSize: 0x0b0a090807060504, - uncompressedSize: 0x131211100f0e0d0c, - }, - }, { - desc: "valid 64 bit without signature", - in: []byte{ - 0x00, 0x01, 0x02, 0x03, // crc32 - 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size - 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, // uncompressed size - }, - zip64: true, - want: &dataDescriptor{ - crc32: 0x03020100, - compressedSize: 0x0b0a090807060504, - uncompressedSize: 0x131211100f0e0d0c, - }, - }, { - desc: "invalid 32 bit with signature", - in: []byte{ - 0x50, 0x4b, 0x07, 0x08, // signature - 0x00, 0x01, 0x02, 0x03, // crc32 - 0x04, 0x05, // unexpected end - }, - wantErr: io.ErrUnexpectedEOF, - }, { - desc: "invalid 32 bit without signature", - in: []byte{ - 0x00, 0x01, 0x02, 0x03, // crc32 - 0x04, 0x05, // unexpected end - }, - wantErr: io.ErrUnexpectedEOF, - }, { - desc: "invalid 64 bit with signature", - in: []byte{ - 0x50, 0x4b, 0x07, 0x08, // signature - 0x00, 0x01, 0x02, 0x03, // crc32 - 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size - 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, // unexpected end - }, - zip64: true, - wantErr: io.ErrUnexpectedEOF, - }, { - desc: "invalid 64 bit without signature", - in: []byte{ - 0x00, 0x01, 0x02, 0x03, // crc32 - 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, // compressed size - 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, // unexpected end - }, - zip64: true, - wantErr: io.ErrUnexpectedEOF, - }} - - for _, test := range tests { - t.Run(test.desc, func(t *testing.T) { - r := bytes.NewReader(test.in) - - desc, err := readDataDescriptor(r, test.zip64) - if err != test.wantErr { - t.Fatalf("got err %v; want nil", err) - } - if test.want == nil { - return - } - if desc == nil { - t.Fatalf("got nil DataDescriptor; want non-nil") - } - if desc.crc32 != test.want.crc32 { - t.Errorf("got CRC32 %#x; want %#x", desc.crc32, test.want.crc32) - } - if desc.compressedSize != test.want.compressedSize { - t.Errorf("got CompressedSize %#x; want %#x", desc.compressedSize, test.want.compressedSize) - } - if desc.uncompressedSize != test.want.uncompressedSize { - t.Errorf("got UncompressedSize %#x; want %#x", desc.uncompressedSize, test.want.uncompressedSize) - } - }) - } -} - func TestCVE202133196(t *testing.T) { // Archive that indicates it has 1 << 128 -1 files, // this would previously cause a panic due to attempting diff --git a/src/archive/zip/struct.go b/src/archive/zip/struct.go index ff9f605eb6..88effedc0f 100644 --- a/src/archive/zip/struct.go +++ b/src/archive/zip/struct.go @@ -390,11 +390,3 @@ func unixModeToFileMode(m uint32) fs.FileMode { } return mode } - -// dataDescriptor holds the data descriptor that optionally follows the file -// contents in the zip file. -type dataDescriptor struct { - crc32 uint32 - compressedSize uint64 - uncompressedSize uint64 -} From 9e6ad46bccfa7a63e768236bcd1fd54dab38e4d1 Mon Sep 17 00:00:00 2001 From: jiahua wang Date: Fri, 8 Oct 2021 09:59:15 +0800 Subject: [PATCH 021/752] net/http: fix spelling in documentation Change-Id: I8b0924300eafe27de98975512a78a6527a92e446 Reviewed-on: https://go-review.googlesource.com/c/go/+/354729 Reviewed-by: Ian Lance Taylor Trust: Damien Neil --- src/net/http/httputil/dump.go | 2 +- src/net/http/serve_test.go | 2 +- src/net/http/transfer.go | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/net/http/httputil/dump.go b/src/net/http/httputil/dump.go index 2948f27e5d..d7baecd9c1 100644 --- a/src/net/http/httputil/dump.go +++ b/src/net/http/httputil/dump.go @@ -292,7 +292,7 @@ func DumpRequest(req *http.Request, body bool) ([]byte, error) { // can detect that the lack of body was intentional. var errNoBody = errors.New("sentinel error value") -// failureToReadBody is a io.ReadCloser that just returns errNoBody on +// failureToReadBody is an io.ReadCloser that just returns errNoBody on // Read. It's swapped in when we don't actually want to consume // the body, but need a non-nil one, and want to distinguish the // error from reading the dummy body. diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go index e8fb77446c..27dff2bf45 100644 --- a/src/net/http/serve_test.go +++ b/src/net/http/serve_test.go @@ -6557,7 +6557,7 @@ func TestDisableKeepAliveUpgrade(t *testing.T) { rwc, ok := resp.Body.(io.ReadWriteCloser) if !ok { - t.Fatalf("Response.Body is not a io.ReadWriteCloser: %T", resp.Body) + t.Fatalf("Response.Body is not an io.ReadWriteCloser: %T", resp.Body) } _, err = rwc.Write([]byte("hello")) diff --git a/src/net/http/transfer.go b/src/net/http/transfer.go index 5ff89cc17f..2be1c9fa3c 100644 --- a/src/net/http/transfer.go +++ b/src/net/http/transfer.go @@ -1030,7 +1030,7 @@ func (b *body) registerOnHitEOF(fn func()) { b.onHitEOF = fn } -// bodyLocked is a io.Reader reading from a *body when its mutex is +// bodyLocked is an io.Reader reading from a *body when its mutex is // already held. type bodyLocked struct { b *body From ab31dbc05b725135ca5f6fd4337a041d8433f153 Mon Sep 17 00:00:00 2001 From: smasher164 Date: Sat, 6 Nov 2021 02:59:00 -0400 Subject: [PATCH 022/752] doc/go1.18: strings,bytes: deprecate Title Updates #48367. Change-Id: Ib8fc6d9dd7c3c6a70fefe077615f51a71d9c42ed Reviewed-on: https://go-review.googlesource.com/c/go/+/361899 Reviewed-by: Ian Lance Taylor Trust: Dmitri Shuralyov --- doc/go1.18.html | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index b86e907874..44c56444fc 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -214,6 +214,12 @@ Do not send CLs removing the interior tags from such phrases.

TODO: https://golang.org/cl/332771: avoid allocations in Trim/TrimLeft/TrimRight

+ +

+ The Title function is now deprecated. It doesn't + handle Unicode punctuation and language-specific capitalization rules, and is superseded by the + golang.org/x/text/cases package. +

@@ -342,6 +348,12 @@ Do not send CLs removing the interior tags from such phrases.

TODO: https://golang.org/cl/332771: avoid allocations in Trim/TrimLeft/TrimRight

+ +

+ The Title function is now deprecated. It doesn't + handle Unicode punctuation and language-specific capitalization rules, and is superseded by the + golang.org/x/text/cases package. +

From 3e41b18a46ea0cf033be4d9baa2d99f7c8c985dc Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 4 Nov 2021 20:00:51 -0700 Subject: [PATCH 023/752] cmd/compile/internal/types2: use compiler version error when configured for compiler Fixes #49368. Change-Id: I7c7575ae8bb6271160747e3f1888b144c3ab24c4 Reviewed-on: https://go-review.googlesource.com/c/go/+/361411 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/builtins.go | 4 ++-- src/cmd/compile/internal/types2/call.go | 6 +++--- src/cmd/compile/internal/types2/conversions.go | 7 +++---- src/cmd/compile/internal/types2/decl.go | 8 ++------ src/cmd/compile/internal/types2/errors.go | 10 ++++++++++ src/cmd/compile/internal/types2/expr.go | 2 +- src/cmd/compile/internal/types2/typeset.go | 6 +++--- src/cmd/compile/internal/types2/typexpr.go | 2 +- src/cmd/compile/internal/types2/version.go | 8 ++++---- src/cmd/go/testdata/script/mod_edit_go.txt | 4 ++-- test/fixedbugs/issue49368.go | 11 +++++++++++ 11 files changed, 42 insertions(+), 26 deletions(-) create mode 100644 test/fixedbugs/issue49368.go diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go index 548d55e10c..ade4c0a49f 100644 --- a/src/cmd/compile/internal/types2/builtins.go +++ b/src/cmd/compile/internal/types2/builtins.go @@ -574,7 +574,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( case _Add: // unsafe.Add(ptr unsafe.Pointer, len IntegerType) unsafe.Pointer if !check.allowVersion(check.pkg, 1, 17) { - check.error(call.Fun, "unsafe.Add requires go1.17 or later") + check.versionErrorf(call.Fun, "go1.17", "unsafe.Add") return } @@ -700,7 +700,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( case _Slice: // unsafe.Slice(ptr *T, len IntegerType) []T if !check.allowVersion(check.pkg, 1, 17) { - check.error(call.Fun, "unsafe.Slice requires go1.17 or later") + check.versionErrorf(call.Fun, "go1.17", "unsafe.Slice") return } diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go index 49cae5a930..74edd4d442 100644 --- a/src/cmd/compile/internal/types2/call.go +++ b/src/cmd/compile/internal/types2/call.go @@ -16,7 +16,7 @@ import ( // The operand x must be the evaluation of inst.X and its type must be a signature. func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) { if !check.allowVersion(check.pkg, 1, 18) { - check.softErrorf(inst.Pos(), "function instantiation requires go1.18 or later") + check.versionErrorf(inst.Pos(), "go1.18", "function instantiation") } xlist := unpackExpr(inst.Index) @@ -363,9 +363,9 @@ func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, targs []T if sig.TypeParams().Len() > 0 { if !check.allowVersion(check.pkg, 1, 18) { if iexpr, _ := call.Fun.(*syntax.IndexExpr); iexpr != nil { - check.softErrorf(iexpr.Pos(), "function instantiation requires go1.18 or later") + check.versionErrorf(iexpr.Pos(), "go1.18", "function instantiation") } else { - check.softErrorf(call.Pos(), "implicit function instantiation requires go1.18 or later") + check.versionErrorf(call.Pos(), "go1.18", "implicit function instantiation") } } // TODO(gri) provide position information for targs so we can feed diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go index 44e8aad84f..ccabbaf0d7 100644 --- a/src/cmd/compile/internal/types2/conversions.go +++ b/src/cmd/compile/internal/types2/conversions.go @@ -7,6 +7,7 @@ package types2 import ( + "fmt" "go/constant" "unicode" ) @@ -181,11 +182,9 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { } // check != nil if cause != nil { + *cause = "conversion of slices to array pointers requires go1.17 or later" if check.conf.CompilerErrorMessages { - // compiler error message assumes a -lang flag - *cause = "conversion of slices to array pointers only supported as of -lang=go1.17" - } else { - *cause = "conversion of slices to array pointers requires go1.17 or later" + *cause += fmt.Sprintf(" (-lang was set to %s; check go.mod)", check.conf.GoVersion) } } return false diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index 5d2a6c531b..5219f7e7c5 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -555,7 +555,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named check.validType(obj.typ, nil) // If typ is local, an error was already reported where typ is specified/defined. if check.isImportedConstraint(rhs) && !check.allowVersion(check.pkg, 1, 18) { - check.errorf(tdecl.Type.Pos(), "using type constraint %s requires go1.18 or later", rhs) + check.versionErrorf(tdecl.Type.Pos(), "go1.18", "using type constraint %s", rhs) } }).describef(obj, "validType(%s)", obj.Name()) @@ -570,11 +570,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named // alias declaration if alias { if !check.allowVersion(check.pkg, 1, 9) { - if check.conf.CompilerErrorMessages { - check.error(tdecl, "type aliases only supported as of -lang=go1.9") - } else { - check.error(tdecl, "type aliases requires go1.9 or later") - } + check.versionErrorf(tdecl, "go1.9", "type aliases") } obj.typ = Typ[Invalid] diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go index b56d11a28b..c39652fe5e 100644 --- a/src/cmd/compile/internal/types2/errors.go +++ b/src/cmd/compile/internal/types2/errors.go @@ -230,6 +230,16 @@ func (check *Checker) softErrorf(at poser, format string, args ...interface{}) { check.err(at, check.sprintf(format, args...), true) } +func (check *Checker) versionErrorf(at poser, goVersion string, format string, args ...interface{}) { + msg := check.sprintf(format, args...) + if check.conf.CompilerErrorMessages { + msg = fmt.Sprintf("%s requires %s or later (-lang was set to %s; check go.mod)", msg, goVersion, check.conf.GoVersion) + } else { + msg = fmt.Sprintf("%s requires %s or later", msg, goVersion) + } + check.err(at, msg, true) +} + // posFor reports the left (= start) position of at. func posFor(at poser) syntax.Pos { switch x := at.(type) { diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index d618ebd372..d24532d780 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -869,7 +869,7 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) { x.mode = invalid return } else if !allUnsigned(y.typ) && !check.allowVersion(check.pkg, 1, 13) { - check.errorf(y, invalidOp+"signed shift count %s requires go1.13 or later", y) + check.versionErrorf(y, "go1.13", invalidOp+"signed shift count %s", y) x.mode = invalid return } diff --git a/src/cmd/compile/internal/types2/typeset.go b/src/cmd/compile/internal/types2/typeset.go index 445a62f9e0..c37a20e73e 100644 --- a/src/cmd/compile/internal/types2/typeset.go +++ b/src/cmd/compile/internal/types2/typeset.go @@ -271,7 +271,7 @@ func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *_ tset := computeInterfaceTypeSet(check, pos, u) // If typ is local, an error was already reported where typ is specified/defined. if check != nil && check.isImportedConstraint(typ) && !check.allowVersion(check.pkg, 1, 18) { - check.errorf(pos, "embedding constraint interface %s requires go1.18 or later", typ) + check.versionErrorf(pos, "go1.18", "embedding constraint interface %s", typ) continue } if tset.comparable { @@ -283,7 +283,7 @@ func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *_ terms = tset.terms case *Union: if check != nil && !check.allowVersion(check.pkg, 1, 18) { - check.errorf(pos, "embedding interface element %s requires go1.18 or later", u) + check.versionErrorf(pos, "go1.18", "embedding interface element %s", u) continue } tset := computeUnionTypeSet(check, pos, u) @@ -300,7 +300,7 @@ func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *_ continue } if check != nil && !check.allowVersion(check.pkg, 1, 18) { - check.errorf(pos, "embedding non-interface type %s requires go1.18 or later", typ) + check.versionErrorf(pos, "go1.18", "embedding non-interface type %s", typ) continue } terms = termlist{{false, typ}} diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go index 95893fd1e1..dcd7cfebe8 100644 --- a/src/cmd/compile/internal/types2/typexpr.go +++ b/src/cmd/compile/internal/types2/typexpr.go @@ -264,7 +264,7 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) { case *syntax.IndexExpr: if !check.allowVersion(check.pkg, 1, 18) { - check.softErrorf(e.Pos(), "type instantiation requires go1.18 or later") + check.versionErrorf(e.Pos(), "go1.18", "type instantiation") } return check.instantiatedType(e.X, unpackExpr(e.Index), def) diff --git a/src/cmd/compile/internal/types2/version.go b/src/cmd/compile/internal/types2/version.go index d9d18b6f7a..b649f09c3a 100644 --- a/src/cmd/compile/internal/types2/version.go +++ b/src/cmd/compile/internal/types2/version.go @@ -21,7 +21,7 @@ func (check *Checker) langCompat(lit *syntax.BasicLit) { } // len(s) > 2 if strings.Contains(s, "_") { - check.error(lit, "underscores in numeric literals requires go1.13 or later") + check.versionErrorf(lit, "go1.13", "underscores in numeric literals") return } if s[0] != '0' { @@ -29,15 +29,15 @@ func (check *Checker) langCompat(lit *syntax.BasicLit) { } radix := s[1] if radix == 'b' || radix == 'B' { - check.error(lit, "binary literals requires go1.13 or later") + check.versionErrorf(lit, "go1.13", "binary literals") return } if radix == 'o' || radix == 'O' { - check.error(lit, "0o/0O-style octal literals requires go1.13 or later") + check.versionErrorf(lit, "go1.13", "0o/0O-style octal literals") return } if lit.Kind != syntax.IntLit && (radix == 'x' || radix == 'X') { - check.error(lit, "hexadecimal floating-point literals requires go1.13 or later") + check.versionErrorf(lit, "go1.13", "hexadecimal floating-point literals") } } diff --git a/src/cmd/go/testdata/script/mod_edit_go.txt b/src/cmd/go/testdata/script/mod_edit_go.txt index 38321d071f..7e9740fec4 100644 --- a/src/cmd/go/testdata/script/mod_edit_go.txt +++ b/src/cmd/go/testdata/script/mod_edit_go.txt @@ -2,7 +2,7 @@ env GO111MODULE=on ! go build -stderr 'type aliases only supported as of' +stderr ' type aliases requires' go mod edit -go=1.9 grep 'go 1.9' go.mod go build @@ -11,7 +11,7 @@ go build # the cached 1.9 build. (https://golang.org/issue/37804) go mod edit -go=1.8 ! go build -stderr 'type aliases only supported as of' +stderr 'type aliases requires' -- go.mod -- diff --git a/test/fixedbugs/issue49368.go b/test/fixedbugs/issue49368.go new file mode 100644 index 0000000000..2339048e3d --- /dev/null +++ b/test/fixedbugs/issue49368.go @@ -0,0 +1,11 @@ +// errorcheck -lang=go1.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 p + +type _ interface { + int // ERROR "embedding non-interface type int requires go1\.18 or later \(-lang was set to go1\.17; check go.mod\)" +} From 759eaa22adb0ab883959e4a36c19f2dfe77b5895 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Sun, 7 Nov 2021 20:08:13 -0800 Subject: [PATCH 024/752] cmd/compile/internal/types2: remove most asX converters (cleanup) Make it explicit in the code where we call under. The asNamed and asTypeParam converters need to stay: asNamed does resolution if necessary, and asTypeParam may or may not call under() depending on the next CL. Reviewed uses of asNamed and .(*Named) for correctness. Removed unnecessary Named.resolve call in lookup. Change-Id: I2acf176925e00bd1703a00230a779aa65a8f5a51 Reviewed-on: https://go-review.googlesource.com/c/go/+/362254 Trust: Robert Griesemer Reviewed-by: Robert Findley --- .../compile/internal/types2/assignments.go | 2 +- src/cmd/compile/internal/types2/builtins.go | 8 ++-- src/cmd/compile/internal/types2/call.go | 2 +- src/cmd/compile/internal/types2/context.go | 2 +- .../compile/internal/types2/conversions.go | 21 +++++----- src/cmd/compile/internal/types2/expr.go | 6 +-- src/cmd/compile/internal/types2/index.go | 8 ++-- src/cmd/compile/internal/types2/lookup.go | 9 ++--- src/cmd/compile/internal/types2/predicates.go | 5 ++- src/cmd/compile/internal/types2/sizes.go | 2 +- src/cmd/compile/internal/types2/type.go | 39 +------------------ src/cmd/compile/internal/types2/typestring.go | 2 +- src/cmd/compile/internal/types2/typexpr.go | 2 +- 13 files changed, 36 insertions(+), 72 deletions(-) diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go index bfc5578683..609d7d0962 100644 --- a/src/cmd/compile/internal/types2/assignments.go +++ b/src/cmd/compile/internal/types2/assignments.go @@ -71,7 +71,7 @@ func (check *Checker) assignment(x *operand, T Type, context string) { // x.typ is typed // A generic (non-instantiated) function value cannot be assigned to a variable. - if sig := asSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 { + if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 { check.errorf(x, "cannot use generic function %s without instantiation in %s", x, context) } diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go index ade4c0a49f..916aed40b3 100644 --- a/src/cmd/compile/internal/types2/builtins.go +++ b/src/cmd/compile/internal/types2/builtins.go @@ -294,7 +294,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( // (applyTypeFunc never calls f with a type parameter) f := func(typ Type) Type { assert(asTypeParam(typ) == nil) - if t := asBasic(typ); t != nil { + if t, _ := under(typ).(*Basic); t != nil { switch t.kind { case Float32: return Typ[Complex64] @@ -418,7 +418,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( // (applyTypeFunc never calls f with a type parameter) f := func(typ Type) Type { assert(asTypeParam(typ) == nil) - if t := asBasic(typ); t != nil { + if t, _ := under(typ).(*Basic); t != nil { switch t.kind { case Complex64: return Typ[Float32] @@ -704,7 +704,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( return } - typ := asPointer(x.typ) + typ, _ := under(x.typ).(*Pointer) if typ == nil { check.errorf(x, invalidArg+"%s is not a pointer", x) return @@ -894,7 +894,7 @@ func makeSig(res Type, args ...Type) *Signature { // otherwise it returns typ. func arrayPtrDeref(typ Type) Type { if p, ok := typ.(*Pointer); ok { - if a := asArray(p.base); a != nil { + if a, _ := under(p.base).(*Array); a != nil { return a } } diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go index 74edd4d442..3a571285c1 100644 --- a/src/cmd/compile/internal/types2/call.go +++ b/src/cmd/compile/internal/types2/call.go @@ -132,7 +132,7 @@ func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind { case 1: check.expr(x, call.ArgList[0]) if x.mode != invalid { - if t := asInterface(T); t != nil { + if t, _ := under(T).(*Interface); t != nil { if !t.IsMethodSet() { check.errorf(call, "cannot use interface %s in conversion (contains specific type constraints or is comparable)", T) break diff --git a/src/cmd/compile/internal/types2/context.go b/src/cmd/compile/internal/types2/context.go index a8f8591243..63303ca422 100644 --- a/src/cmd/compile/internal/types2/context.go +++ b/src/cmd/compile/internal/types2/context.go @@ -39,7 +39,7 @@ func (ctxt *Context) TypeHash(typ Type, targs []Type) string { var buf bytes.Buffer h := newTypeHasher(&buf, ctxt) - if named, _ := typ.(*Named); named != nil && len(targs) > 0 { + if named := asNamed(typ); named != nil && len(targs) > 0 { // Don't use WriteType because we need to use the provided targs // and not any targs that might already be with the *Named type. h.typePrefix(named) diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go index ccabbaf0d7..dd89f29762 100644 --- a/src/cmd/compile/internal/types2/conversions.go +++ b/src/cmd/compile/internal/types2/conversions.go @@ -18,7 +18,7 @@ func (check *Checker) conversion(x *operand, T Type) { constArg := x.mode == constant_ constConvertibleTo := func(T Type, val *constant.Value) bool { - switch t := asBasic(T); { + switch t, _ := under(T).(*Basic); { case t == nil: // nothing to do case representableConst(x.val, check, t, val): @@ -173,9 +173,9 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { // "V a slice, T is a pointer-to-array type, // and the slice and array types have identical element types." - if s := asSlice(V); s != nil { - if p := asPointer(T); p != nil { - if a := asArray(p.Elem()); a != nil { + if s, _ := under(V).(*Slice); s != nil { + if p, _ := under(T).(*Pointer); p != nil { + if a, _ := under(p.Elem()).(*Array); a != nil { if Identical(s.Elem(), a.Elem()) { if check == nil || check.allowVersion(check.pkg, 1, 17) { return true @@ -262,26 +262,27 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { // use the toT convenience converters in the predicates below. func isUintptr(typ Type) bool { - t := asBasic(typ) + t, _ := under(typ).(*Basic) return t != nil && t.kind == Uintptr } func isUnsafePointer(typ Type) bool { - // TODO(gri): Is this asBasic(typ) instead of typ.(*Basic) correct? + // TODO(gri): Is this under(typ).(*Basic) instead of typ.(*Basic) correct? // (The former calls under(), while the latter doesn't.) // The spec does not say so, but gc claims it is. See also // issue 6326. - t := asBasic(typ) + t, _ := under(typ).(*Basic) return t != nil && t.kind == UnsafePointer } func isPointer(typ Type) bool { - return asPointer(typ) != nil + _, ok := under(typ).(*Pointer) + return ok } func isBytesOrRunes(typ Type) bool { - if s := asSlice(typ); s != nil { - t := asBasic(s.elem) + if s, _ := under(typ).(*Slice); s != nil { + t, _ := under(s.elem).(*Basic) return t != nil && (t.kind == Byte || t.kind == Rune) } return false diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index d24532d780..8125fba717 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -116,7 +116,7 @@ func (check *Checker) overflow(x *operand) { // x.typ cannot be a type parameter (type // parameters cannot be constant types). if isTyped(x.typ) { - check.representable(x, asBasic(x.typ)) + check.representable(x, under(x.typ).(*Basic)) return } @@ -617,7 +617,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) { // If the new type is not final and still untyped, just // update the recorded type. if !final && isUntyped(typ) { - old.typ = asBasic(typ) + old.typ = under(typ).(*Basic) check.untyped[x] = old return } @@ -1394,7 +1394,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin duplicate := false // if the key is of interface type, the type is also significant when checking for duplicates xkey := keyVal(x.val) - if asInterface(utyp.key) != nil { + if IsInterface(utyp.key) { for _, vtyp := range visited[xkey] { if Identical(vtyp, x.typ) { duplicate = true diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go index 67110704e9..f096674536 100644 --- a/src/cmd/compile/internal/types2/index.go +++ b/src/cmd/compile/internal/types2/index.go @@ -34,7 +34,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo return false case value: - if sig := asSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 { + if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 { // function instantiation return true } @@ -72,7 +72,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo x.typ = typ.elem case *Pointer: - if typ := asArray(typ.base); typ != nil { + if typ, _ := under(typ.base).(*Array); typ != nil { valid = true length = typ.len x.mode = variable @@ -120,7 +120,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo mode = value } case *Pointer: - if t := asArray(t.base); t != nil { + if t, _ := under(t.base).(*Array); t != nil { l = t.len e = t.elem } @@ -245,7 +245,7 @@ func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) { x.typ = &Slice{elem: u.elem} case *Pointer: - if u := asArray(u.base); u != nil { + if u, _ := under(u.base).(*Array); u != nil { valid = true length = u.len x.typ = &Slice{elem: u.elem} diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index e0fd74482a..0612400590 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -122,7 +122,6 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o seen[named] = true // look for a matching attached method - named.resolve(nil) if i, m := lookupMethod(named.methods, pkg, name); m != nil { // potential match // caution: method may not have a proper signature yet @@ -306,7 +305,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, return } - if ityp := asInterface(V); ityp != nil { + if ityp, _ := under(V).(*Interface); ityp != nil { // TODO(gri) the methods are sorted - could do this more efficiently for _, m := range T.typeSet().methods { _, f := ityp.typeSet().LookupMethod(m.pkg, m.name) @@ -417,7 +416,7 @@ func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Fun // no static check is required if T is an interface // spec: "If T is an interface type, x.(T) asserts that the // dynamic type of x implements the interface T." - if asInterface(T) != nil && !forceStrict { + if IsInterface(T) && !forceStrict { return } return check.missingMethod(T, V, false) @@ -435,8 +434,8 @@ func deref(typ Type) (Type, bool) { // derefStructPtr dereferences typ if it is a (named or unnamed) pointer to a // (named or unnamed) struct and returns its base. Otherwise it returns typ. func derefStructPtr(typ Type) Type { - if p := asPointer(typ); p != nil { - if asStruct(p.base) != nil { + if p, _ := under(typ).(*Pointer); p != nil { + if _, ok := under(p.base).(*Struct); ok { return p.base } } diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go index 7fbb91eb61..8d676ed8f6 100644 --- a/src/cmd/compile/internal/types2/predicates.go +++ b/src/cmd/compile/internal/types2/predicates.go @@ -72,7 +72,7 @@ func hasName(t Type) bool { // are not fully set up. func isTyped(t Type) bool { // isTyped is called with types that are not fully - // set up. Must not call asBasic()! + // set up. Must not call under()! b, _ := t.(*Basic) return b == nil || b.info&IsUntyped == 0 } @@ -84,7 +84,8 @@ func isUntyped(t Type) bool { // IsInterface reports whether t is an interface type. func IsInterface(t Type) bool { - return asInterface(t) != nil + _, ok := under(t).(*Interface) + return ok } // isTypeParam reports whether t is a type parameter. diff --git a/src/cmd/compile/internal/types2/sizes.go b/src/cmd/compile/internal/types2/sizes.go index 6a3d19d8ea..609b6f585e 100644 --- a/src/cmd/compile/internal/types2/sizes.go +++ b/src/cmd/compile/internal/types2/sizes.go @@ -243,7 +243,7 @@ func (conf *Config) offsetsof(T *Struct) []int64 { func (conf *Config) offsetof(typ Type, index []int) int64 { var o int64 for _, i := range index { - s := asStruct(typ) + s := under(typ).(*Struct) o += conf.offsetsof(s)[i] typ = s.fields[i].typ } diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go index 300c81f5fa..d1655c55f8 100644 --- a/src/cmd/compile/internal/types2/type.go +++ b/src/cmd/compile/internal/types2/type.go @@ -27,45 +27,8 @@ func under(t Type) Type { return t } -// Convenience converters - -func asBasic(t Type) *Basic { - u, _ := under(t).(*Basic) - return u -} - -func asArray(t Type) *Array { - u, _ := under(t).(*Array) - return u -} - -func asSlice(t Type) *Slice { - u, _ := under(t).(*Slice) - return u -} - -func asStruct(t Type) *Struct { - u, _ := under(t).(*Struct) - return u -} - -func asPointer(t Type) *Pointer { - u, _ := under(t).(*Pointer) - return u -} - -func asSignature(t Type) *Signature { - u, _ := under(t).(*Signature) - return u -} - -func asInterface(t Type) *Interface { - u, _ := under(t).(*Interface) - return u -} - // If the argument to asNamed, or asTypeParam is of the respective type -// (possibly after expanding resolving a *Named type), these methods return that type. +// (possibly after resolving a *Named type), these methods return that type. // Otherwise the result is nil. func asNamed(t Type) *Named { diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go index f18a32016f..f151f47a5e 100644 --- a/src/cmd/compile/internal/types2/typestring.go +++ b/src/cmd/compile/internal/types2/typestring.go @@ -361,7 +361,7 @@ func (w *typeWriter) tuple(tup *Tuple, variadic bool) { } else { // special case: // append(s, "foo"...) leads to signature func([]byte, string...) - if t := asBasic(typ); t == nil || t.kind != String { + if t, _ := under(typ).(*Basic); t == nil || t.kind != String { w.error("expected string type") continue } diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go index dcd7cfebe8..a08e472703 100644 --- a/src/cmd/compile/internal/types2/typexpr.go +++ b/src/cmd/compile/internal/types2/typexpr.go @@ -148,7 +148,7 @@ func (check *Checker) varType(e syntax.Expr) Type { // are in the middle of type-checking parameter declarations that might belong to // interface methods. Delay this check to the end of type-checking. check.later(func() { - if t := asInterface(typ); t != nil { + if t, _ := under(typ).(*Interface); t != nil { pos := syntax.StartPos(e) tset := computeInterfaceTypeSet(check, pos, t) // TODO(gri) is this the correct position? if !tset.IsMethodSet() { From 7ee3f1427b079bb363689321b0565ba7b03de03e Mon Sep 17 00:00:00 2001 From: Michael Anthony Knyszek Date: Fri, 5 Nov 2021 23:35:58 +0000 Subject: [PATCH 025/752] runtime: disable GC during debug call tests Currently the debug call protocol implementation we use for testing is riddled with write barriers, and called from a signal handler. This is not safe, as write barriers need a P to execute. Ideally this implementation would be rewritten to avoid the write barriers, but it's not straightforward, and needs some thought. As a temporary measure, disable GC during the debug call tests to avoid a write barrier. Note that this does not indicate a problem with real use of the debug call protocol. Only our test implementation has this issue, because it needs to get executed in a signal handler, normally a separate process is interfacing with the protocol via process signals and ptrace (and the like). Fixes #49370. Change-Id: Ic0fde5d0f4c64f9ecc9789b7dabb3954538fe0a8 Reviewed-on: https://go-review.googlesource.com/c/go/+/361896 Trust: Michael Knyszek Run-TryBot: Michael Knyszek TryBot-Result: Go Bot Reviewed-by: Michael Pratt --- src/runtime/debug_test.go | 42 ++++++++++++++++++++++++++++++++ src/runtime/export_debug_test.go | 10 +++++++- 2 files changed, 51 insertions(+), 1 deletion(-) diff --git a/src/runtime/debug_test.go b/src/runtime/debug_test.go index b5db7a55f1..89ea577d64 100644 --- a/src/runtime/debug_test.go +++ b/src/runtime/debug_test.go @@ -114,6 +114,13 @@ func skipUnderDebugger(t *testing.T) { } func TestDebugCall(t *testing.T) { + // InjectDebugCall cannot be executed while a GC is actively in + // progress. Wait until the current GC is done, and turn it off. + // + // See #49370. + runtime.GC() + defer debug.SetGCPercent(debug.SetGCPercent(-1)) + g, after := startDebugCallWorker(t) defer after() @@ -143,6 +150,7 @@ func TestDebugCall(t *testing.T) { x1: 42.0, } } + if _, err := runtime.InjectDebugCall(g, fn, ®s, args, debugCallTKill, false); err != nil { t.Fatal(err) } @@ -164,6 +172,13 @@ func TestDebugCall(t *testing.T) { } func TestDebugCallLarge(t *testing.T) { + // InjectDebugCall cannot be executed while a GC is actively in + // progress. Wait until the current GC is done, and turn it off. + // + // See #49370. + runtime.GC() + defer debug.SetGCPercent(debug.SetGCPercent(-1)) + g, after := startDebugCallWorker(t) defer after() @@ -193,6 +208,13 @@ func TestDebugCallLarge(t *testing.T) { } func TestDebugCallGC(t *testing.T) { + // InjectDebugCall cannot be executed while a GC is actively in + // progress. Wait until the current GC is done, and turn it off. + // + // See #49370. + runtime.GC() + defer debug.SetGCPercent(debug.SetGCPercent(-1)) + g, after := startDebugCallWorker(t) defer after() @@ -203,6 +225,13 @@ func TestDebugCallGC(t *testing.T) { } func TestDebugCallGrowStack(t *testing.T) { + // InjectDebugCall cannot be executed while a GC is actively in + // progress. Wait until the current GC is done, and turn it off. + // + // See #49370. + runtime.GC() + defer debug.SetGCPercent(debug.SetGCPercent(-1)) + g, after := startDebugCallWorker(t) defer after() @@ -233,6 +262,12 @@ func TestDebugCallUnsafePoint(t *testing.T) { // This can deadlock if there aren't enough threads or if a GC // tries to interrupt an atomic loop (see issue #10958). defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(8)) + + // InjectDebugCall cannot be executed while a GC is actively in + // progress. Wait until the current GC is done, and turn it off. + // + // See #49370. + runtime.GC() defer debug.SetGCPercent(debug.SetGCPercent(-1)) // Test that the runtime refuses call injection at unsafe points. @@ -256,6 +291,13 @@ func TestDebugCallPanic(t *testing.T) { // This can deadlock if there aren't enough threads. defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(8)) + // InjectDebugCall cannot be executed while a GC is actively in + // progress. Wait until the current GC is done, and turn it off. + // + // See #49370. + runtime.GC() + defer debug.SetGCPercent(debug.SetGCPercent(-1)) + ready := make(chan *runtime.G) var stop uint32 defer atomic.StoreUint32(&stop, 1) diff --git a/src/runtime/export_debug_test.go b/src/runtime/export_debug_test.go index 032a9b9725..fffc99d7e5 100644 --- a/src/runtime/export_debug_test.go +++ b/src/runtime/export_debug_test.go @@ -107,6 +107,10 @@ type debugCallHandler struct { } func (h *debugCallHandler) inject(info *siginfo, ctxt *sigctxt, gp2 *g) bool { + // TODO(49370): This code is riddled with write barriers, but called from + // a signal handler. Add the go:nowritebarrierrec annotation and restructure + // this to avoid write barriers. + switch h.gp.atomicstatus { case _Grunning: if getg().m != h.mp { @@ -141,7 +145,11 @@ func (h *debugCallHandler) inject(info *siginfo, ctxt *sigctxt, gp2 *g) bool { } func (h *debugCallHandler) handle(info *siginfo, ctxt *sigctxt, gp2 *g) bool { - // Sanity check. + // TODO(49370): This code is riddled with write barriers, but called from + // a signal handler. Add the go:nowritebarrierrec annotation and restructure + // this to avoid write barriers. + + // Double-check m. if getg().m != h.mp { println("trap on wrong M", getg().m, h.mp) return false From 7bda349c1735fb6043b22d7a0e4542134baa6518 Mon Sep 17 00:00:00 2001 From: Michael Anthony Knyszek Date: Fri, 5 Nov 2021 23:47:51 +0000 Subject: [PATCH 026/752] runtime: disable GC in TestPanicSystemstack's subprocess TestPanicSystemstack spins up a subprocess that has 2 goroutines deadlock on a runtime lock while on the system stack, with GOMAXPROCS=2. Each goroutine is going to be running on a P, and then is going to wedge itself up on that P. If a GC is active and a worker starts executing (using a P), then it could try to preempt a goroutine that is already blocked. It won't be able to, so it'll just sit there forever trying to suspend it. At this point there are no more Ps to execute the remaining goroutine that needs to print something so the parent process can continue the test. This change fixes this issue by disabling GCs in the child process. An alternative fix could be to increase GOMAXPROCS in the child, but maybe letting the GC be on (which assumes it'll always be able to *eventually* suspend a G) is just asking for trouble. Fixes #49388. Change-Id: I405c9dad50e24e1e68f2c52a646538da15797fbe Reviewed-on: https://go-review.googlesource.com/c/go/+/361897 Trust: Michael Knyszek Run-TryBot: Michael Knyszek TryBot-Result: Go Bot Reviewed-by: Michael Pratt --- src/runtime/crash_unix_test.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/runtime/crash_unix_test.go b/src/runtime/crash_unix_test.go index 0d9d22aa49..0930a1b365 100644 --- a/src/runtime/crash_unix_test.go +++ b/src/runtime/crash_unix_test.go @@ -13,6 +13,7 @@ import ( "os" "os/exec" "runtime" + "runtime/debug" "strings" "sync" "syscall" @@ -211,6 +212,11 @@ func TestPanicSystemstack(t *testing.T) { func init() { if len(os.Args) >= 2 && os.Args[1] == "testPanicSystemstackInternal" { + // Complete any in-flight GCs and disable future ones. We're going to + // block goroutines on runtime locks, which aren't ever preemptible for the + // GC to scan them. + runtime.GC() + debug.SetGCPercent(-1) // Get two threads running on the system stack with // something recognizable in the stack trace. runtime.GOMAXPROCS(2) From 6a9d81174e6c7d205fc189a1eac56212a723c40c Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Sun, 7 Nov 2021 21:29:30 -0800 Subject: [PATCH 027/752] internal/fmtsort: order channels in test in memory address order Kind of a kludge, but it makes the test work reliably. Fixes #49431 Change-Id: Ic2a075ba02f80ea7efcc1b3f0f5a43649e87c0d8 Reviewed-on: https://go-review.googlesource.com/c/go/+/361918 Trust: Keith Randall Run-TryBot: Keith Randall Reviewed-by: Bryan C. Mills Reviewed-by: Cuong Manh Le --- src/internal/fmtsort/sort_test.go | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/internal/fmtsort/sort_test.go b/src/internal/fmtsort/sort_test.go index 5c4db1c5fa..ab063af5ba 100644 --- a/src/internal/fmtsort/sort_test.go +++ b/src/internal/fmtsort/sort_test.go @@ -9,6 +9,7 @@ import ( "internal/fmtsort" "math" "reflect" + "sort" "strings" "testing" "unsafe" @@ -188,9 +189,19 @@ func sprintKey(key reflect.Value) string { var ( ints [3]int - chans = [3]chan int{make(chan int), make(chan int), make(chan int)} + chans = makeChans() ) +func makeChans() []chan int { + cs := []chan int{make(chan int), make(chan int), make(chan int)} + // Order channels by address. See issue #49431. + // TODO: pin these pointers once pinning is available (#46787). + sort.Slice(cs, func(i, j int) bool { + return uintptr(reflect.ValueOf(cs[i]).UnsafePointer()) < uintptr(reflect.ValueOf(cs[j]).UnsafePointer()) + }) + return cs +} + func pointerMap() map[*int]string { m := make(map[*int]string) for i := 2; i >= 0; i-- { From 2e210b41ea5ca2fd3dcac5bc24ea932c2cac1234 Mon Sep 17 00:00:00 2001 From: Roland Shoemaker Date: Mon, 8 Nov 2021 08:05:24 -0800 Subject: [PATCH 028/752] crypto/x509: remove ios build tag restriction Fixes #49435 Change-Id: I77ce12f447e727e7dc3b23de947357c27a268bd2 Reviewed-on: https://go-review.googlesource.com/c/go/+/362294 Trust: Roland Shoemaker Run-TryBot: Roland Shoemaker Reviewed-by: Bryan C. Mills --- src/crypto/x509/internal/macos/corefoundation.go | 2 +- src/crypto/x509/internal/macos/corefoundation.s | 2 +- src/crypto/x509/internal/macos/security.go | 2 +- src/crypto/x509/internal/macos/security.s | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/crypto/x509/internal/macos/corefoundation.go b/src/crypto/x509/internal/macos/corefoundation.go index 07db5c7527..cda1d95d81 100644 --- a/src/crypto/x509/internal/macos/corefoundation.go +++ b/src/crypto/x509/internal/macos/corefoundation.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. -//go:build darwin && !ios +//go:build darwin // Package macOS provides cgo-less wrappers for Core Foundation and // Security.framework, similarly to how package syscall provides access to diff --git a/src/crypto/x509/internal/macos/corefoundation.s b/src/crypto/x509/internal/macos/corefoundation.s index e60bd8712d..d69f72f795 100644 --- a/src/crypto/x509/internal/macos/corefoundation.s +++ b/src/crypto/x509/internal/macos/corefoundation.s @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build darwin && !ios +//go:build darwin #include "textflag.h" diff --git a/src/crypto/x509/internal/macos/security.go b/src/crypto/x509/internal/macos/security.go index 2805076ccd..661844a805 100644 --- a/src/crypto/x509/internal/macos/security.go +++ b/src/crypto/x509/internal/macos/security.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. -//go:build darwin && !ios +//go:build darwin package macOS diff --git a/src/crypto/x509/internal/macos/security.s b/src/crypto/x509/internal/macos/security.s index 77406a0553..cdef63f9f9 100644 --- a/src/crypto/x509/internal/macos/security.s +++ b/src/crypto/x509/internal/macos/security.s @@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -//go:build darwin && !ios +//go:build darwin #include "textflag.h" From 5e6475598c4c78fe5404ea273041552e65463a21 Mon Sep 17 00:00:00 2001 From: Cuong Manh Le Date: Tue, 9 Nov 2021 00:34:18 +0700 Subject: [PATCH 029/752] cmd/compile: Revert "cmd/compile/internal/types2: remove most asX converters (cleanup)" This reverts commit 759eaa22adb0ab883959e4a36c19f2dfe77b5895. Reason to revert: break unified IR builder Though the unified IR is not for go1.18, it's the only user of types2 lazy resolution APIs at this moment. And it consistently failed after CL 362254 is the sign that the change was wrong somehow. Change-Id: I6bfc3192904fe2129fd3c165f0df8761e8eb441c Reviewed-on: https://go-review.googlesource.com/c/go/+/361964 Trust: Cuong Manh Le Run-TryBot: Cuong Manh Le TryBot-Result: Go Bot Reviewed-by: Robert Findley --- .../compile/internal/types2/assignments.go | 2 +- src/cmd/compile/internal/types2/builtins.go | 8 ++-- src/cmd/compile/internal/types2/call.go | 2 +- src/cmd/compile/internal/types2/context.go | 2 +- .../compile/internal/types2/conversions.go | 21 +++++----- src/cmd/compile/internal/types2/expr.go | 6 +-- src/cmd/compile/internal/types2/index.go | 8 ++-- src/cmd/compile/internal/types2/lookup.go | 9 +++-- src/cmd/compile/internal/types2/predicates.go | 5 +-- src/cmd/compile/internal/types2/sizes.go | 2 +- src/cmd/compile/internal/types2/type.go | 39 ++++++++++++++++++- src/cmd/compile/internal/types2/typestring.go | 2 +- src/cmd/compile/internal/types2/typexpr.go | 2 +- 13 files changed, 72 insertions(+), 36 deletions(-) diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go index 609d7d0962..bfc5578683 100644 --- a/src/cmd/compile/internal/types2/assignments.go +++ b/src/cmd/compile/internal/types2/assignments.go @@ -71,7 +71,7 @@ func (check *Checker) assignment(x *operand, T Type, context string) { // x.typ is typed // A generic (non-instantiated) function value cannot be assigned to a variable. - if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 { + if sig := asSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 { check.errorf(x, "cannot use generic function %s without instantiation in %s", x, context) } diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go index 916aed40b3..ade4c0a49f 100644 --- a/src/cmd/compile/internal/types2/builtins.go +++ b/src/cmd/compile/internal/types2/builtins.go @@ -294,7 +294,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( // (applyTypeFunc never calls f with a type parameter) f := func(typ Type) Type { assert(asTypeParam(typ) == nil) - if t, _ := under(typ).(*Basic); t != nil { + if t := asBasic(typ); t != nil { switch t.kind { case Float32: return Typ[Complex64] @@ -418,7 +418,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( // (applyTypeFunc never calls f with a type parameter) f := func(typ Type) Type { assert(asTypeParam(typ) == nil) - if t, _ := under(typ).(*Basic); t != nil { + if t := asBasic(typ); t != nil { switch t.kind { case Complex64: return Typ[Float32] @@ -704,7 +704,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( return } - typ, _ := under(x.typ).(*Pointer) + typ := asPointer(x.typ) if typ == nil { check.errorf(x, invalidArg+"%s is not a pointer", x) return @@ -894,7 +894,7 @@ func makeSig(res Type, args ...Type) *Signature { // otherwise it returns typ. func arrayPtrDeref(typ Type) Type { if p, ok := typ.(*Pointer); ok { - if a, _ := under(p.base).(*Array); a != nil { + if a := asArray(p.base); a != nil { return a } } diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go index 3a571285c1..74edd4d442 100644 --- a/src/cmd/compile/internal/types2/call.go +++ b/src/cmd/compile/internal/types2/call.go @@ -132,7 +132,7 @@ func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind { case 1: check.expr(x, call.ArgList[0]) if x.mode != invalid { - if t, _ := under(T).(*Interface); t != nil { + if t := asInterface(T); t != nil { if !t.IsMethodSet() { check.errorf(call, "cannot use interface %s in conversion (contains specific type constraints or is comparable)", T) break diff --git a/src/cmd/compile/internal/types2/context.go b/src/cmd/compile/internal/types2/context.go index 63303ca422..a8f8591243 100644 --- a/src/cmd/compile/internal/types2/context.go +++ b/src/cmd/compile/internal/types2/context.go @@ -39,7 +39,7 @@ func (ctxt *Context) TypeHash(typ Type, targs []Type) string { var buf bytes.Buffer h := newTypeHasher(&buf, ctxt) - if named := asNamed(typ); named != nil && len(targs) > 0 { + if named, _ := typ.(*Named); named != nil && len(targs) > 0 { // Don't use WriteType because we need to use the provided targs // and not any targs that might already be with the *Named type. h.typePrefix(named) diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go index dd89f29762..ccabbaf0d7 100644 --- a/src/cmd/compile/internal/types2/conversions.go +++ b/src/cmd/compile/internal/types2/conversions.go @@ -18,7 +18,7 @@ func (check *Checker) conversion(x *operand, T Type) { constArg := x.mode == constant_ constConvertibleTo := func(T Type, val *constant.Value) bool { - switch t, _ := under(T).(*Basic); { + switch t := asBasic(T); { case t == nil: // nothing to do case representableConst(x.val, check, t, val): @@ -173,9 +173,9 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { // "V a slice, T is a pointer-to-array type, // and the slice and array types have identical element types." - if s, _ := under(V).(*Slice); s != nil { - if p, _ := under(T).(*Pointer); p != nil { - if a, _ := under(p.Elem()).(*Array); a != nil { + if s := asSlice(V); s != nil { + if p := asPointer(T); p != nil { + if a := asArray(p.Elem()); a != nil { if Identical(s.Elem(), a.Elem()) { if check == nil || check.allowVersion(check.pkg, 1, 17) { return true @@ -262,27 +262,26 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { // use the toT convenience converters in the predicates below. func isUintptr(typ Type) bool { - t, _ := under(typ).(*Basic) + t := asBasic(typ) return t != nil && t.kind == Uintptr } func isUnsafePointer(typ Type) bool { - // TODO(gri): Is this under(typ).(*Basic) instead of typ.(*Basic) correct? + // TODO(gri): Is this asBasic(typ) instead of typ.(*Basic) correct? // (The former calls under(), while the latter doesn't.) // The spec does not say so, but gc claims it is. See also // issue 6326. - t, _ := under(typ).(*Basic) + t := asBasic(typ) return t != nil && t.kind == UnsafePointer } func isPointer(typ Type) bool { - _, ok := under(typ).(*Pointer) - return ok + return asPointer(typ) != nil } func isBytesOrRunes(typ Type) bool { - if s, _ := under(typ).(*Slice); s != nil { - t, _ := under(s.elem).(*Basic) + if s := asSlice(typ); s != nil { + t := asBasic(s.elem) return t != nil && (t.kind == Byte || t.kind == Rune) } return false diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index 8125fba717..d24532d780 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -116,7 +116,7 @@ func (check *Checker) overflow(x *operand) { // x.typ cannot be a type parameter (type // parameters cannot be constant types). if isTyped(x.typ) { - check.representable(x, under(x.typ).(*Basic)) + check.representable(x, asBasic(x.typ)) return } @@ -617,7 +617,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) { // If the new type is not final and still untyped, just // update the recorded type. if !final && isUntyped(typ) { - old.typ = under(typ).(*Basic) + old.typ = asBasic(typ) check.untyped[x] = old return } @@ -1394,7 +1394,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin duplicate := false // if the key is of interface type, the type is also significant when checking for duplicates xkey := keyVal(x.val) - if IsInterface(utyp.key) { + if asInterface(utyp.key) != nil { for _, vtyp := range visited[xkey] { if Identical(vtyp, x.typ) { duplicate = true diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go index f096674536..67110704e9 100644 --- a/src/cmd/compile/internal/types2/index.go +++ b/src/cmd/compile/internal/types2/index.go @@ -34,7 +34,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo return false case value: - if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 { + if sig := asSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 { // function instantiation return true } @@ -72,7 +72,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo x.typ = typ.elem case *Pointer: - if typ, _ := under(typ.base).(*Array); typ != nil { + if typ := asArray(typ.base); typ != nil { valid = true length = typ.len x.mode = variable @@ -120,7 +120,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo mode = value } case *Pointer: - if t, _ := under(t.base).(*Array); t != nil { + if t := asArray(t.base); t != nil { l = t.len e = t.elem } @@ -245,7 +245,7 @@ func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) { x.typ = &Slice{elem: u.elem} case *Pointer: - if u, _ := under(u.base).(*Array); u != nil { + if u := asArray(u.base); u != nil { valid = true length = u.len x.typ = &Slice{elem: u.elem} diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index 0612400590..e0fd74482a 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -122,6 +122,7 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o seen[named] = true // look for a matching attached method + named.resolve(nil) if i, m := lookupMethod(named.methods, pkg, name); m != nil { // potential match // caution: method may not have a proper signature yet @@ -305,7 +306,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, return } - if ityp, _ := under(V).(*Interface); ityp != nil { + if ityp := asInterface(V); ityp != nil { // TODO(gri) the methods are sorted - could do this more efficiently for _, m := range T.typeSet().methods { _, f := ityp.typeSet().LookupMethod(m.pkg, m.name) @@ -416,7 +417,7 @@ func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Fun // no static check is required if T is an interface // spec: "If T is an interface type, x.(T) asserts that the // dynamic type of x implements the interface T." - if IsInterface(T) && !forceStrict { + if asInterface(T) != nil && !forceStrict { return } return check.missingMethod(T, V, false) @@ -434,8 +435,8 @@ func deref(typ Type) (Type, bool) { // derefStructPtr dereferences typ if it is a (named or unnamed) pointer to a // (named or unnamed) struct and returns its base. Otherwise it returns typ. func derefStructPtr(typ Type) Type { - if p, _ := under(typ).(*Pointer); p != nil { - if _, ok := under(p.base).(*Struct); ok { + if p := asPointer(typ); p != nil { + if asStruct(p.base) != nil { return p.base } } diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go index 8d676ed8f6..7fbb91eb61 100644 --- a/src/cmd/compile/internal/types2/predicates.go +++ b/src/cmd/compile/internal/types2/predicates.go @@ -72,7 +72,7 @@ func hasName(t Type) bool { // are not fully set up. func isTyped(t Type) bool { // isTyped is called with types that are not fully - // set up. Must not call under()! + // set up. Must not call asBasic()! b, _ := t.(*Basic) return b == nil || b.info&IsUntyped == 0 } @@ -84,8 +84,7 @@ func isUntyped(t Type) bool { // IsInterface reports whether t is an interface type. func IsInterface(t Type) bool { - _, ok := under(t).(*Interface) - return ok + return asInterface(t) != nil } // isTypeParam reports whether t is a type parameter. diff --git a/src/cmd/compile/internal/types2/sizes.go b/src/cmd/compile/internal/types2/sizes.go index 609b6f585e..6a3d19d8ea 100644 --- a/src/cmd/compile/internal/types2/sizes.go +++ b/src/cmd/compile/internal/types2/sizes.go @@ -243,7 +243,7 @@ func (conf *Config) offsetsof(T *Struct) []int64 { func (conf *Config) offsetof(typ Type, index []int) int64 { var o int64 for _, i := range index { - s := under(typ).(*Struct) + s := asStruct(typ) o += conf.offsetsof(s)[i] typ = s.fields[i].typ } diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go index d1655c55f8..300c81f5fa 100644 --- a/src/cmd/compile/internal/types2/type.go +++ b/src/cmd/compile/internal/types2/type.go @@ -27,8 +27,45 @@ func under(t Type) Type { return t } +// Convenience converters + +func asBasic(t Type) *Basic { + u, _ := under(t).(*Basic) + return u +} + +func asArray(t Type) *Array { + u, _ := under(t).(*Array) + return u +} + +func asSlice(t Type) *Slice { + u, _ := under(t).(*Slice) + return u +} + +func asStruct(t Type) *Struct { + u, _ := under(t).(*Struct) + return u +} + +func asPointer(t Type) *Pointer { + u, _ := under(t).(*Pointer) + return u +} + +func asSignature(t Type) *Signature { + u, _ := under(t).(*Signature) + return u +} + +func asInterface(t Type) *Interface { + u, _ := under(t).(*Interface) + return u +} + // If the argument to asNamed, or asTypeParam is of the respective type -// (possibly after resolving a *Named type), these methods return that type. +// (possibly after expanding resolving a *Named type), these methods return that type. // Otherwise the result is nil. func asNamed(t Type) *Named { diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go index f151f47a5e..f18a32016f 100644 --- a/src/cmd/compile/internal/types2/typestring.go +++ b/src/cmd/compile/internal/types2/typestring.go @@ -361,7 +361,7 @@ func (w *typeWriter) tuple(tup *Tuple, variadic bool) { } else { // special case: // append(s, "foo"...) leads to signature func([]byte, string...) - if t, _ := under(typ).(*Basic); t == nil || t.kind != String { + if t := asBasic(typ); t == nil || t.kind != String { w.error("expected string type") continue } diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go index a08e472703..dcd7cfebe8 100644 --- a/src/cmd/compile/internal/types2/typexpr.go +++ b/src/cmd/compile/internal/types2/typexpr.go @@ -148,7 +148,7 @@ func (check *Checker) varType(e syntax.Expr) Type { // are in the middle of type-checking parameter declarations that might belong to // interface methods. Delay this check to the end of type-checking. check.later(func() { - if t, _ := under(typ).(*Interface); t != nil { + if t := asInterface(typ); t != nil { pos := syntax.StartPos(e) tset := computeInterfaceTypeSet(check, pos, t) // TODO(gri) is this the correct position? if !tset.IsMethodSet() { From 830b393bcd5a3090b13cd0bd05f51e3d594807f3 Mon Sep 17 00:00:00 2001 From: Cuong Manh Le Date: Tue, 9 Nov 2021 00:05:58 +0700 Subject: [PATCH 030/752] cmd/compile,cmd/go: fix long test builders CL 361411 improved error message for go version requirement, but forgot to update the test in cmd/go to match new error message. That causes longtest builders failed. This CL changes mod_vendor_goversion.txt to match compiler error, and limit fixedbugs/issue49368.go to run with -G=3 only. Updates #49368 Change-Id: I125fe0a8c2a1595066d39c03e97819e7a1274e0a Reviewed-on: https://go-review.googlesource.com/c/go/+/361963 Trust: Cuong Manh Le Run-TryBot: Cuong Manh Le TryBot-Result: Go Bot Reviewed-by: Robert Findley Reviewed-by: Bryan C. Mills --- src/cmd/go/testdata/script/mod_vendor_goversion.txt | 2 +- test/fixedbugs/issue49368.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/testdata/script/mod_vendor_goversion.txt b/src/cmd/go/testdata/script/mod_vendor_goversion.txt index a92eb73d27..9e3618a218 100644 --- a/src/cmd/go/testdata/script/mod_vendor_goversion.txt +++ b/src/cmd/go/testdata/script/mod_vendor_goversion.txt @@ -26,7 +26,7 @@ go mod vendor ! grep 1.17 vendor/modules.txt ! go build example.net/need117 stderr '^vendor[/\\]example\.net[/\\]need117[/\\]need117.go:5:1[89]:' -stderr 'conversion of slices to array pointers only supported as of -lang=go1\.17' +stderr 'conversion of slices to array pointers requires go1\.17 or later' ! grep 1.13 vendor/modules.txt go build example.net/bad114 diff --git a/test/fixedbugs/issue49368.go b/test/fixedbugs/issue49368.go index 2339048e3d..4cbf351ae0 100644 --- a/test/fixedbugs/issue49368.go +++ b/test/fixedbugs/issue49368.go @@ -1,4 +1,4 @@ -// errorcheck -lang=go1.17 +// errorcheck -G=3 -lang=go1.17 // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style From ccea0b2fbe8eaf0ac69fab4aef28f300bf676d21 Mon Sep 17 00:00:00 2001 From: Damien Neil Date: Mon, 8 Nov 2021 12:45:41 -0800 Subject: [PATCH 031/752] net/http: deflake TestTimeoutHandlerContextCanceled Fixes #49448 Change-Id: Ie2acff7dedbca9bd1cc0b1b3dd0a01573c7befee Reviewed-on: https://go-review.googlesource.com/c/go/+/361920 Trust: Damien Neil Run-TryBot: Damien Neil TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/net/http/serve_test.go | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go index 27dff2bf45..30a6555d30 100644 --- a/src/net/http/serve_test.go +++ b/src/net/http/serve_test.go @@ -2520,22 +2520,28 @@ func TestTimeoutHandlerStartTimerWhenServing(t *testing.T) { func TestTimeoutHandlerContextCanceled(t *testing.T) { setParallel(t) defer afterTest(t) - sendHi := make(chan bool, 1) writeErrors := make(chan error, 1) sayHi := HandlerFunc(func(w ResponseWriter, r *Request) { w.Header().Set("Content-Type", "text/plain") - <-sendHi - _, werr := w.Write([]byte("hi")) - writeErrors <- werr + var err error + // The request context has already been canceled, but + // retry the write for a while to give the timeout handler + // a chance to notice. + for i := 0; i < 100; i++ { + _, err = w.Write([]byte("a")) + if err != nil { + break + } + time.Sleep(1 * time.Millisecond) + } + writeErrors <- err }) - ctx, cancel := context.WithTimeout(context.Background(), 1*time.Hour) - h := NewTestTimeoutHandler(sayHi, ctx) + ctx, cancel := context.WithCancel(context.Background()) cancel() + h := NewTestTimeoutHandler(sayHi, ctx) cst := newClientServerTest(t, h1Mode, h) defer cst.close() - // Succeed without timing out: - sendHi <- true res, err := cst.c.Get(cst.ts.URL) if err != nil { t.Error(err) @@ -2548,7 +2554,7 @@ func TestTimeoutHandlerContextCanceled(t *testing.T) { t.Errorf("got body %q; expected %q", g, e) } if g, e := <-writeErrors, context.Canceled; g != e { - t.Errorf("got unexpected Write error on first request: %v", g) + t.Errorf("got unexpected Write in handler: %v, want %g", g, e) } } From 0e39946e8df426b459103ab94256b697a6a4dd9c Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Tue, 19 Oct 2021 14:05:29 -0400 Subject: [PATCH 032/752] cmd/go: add workspace pruning mode This change corrects a bug in the handling of module loading of workspaces. Namely, there is an assumption by the module pruning code that if a root module is selected then the packages of that module can be resolved without loading the whole module graph. This is not true in workspace mode because two workspace modules can require different versions of a dependency. Worse, one workspace module can directly require a depencency that is transitively required by another workspace module, changing the version of that module loaded in the fully expanded graph. To correct this, a new 'workspace' pruning mode is added where the roots are the workspace modules themselves, satisfying the assumption made by the module pruning logic. The rest of this change accounts for the new pruning mode where it's used and correctly sets the requirements in this pruning mode. Change-Id: I5d4d9877e492e196681f6ee9f8f18a08b4e95c61 Reviewed-on: https://go-review.googlesource.com/c/go/+/357169 Trust: Michael Matloob Run-TryBot: Michael Matloob TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/cmd/go/internal/modload/buildlist.go | 86 +++++++++++++++++------ src/cmd/go/internal/modload/init.go | 44 ++++++------ src/cmd/go/internal/modload/load.go | 24 ++++++- src/cmd/go/internal/modload/modfile.go | 14 ++-- src/cmd/go/testdata/script/work_prune.txt | 2 +- 5 files changed, 121 insertions(+), 49 deletions(-) diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go index 27cab0b9c8..9e56265a41 100644 --- a/src/cmd/go/internal/modload/buildlist.go +++ b/src/cmd/go/internal/modload/buildlist.go @@ -38,11 +38,17 @@ type Requirements struct { // If pruned, the graph includes only the root modules, the explicit // requirements of those root modules, and the transitive requirements of only // the root modules that do not support pruning. + // + // If workspace, the graph includes only the workspace modules, the explicit + // requirements of the workspace modules, and the transitive requirements of + // the workspace modules that do not support pruning. pruning modPruning - // rootModules is the set of module versions explicitly required by the main - // modules, sorted and capped to length. It may contain duplicates, and may - // contain multiple versions for a given module path. + // rootModules is the set of root modules of the graph, sorted and capped to + // length. It may contain duplicates, and may contain multiple versions for a + // given module path. The root modules of the groph are the set of main + // modules in workspace mode, and the main module's direct requirements + // outside workspace mode. rootModules []module.Version maxRootVersion map[string]string @@ -99,6 +105,19 @@ var requirements *Requirements // If vendoring is in effect, the caller must invoke initVendor on the returned // *Requirements before any other method. func newRequirements(pruning modPruning, rootModules []module.Version, direct map[string]bool) *Requirements { + if pruning == workspace { + return &Requirements{ + pruning: pruning, + rootModules: capVersionSlice(rootModules), + maxRootVersion: nil, + direct: direct, + } + } + + if inWorkspaceMode() && pruning != workspace { + panic("in workspace mode, but pruning is not workspace in newRequirements") + } + for i, m := range rootModules { if m.Version == "" && MainModules.Contains(m.Path) { panic(fmt.Sprintf("newRequirements called with untrimmed build list: rootModules[%v] is a main module", i)) @@ -291,13 +310,11 @@ func readModGraph(ctx context.Context, pruning modPruning, roots []module.Versio g: mvs.NewGraph(cmpVersion, MainModules.Versions()), } ) - for _, m := range MainModules.Versions() { - // Require all roots from all main modules. - _ = TODOWorkspaces("This flattens a level of the module graph, adding the dependencies " + - "of all main modules to a single requirements struct, and losing the information of which " + - "main module required which requirement. Rework the requirements struct and change this" + - "to reflect the structure of the main modules.") - mg.g.Require(m, roots) + if pruning != workspace { + if inWorkspaceMode() { + panic("pruning is not workspace in workspace mode") + } + mg.g.Require(MainModules.mustGetSingleMainModule(), roots) } var ( @@ -352,9 +369,13 @@ func readModGraph(ctx context.Context, pruning modPruning, roots []module.Versio // are sufficient to build the packages it contains. We must load its full // transitive dependency graph to be sure that we see all relevant // dependencies. - if pruning == unpruned || summary.pruning == unpruned { + if pruning != pruned || summary.pruning == unpruned { + nextPruning := summary.pruning + if pruning == unpruned { + nextPruning = unpruned + } for _, r := range summary.require { - enqueue(r, unpruned) + enqueue(r, nextPruning) } } }) @@ -424,12 +445,15 @@ func (mg *ModuleGraph) findError() error { } func (mg *ModuleGraph) allRootsSelected() bool { - for _, mm := range MainModules.Versions() { - roots, _ := mg.g.RequiredBy(mm) - for _, m := range roots { - if mg.Selected(m.Path) != m.Version { - return false - } + var roots []module.Version + if inWorkspaceMode() { + roots = MainModules.Versions() + } else { + roots, _ = mg.g.RequiredBy(MainModules.mustGetSingleMainModule()) + } + for _, m := range roots { + if mg.Selected(m.Path) != m.Version { + return false } } return true @@ -576,10 +600,29 @@ func tidyRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Require } func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version, rootsImported bool) (*Requirements, error) { - if rs.pruning == unpruned { + switch rs.pruning { + case unpruned: return updateUnprunedRoots(ctx, direct, rs, add) + case pruned: + return updatePrunedRoots(ctx, direct, rs, pkgs, add, rootsImported) + case workspace: + return updateWorkspaceRoots(ctx, rs, add) + default: + panic(fmt.Sprintf("unsupported pruning mode: %v", rs.pruning)) } - return updatePrunedRoots(ctx, direct, rs, pkgs, add, rootsImported) +} + +func updateWorkspaceRoots(ctx context.Context, rs *Requirements, add []module.Version) (*Requirements, error) { + if len(add) != 0 { + // add should be empty in workspace mode because a non-empty add slice means + // that there are missing roots in the current pruning mode or that the + // pruning mode is being changed. But the pruning mode should always be + // 'workspace' in workspace mode and the set of roots in workspace mode is + // always complete because it's the set of workspace modules, which can't + // be edited by loading. + panic("add is not empty") + } + return rs, nil } // tidyPrunedRoots returns a minimal set of root requirements that maintains the @@ -1156,7 +1199,6 @@ func updateUnprunedRoots(ctx context.Context, direct map[string]bool, rs *Requir } } - // TODO(matloob): Make roots into a map. var roots []module.Version for _, mainModule := range MainModules.Versions() { min, err := mvs.Req(mainModule, rootPaths, &mvsReqs{roots: keep}) @@ -1182,6 +1224,8 @@ func updateUnprunedRoots(ctx context.Context, direct map[string]bool, rs *Requir func convertPruning(ctx context.Context, rs *Requirements, pruning modPruning) (*Requirements, error) { if rs.pruning == pruning { return rs, nil + } else if rs.pruning == workspace || pruning == workspace { + panic("attempthing to convert to/from workspace pruning and another pruning type") } if pruning == unpruned { diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go index 9aef5a7c33..512c9ebfbd 100644 --- a/src/cmd/go/internal/modload/init.go +++ b/src/cmd/go/internal/modload/init.go @@ -704,7 +704,7 @@ func LoadModFile(ctx context.Context) *Requirements { } } - if MainModules.Index(mainModule).goVersionV == "" { + if MainModules.Index(mainModule).goVersionV == "" && rs.pruning != workspace { // TODO(#45551): Do something more principled instead of checking // cfg.CmdName directly here. if cfg.BuildMod == "mod" && cfg.CmdName != "mod graph" && cfg.CmdName != "mod why" { @@ -987,29 +987,29 @@ func makeMainModules(ms []module.Version, rootDirs []string, modFiles []*modfile // requirementsFromModFiles returns the set of non-excluded requirements from // the global modFile. func requirementsFromModFiles(ctx context.Context, modFiles []*modfile.File) *Requirements { - rootCap := 0 - for i := range modFiles { - rootCap += len(modFiles[i].Require) - } - roots := make([]module.Version, 0, rootCap) - mPathCount := make(map[string]int) - for _, m := range MainModules.Versions() { - mPathCount[m.Path] = 1 - } + var roots []module.Version direct := map[string]bool{} - for _, modFile := range modFiles { - requirement: + var pruning modPruning + if inWorkspaceMode() { + pruning = workspace + roots = make([]module.Version, len(MainModules.Versions())) + copy(roots, MainModules.Versions()) + } else { + pruning = pruningForGoVersion(MainModules.GoVersion()) + if len(modFiles) != 1 { + panic(fmt.Errorf("requirementsFromModFiles called with %v modfiles outside workspace mode", len(modFiles))) + } + modFile := modFiles[0] + roots = make([]module.Version, 0, len(modFile.Require)) + mm := MainModules.mustGetSingleMainModule() for _, r := range modFile.Require { - // TODO(#45713): Maybe join - for _, mainModule := range MainModules.Versions() { - if index := MainModules.Index(mainModule); index != nil && index.exclude[r.Mod] { - if cfg.BuildMod == "mod" { - fmt.Fprintf(os.Stderr, "go: dropping requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) - } else { - fmt.Fprintf(os.Stderr, "go: ignoring requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) - } - continue requirement + if index := MainModules.Index(mm); index != nil && index.exclude[r.Mod] { + if cfg.BuildMod == "mod" { + fmt.Fprintf(os.Stderr, "go: dropping requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) + } else { + fmt.Fprintf(os.Stderr, "go: ignoring requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) } + continue } roots = append(roots, r.Mod) @@ -1019,7 +1019,7 @@ func requirementsFromModFiles(ctx context.Context, modFiles []*modfile.File) *Re } } module.Sort(roots) - rs := newRequirements(pruningForGoVersion(MainModules.GoVersion()), roots, direct) + rs := newRequirements(pruning, roots, direct) return rs } diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go index 845bf2f8a2..83fcafead3 100644 --- a/src/cmd/go/internal/modload/load.go +++ b/src/cmd/go/internal/modload/load.go @@ -1004,7 +1004,11 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader { } var err error - ld.requirements, err = convertPruning(ctx, ld.requirements, pruningForGoVersion(ld.GoVersion)) + desiredPruning := pruningForGoVersion(ld.GoVersion) + if ld.requirements.pruning == workspace { + desiredPruning = workspace + } + ld.requirements, err = convertPruning(ctx, ld.requirements, desiredPruning) if err != nil { ld.errorf("go: %v\n", err) } @@ -1246,6 +1250,24 @@ func (ld *loader) updateRequirements(ctx context.Context) (changed bool, err err continue } + if inWorkspaceMode() { + // In workspace mode / workspace pruning mode, the roots are the main modules + // rather than the main module's direct dependencies. The check below on the selected + // roots does not apply. + if mg, err := rs.Graph(ctx); err != nil { + return false, err + } else if _, ok := mg.RequiredBy(dep.mod); !ok { + // dep.mod is not an explicit dependency, but needs to be. + // See comment on error returned below. + pkg.err = &DirectImportFromImplicitDependencyError{ + ImporterPath: pkg.path, + ImportedPath: dep.path, + Module: dep.mod, + } + } + continue + } + if pkg.err == nil && cfg.BuildMod != "mod" { if v, ok := rs.rootSelected(dep.mod.Path); !ok || v != dep.mod.Version { // dep.mod is not an explicit dependency, but needs to be. diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go index a7e92222a1..40e6ed787d 100644 --- a/src/cmd/go/internal/modload/modfile.go +++ b/src/cmd/go/internal/modload/modfile.go @@ -118,8 +118,9 @@ type requireMeta struct { type modPruning uint8 const ( - pruned modPruning = iota // transitive dependencies of modules at go 1.17 and higher are pruned out - unpruned // no transitive dependencies are pruned out + pruned modPruning = iota // transitive dependencies of modules at go 1.17 and higher are pruned out + unpruned // no transitive dependencies are pruned out + workspace // pruned to the union of modules in the workspace ) func pruningForGoVersion(goVersion string) modPruning { @@ -554,7 +555,7 @@ type retraction struct { // // The caller must not modify the returned summary. func goModSummary(m module.Version) (*modFileSummary, error) { - if m.Version == "" && MainModules.Contains(m.Path) { + if m.Version == "" && !inWorkspaceMode() && MainModules.Contains(m.Path) { panic("internal error: goModSummary called on a main module") } @@ -718,9 +719,14 @@ var rawGoModSummaryCache par.Cache // module.Version → rawGoModSummary result func rawGoModData(m module.Version) (name string, data []byte, err error) { if m.Version == "" { // m is a replacement module with only a file path. + dir := m.Path if !filepath.IsAbs(dir) { - dir = filepath.Join(replaceRelativeTo(), dir) + if inWorkspaceMode() && MainModules.Contains(m.Path) { + dir = MainModules.ModRoot(m) + } else { + dir = filepath.Join(replaceRelativeTo(), dir) + } } name = filepath.Join(dir, "go.mod") if gomodActual, ok := fsys.OverlayPath(name); ok { diff --git a/src/cmd/go/testdata/script/work_prune.txt b/src/cmd/go/testdata/script/work_prune.txt index f0fb073c4b..00c3e10663 100644 --- a/src/cmd/go/testdata/script/work_prune.txt +++ b/src/cmd/go/testdata/script/work_prune.txt @@ -14,7 +14,7 @@ # TODO(#48331): We currently load the wrong version of q. Fix this. go list -m -f '{{.Version}}' example.com/q -stdout '^v1.0.0$' # TODO(#48331): This should be 1.1.0. Fix this. +stdout '^v1.1.0$' -- go.work -- go 1.18 From cc4917823747752337feec5a14f700633f4e9d02 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Thu, 21 Oct 2021 14:26:55 -0400 Subject: [PATCH 033/752] cmd/go: rename go mod initwork and editwork to go work init and edit This brings the workspace related commands into their own namespace. Fixes #48256 Change-Id: I9d5e3d4c45798913d742c532c1571006e6f9cc57 Reviewed-on: https://go-review.googlesource.com/c/go/+/357611 Trust: Michael Matloob Run-TryBot: Michael Matloob TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/cmd/go/alldocs.go | 200 ++++++++++-------- src/cmd/go/internal/modcmd/mod.go | 2 - .../{modcmd/editwork.go => workcmd/edit.go} | 97 ++++++--- .../{modcmd/initwork.go => workcmd/init.go} | 14 +- src/cmd/go/internal/workcmd/work.go | 28 +++ src/cmd/go/main.go | 2 + src/cmd/go/testdata/script/work.txt | 4 +- src/cmd/go/testdata/script/work_edit.txt | 22 +- .../testdata/script/work_replace_conflict.txt | 2 +- 9 files changed, 230 insertions(+), 141 deletions(-) rename src/cmd/go/internal/{modcmd/editwork.go => workcmd/edit.go} (74%) rename src/cmd/go/internal/{modcmd/initwork.go => workcmd/init.go} (83%) create mode 100644 src/cmd/go/internal/workcmd/work.go diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index c9426801c5..d8ebc8d61d 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -25,6 +25,7 @@ // install compile and install packages and dependencies // list list packages or modules // mod module maintenance +// work workspace maintenance // run compile and run Go program // test test packages // tool run specified go tool @@ -1055,10 +1056,8 @@ // // download download modules to local cache // edit edit go.mod from tools or scripts -// editwork edit go.work from tools or scripts // graph print module requirement graph // init initialize new module in current directory -// initwork initialize workspace file // tidy add missing and remove unused modules // vendor make vendored copy of dependencies // verify verify dependencies have expected content @@ -1218,77 +1217,6 @@ // See https://golang.org/ref/mod#go-mod-edit for more about 'go mod edit'. // // -// Edit go.work from tools or scripts -// -// Usage: -// -// go mod editwork [editing flags] [go.work] -// -// Editwork provides a command-line interface for editing go.work, -// for use primarily by tools or scripts. It only reads go.work; -// it does not look up information about the modules involved. -// If no file is specified, editwork looks for a go.work file in the current -// directory and its parent directories -// -// The editing flags specify a sequence of editing operations. -// -// The -fmt flag reformats the go.work file without making other changes. -// This reformatting is also implied by any other modifications that use or -// rewrite the go.mod file. The only time this flag is needed is if no other -// flags are specified, as in 'go mod editwork -fmt'. -// -// The -directory=path and -dropdirectory=path flags -// add and drop a directory from the go.work files set of module directories. -// -// The -replace=old[@v]=new[@v] flag adds a replacement of the given -// module path and version pair. If the @v in old@v is omitted, a -// replacement without a version on the left side is added, which applies -// to all versions of the old module path. If the @v in new@v is omitted, -// the new path should be a local module root directory, not a module -// path. Note that -replace overrides any redundant replacements for old[@v], -// so omitting @v will drop existing replacements for specific versions. -// -// The -dropreplace=old[@v] flag drops a replacement of the given -// module path and version pair. If the @v is omitted, a replacement without -// a version on the left side is dropped. -// -// The -directory, -dropdirectory, -replace, and -dropreplace, -// editing flags may be repeated, and the changes are applied in the order given. -// -// The -go=version flag sets the expected Go language version. -// -// The -print flag prints the final go.work in its text format instead of -// writing it back to go.mod. -// -// The -json flag prints the final go.work file in JSON format instead of -// writing it back to go.mod. The JSON output corresponds to these Go types: -// -// type Module struct { -// Path string -// Version string -// } -// -// type GoWork struct { -// Go string -// Directory []Directory -// Replace []Replace -// } -// -// type Directory struct { -// Path string -// ModulePath string -// } -// -// type Replace struct { -// Old Module -// New Module -// } -// -// See the workspaces design proposal at -// https://go.googlesource.com/proposal/+/master/design/45713-workspace.md for -// more information. -// -// // Print module requirement graph // // Usage: @@ -1328,23 +1256,6 @@ // See https://golang.org/ref/mod#go-mod-init for more about 'go mod init'. // // -// Initialize workspace file -// -// Usage: -// -// go mod initwork [moddirs] -// -// go mod initwork initializes and writes a new go.work file in the current -// directory, in effect creating a new workspace at the current directory. -// -// go mod initwork optionally accepts paths to the workspace modules as arguments. -// If the argument is omitted, an empty workspace with no modules will be created. -// -// See the workspaces design proposal at -// https://go.googlesource.com/proposal/+/master/design/45713-workspace.md for -// more information. -// -// // Add missing and remove unused modules // // Usage: @@ -1453,6 +1364,115 @@ // See https://golang.org/ref/mod#go-mod-why for more about 'go mod why'. // // +// Workspace maintenance +// +// Go workspace provides access to operations on worskpaces. +// +// Note that support for workspaces is built into many other commands, +// not just 'go work'. +// +// See 'go help modules' for information about Go's module system of +// which workspaces are a part. +// +// Usage: +// +// go work [arguments] +// +// The commands are: +// +// edit edit go.work from tools or scripts +// init initialize workspace file +// +// Use "go help work " for more information about a command. +// +// Edit go.work from tools or scripts +// +// Usage: +// +// go work edit [editing flags] [go.work] +// +// Editwork provides a command-line interface for editing go.work, +// for use primarily by tools or scripts. It only reads go.work; +// it does not look up information about the modules involved. +// If no file is specified, editwork looks for a go.work file in the current +// directory and its parent directories +// +// The editing flags specify a sequence of editing operations. +// +// The -fmt flag reformats the go.work file without making other changes. +// This reformatting is also implied by any other modifications that use or +// rewrite the go.mod file. The only time this flag is needed is if no other +// flags are specified, as in 'go mod editwork -fmt'. +// +// The -directory=path and -dropdirectory=path flags +// add and drop a directory from the go.work files set of module directories. +// +// The -replace=old[@v]=new[@v] flag adds a replacement of the given +// module path and version pair. If the @v in old@v is omitted, a +// replacement without a version on the left side is added, which applies +// to all versions of the old module path. If the @v in new@v is omitted, +// the new path should be a local module root directory, not a module +// path. Note that -replace overrides any redundant replacements for old[@v], +// so omitting @v will drop existing replacements for specific versions. +// +// The -dropreplace=old[@v] flag drops a replacement of the given +// module path and version pair. If the @v is omitted, a replacement without +// a version on the left side is dropped. +// +// The -directory, -dropdirectory, -replace, and -dropreplace, +// editing flags may be repeated, and the changes are applied in the order given. +// +// The -go=version flag sets the expected Go language version. +// +// The -print flag prints the final go.work in its text format instead of +// writing it back to go.mod. +// +// The -json flag prints the final go.work file in JSON format instead of +// writing it back to go.mod. The JSON output corresponds to these Go types: +// +// type Module struct { +// Path string +// Version string +// } +// +// type GoWork struct { +// Go string +// Directory []Directory +// Replace []Replace +// } +// +// type Directory struct { +// Path string +// ModulePath string +// } +// +// type Replace struct { +// Old Module +// New Module +// } +// +// See the workspaces design proposal at +// https://go.googlesource.com/proposal/+/master/design/45713-workspace.md for +// more information. +// +// +// Initialize workspace file +// +// Usage: +// +// go work init [moddirs] +// +// go mod initwork initializes and writes a new go.work file in the current +// directory, in effect creating a new workspace at the current directory. +// +// go mod initwork optionally accepts paths to the workspace modules as arguments. +// If the argument is omitted, an empty workspace with no modules will be created. +// +// See the workspaces design proposal at +// https://go.googlesource.com/proposal/+/master/design/45713-workspace.md for +// more information. +// +// // Compile and run Go program // // Usage: diff --git a/src/cmd/go/internal/modcmd/mod.go b/src/cmd/go/internal/modcmd/mod.go index 29aad58324..d72d0cacd6 100644 --- a/src/cmd/go/internal/modcmd/mod.go +++ b/src/cmd/go/internal/modcmd/mod.go @@ -23,10 +23,8 @@ See 'go help modules' for an overview of module functionality. Commands: []*base.Command{ cmdDownload, cmdEdit, - cmdEditwork, cmdGraph, cmdInit, - cmdInitwork, cmdTidy, cmdVendor, cmdVerify, diff --git a/src/cmd/go/internal/modcmd/editwork.go b/src/cmd/go/internal/workcmd/edit.go similarity index 74% rename from src/cmd/go/internal/modcmd/editwork.go rename to src/cmd/go/internal/workcmd/edit.go index 50f86366a0..f4e630f43f 100644 --- a/src/cmd/go/internal/modcmd/editwork.go +++ b/src/cmd/go/internal/workcmd/edit.go @@ -2,9 +2,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// go mod editwork +// go work edit -package modcmd +package workcmd import ( "bytes" @@ -14,15 +14,18 @@ import ( "context" "encoding/json" "errors" + "fmt" "os" "path/filepath" "strings" + "golang.org/x/mod/module" + "golang.org/x/mod/modfile" ) -var cmdEditwork = &base.Command{ - UsageLine: "go mod editwork [editing flags] [go.work]", +var cmdEdit = &base.Command{ + UsageLine: "go work edit [editing flags] [go.work]", Short: "edit go.work from tools or scripts", Long: `Editwork provides a command-line interface for editing go.work, for use primarily by tools or scripts. It only reads go.work; @@ -91,37 +94,42 @@ more information. } var ( - editworkFmt = cmdEditwork.Flag.Bool("fmt", false, "") - editworkGo = cmdEditwork.Flag.String("go", "", "") - editworkJSON = cmdEditwork.Flag.Bool("json", false, "") - editworkPrint = cmdEditwork.Flag.Bool("print", false, "") - workedits []func(file *modfile.WorkFile) // edits specified in flags + editFmt = cmdEdit.Flag.Bool("fmt", false, "") + editGo = cmdEdit.Flag.String("go", "", "") + editJSON = cmdEdit.Flag.Bool("json", false, "") + editPrint = cmdEdit.Flag.Bool("print", false, "") + workedits []func(file *modfile.WorkFile) // edits specified in flags ) +type flagFunc func(string) + +func (f flagFunc) String() string { return "" } +func (f flagFunc) Set(s string) error { f(s); return nil } + func init() { - cmdEditwork.Run = runEditwork // break init cycle + cmdEdit.Run = runEditwork // break init cycle - cmdEditwork.Flag.Var(flagFunc(flagEditworkDirectory), "directory", "") - cmdEditwork.Flag.Var(flagFunc(flagEditworkDropDirectory), "dropdirectory", "") - cmdEditwork.Flag.Var(flagFunc(flagEditworkReplace), "replace", "") - cmdEditwork.Flag.Var(flagFunc(flagEditworkDropReplace), "dropreplace", "") + cmdEdit.Flag.Var(flagFunc(flagEditworkDirectory), "directory", "") + cmdEdit.Flag.Var(flagFunc(flagEditworkDropDirectory), "dropdirectory", "") + cmdEdit.Flag.Var(flagFunc(flagEditworkReplace), "replace", "") + cmdEdit.Flag.Var(flagFunc(flagEditworkDropReplace), "dropreplace", "") - base.AddWorkfileFlag(&cmdEditwork.Flag) + base.AddWorkfileFlag(&cmdEdit.Flag) } func runEditwork(ctx context.Context, cmd *base.Command, args []string) { anyFlags := - *editworkGo != "" || - *editworkJSON || - *editworkPrint || - *editworkFmt || + *editGo != "" || + *editJSON || + *editPrint || + *editFmt || len(workedits) > 0 if !anyFlags { base.Fatalf("go: no flags specified (see 'go help mod editwork').") } - if *editworkJSON && *editworkPrint { + if *editJSON && *editPrint { base.Fatalf("go: cannot use both -json and -print") } @@ -136,8 +144,8 @@ func runEditwork(ctx context.Context, cmd *base.Command, args []string) { gowork = modload.WorkFilePath() } - if *editworkGo != "" { - if !modfile.GoVersionRE.MatchString(*editworkGo) { + if *editGo != "" { + if !modfile.GoVersionRE.MatchString(*editGo) { base.Fatalf(`go mod: invalid -go option; expecting something like "-go %s"`, modload.LatestGoVersion()) } } @@ -152,8 +160,8 @@ func runEditwork(ctx context.Context, cmd *base.Command, args []string) { base.Fatalf("go: errors parsing %s:\n%s", base.ShortPath(gowork), err) } - if *editworkGo != "" { - if err := workFile.AddGoStmt(*editworkGo); err != nil { + if *editGo != "" { + if err := workFile.AddGoStmt(*editGo); err != nil { base.Fatalf("go: internal error: %v", err) } } @@ -166,14 +174,14 @@ func runEditwork(ctx context.Context, cmd *base.Command, args []string) { workFile.SortBlocks() workFile.Cleanup() // clean file after edits - if *editworkJSON { - editworkPrintJSON(workFile) + if *editJSON { + editPrintJSON(workFile) return } out := modfile.Format(workFile.Syntax) - if *editworkPrint { + if *editPrint { os.Stdout.Write(out) return } @@ -213,6 +221,34 @@ func flagEditworkDropDirectory(arg string) { }) } +// allowedVersionArg returns whether a token may be used as a version in go.mod. +// We don't call modfile.CheckPathVersion, because that insists on versions +// being in semver form, but here we want to allow versions like "master" or +// "1234abcdef", which the go command will resolve the next time it runs (or +// during -fix). Even so, we need to make sure the version is a valid token. +func allowedVersionArg(arg string) bool { + return !modfile.MustQuote(arg) +} + +// parsePathVersionOptional parses path[@version], using adj to +// describe any errors. +func parsePathVersionOptional(adj, arg string, allowDirPath bool) (path, version string, err error) { + if i := strings.Index(arg, "@"); i < 0 { + path = arg + } else { + path, version = strings.TrimSpace(arg[:i]), strings.TrimSpace(arg[i+1:]) + } + if err := module.CheckImportPath(path); err != nil { + if !allowDirPath || !modfile.IsDirectoryPath(path) { + return path, version, fmt.Errorf("invalid %s path: %v", adj, err) + } + } + if path != arg && !allowedVersionArg(version) { + return path, version, fmt.Errorf("invalid %s version: %q", adj, version) + } + return path, version, nil +} + // flagReplace implements the -replace flag. func flagEditworkReplace(arg string) { var i int @@ -255,8 +291,13 @@ func flagEditworkDropReplace(arg string) { }) } +type replaceJSON struct { + Old module.Version + New module.Version +} + // editPrintJSON prints the -json output. -func editworkPrintJSON(workFile *modfile.WorkFile) { +func editPrintJSON(workFile *modfile.WorkFile) { var f workfileJSON if workFile.Go != nil { f.Go = workFile.Go.Version diff --git a/src/cmd/go/internal/modcmd/initwork.go b/src/cmd/go/internal/workcmd/init.go similarity index 83% rename from src/cmd/go/internal/modcmd/initwork.go rename to src/cmd/go/internal/workcmd/init.go index 4182aa071d..1342748023 100644 --- a/src/cmd/go/internal/modcmd/initwork.go +++ b/src/cmd/go/internal/workcmd/init.go @@ -4,7 +4,7 @@ // go mod initwork -package modcmd +package workcmd import ( "cmd/go/internal/base" @@ -17,8 +17,8 @@ var _ = modload.TODOWorkspaces("Add more documentation below. Though this is" + "enough for those trying workspaces out, there should be more through" + "documentation if the proposal is accepted and released.") -var cmdInitwork = &base.Command{ - UsageLine: "go mod initwork [moddirs]", +var cmdInit = &base.Command{ + UsageLine: "go work init [moddirs]", Short: "initialize workspace file", Long: `go mod initwork initializes and writes a new go.work file in the current directory, in effect creating a new workspace at the current directory. @@ -30,15 +30,15 @@ See the workspaces design proposal at https://go.googlesource.com/proposal/+/master/design/45713-workspace.md for more information. `, - Run: runInitwork, + Run: runInit, } func init() { - base.AddModCommonFlags(&cmdInitwork.Flag) - base.AddWorkfileFlag(&cmdInitwork.Flag) + base.AddModCommonFlags(&cmdInit.Flag) + base.AddWorkfileFlag(&cmdInit.Flag) } -func runInitwork(ctx context.Context, cmd *base.Command, args []string) { +func runInit(ctx context.Context, cmd *base.Command, args []string) { modload.InitWorkfile() modload.ForceUseModules = true diff --git a/src/cmd/go/internal/workcmd/work.go b/src/cmd/go/internal/workcmd/work.go new file mode 100644 index 0000000000..2e7f68b675 --- /dev/null +++ b/src/cmd/go/internal/workcmd/work.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 workcmd implements the ``go work'' command. +package workcmd + +import ( + "cmd/go/internal/base" +) + +var CmdWork = &base.Command{ + UsageLine: "go work", + Short: "workspace maintenance", + Long: `Go workspace provides access to operations on worskpaces. + +Note that support for workspaces is built into many other commands, +not just 'go work'. + +See 'go help modules' for information about Go's module system of +which workspaces are a part. +`, + + Commands: []*base.Command{ + cmdEdit, + cmdInit, + }, +} diff --git a/src/cmd/go/main.go b/src/cmd/go/main.go index 16361e02ca..c0a1d3ccfc 100644 --- a/src/cmd/go/main.go +++ b/src/cmd/go/main.go @@ -7,6 +7,7 @@ package main import ( + "cmd/go/internal/workcmd" "context" "flag" "fmt" @@ -56,6 +57,7 @@ func init() { work.CmdInstall, list.CmdList, modcmd.CmdMod, + workcmd.CmdWork, run.CmdRun, test.CmdTest, tool.CmdTool, diff --git a/src/cmd/go/testdata/script/work.txt b/src/cmd/go/testdata/script/work.txt index 613f037615..68bd3ea08b 100644 --- a/src/cmd/go/testdata/script/work.txt +++ b/src/cmd/go/testdata/script/work.txt @@ -1,9 +1,9 @@ -! go mod initwork doesnotexist +! go work init doesnotexist stderr 'go: creating workspace file: no go.mod file exists in directory doesnotexist' go env GOWORK ! stdout . -go mod initwork ./a ./b +go work init ./a ./b cmp go.work go.work.want go env GOWORK stdout '^'$WORK'(\\|/)gopath(\\|/)src(\\|/)go.work$' diff --git a/src/cmd/go/testdata/script/work_edit.txt b/src/cmd/go/testdata/script/work_edit.txt index 979c1f98e0..060d1f0386 100644 --- a/src/cmd/go/testdata/script/work_edit.txt +++ b/src/cmd/go/testdata/script/work_edit.txt @@ -1,36 +1,36 @@ # Test editing go.work files. -go mod initwork m +go work init m cmp go.work go.work.want_initial -go mod editwork -directory n +go work edit -directory n cmp go.work go.work.want_directory_n -go mod editwork -go 1.18 +go work edit -go 1.18 cmp go.work go.work.want_go_118 -go mod editwork -dropdirectory m +go work edit -dropdirectory m cmp go.work go.work.want_dropdirectory_m -go mod editwork -replace=x.1@v1.3.0=y.1@v1.4.0 -replace='x.1@v1.4.0 = ../z' +go work edit -replace=x.1@v1.3.0=y.1@v1.4.0 -replace='x.1@v1.4.0 = ../z' cmp go.work go.work.want_add_replaces -go mod editwork -directory n -directory ../a -directory /b -directory c -directory c +go work edit -directory n -directory ../a -directory /b -directory c -directory c cmp go.work go.work.want_multidirectory -go mod editwork -dropdirectory /b -dropdirectory n +go work edit -dropdirectory /b -dropdirectory n cmp go.work go.work.want_multidropdirectory -go mod editwork -dropreplace='x.1@v1.4.0' +go work edit -dropreplace='x.1@v1.4.0' cmp go.work go.work.want_dropreplace -go mod editwork -print -go 1.19 -directory b -dropdirectory c -replace 'x.1@v1.4.0 = ../z' -dropreplace x.1 -dropreplace x.1@v1.3.0 +go work edit -print -go 1.19 -directory b -dropdirectory c -replace 'x.1@v1.4.0 = ../z' -dropreplace x.1 -dropreplace x.1@v1.3.0 cmp stdout go.work.want_print -go mod editwork -json -go 1.19 -directory b -dropdirectory c -replace 'x.1@v1.4.0 = ../z' -dropreplace x.1 -dropreplace x.1@v1.3.0 +go work edit -json -go 1.19 -directory b -dropdirectory c -replace 'x.1@v1.4.0 = ../z' -dropreplace x.1 -dropreplace x.1@v1.3.0 cmp stdout go.work.want_json -go mod editwork -print -fmt -workfile $GOPATH/src/unformatted +go work edit -print -fmt -workfile $GOPATH/src/unformatted cmp stdout formatted -- m/go.mod -- diff --git a/src/cmd/go/testdata/script/work_replace_conflict.txt b/src/cmd/go/testdata/script/work_replace_conflict.txt index a2f76d13a0..f91b63cd86 100644 --- a/src/cmd/go/testdata/script/work_replace_conflict.txt +++ b/src/cmd/go/testdata/script/work_replace_conflict.txt @@ -3,7 +3,7 @@ ! go list -m example.com/dep stderr 'go: conflicting replacements for example.com/dep@v1.0.0:\n\t./dep1\n\t./dep2\nuse "go mod editwork -replace example.com/dep@v1.0.0=\[override\]" to resolve' -go mod editwork -replace example.com/dep@v1.0.0=./dep1 +go work edit -replace example.com/dep@v1.0.0=./dep1 go list -m example.com/dep stdout 'example.com/dep v1.0.0 => ./dep1' From 955f9f56bf21dca045c042a2a8998a2fc04117a4 Mon Sep 17 00:00:00 2001 From: Matthew Dempsky Date: Mon, 8 Nov 2021 13:13:30 -0800 Subject: [PATCH 034/752] test: add regress test for reported non-monomorphizable example Fixes #48711. Change-Id: I2ed1ef5267343d4b9f91da0618905098d178db90 Reviewed-on: https://go-review.googlesource.com/c/go/+/362394 Trust: Matthew Dempsky Run-TryBot: Matthew Dempsky TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- test/typeparam/issue48711.go | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 test/typeparam/issue48711.go diff --git a/test/typeparam/issue48711.go b/test/typeparam/issue48711.go new file mode 100644 index 0000000000..d09a72e576 --- /dev/null +++ b/test/typeparam/issue48711.go @@ -0,0 +1,18 @@ +// errorcheck -G=3 + +// 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 f[T interface{ ~[]P }, P any](t T) { // ERROR "instantiation cycle" + if t == nil { + return + } + f[[]T, T]([]T{t}) +} + +func main() { + f[[]int](nil) +} From 67e22941dfe1555d8597e48f49ff86d3be340a36 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 8 Nov 2021 21:45:58 +0000 Subject: [PATCH 035/752] Revert "cmd/go: add workspace pruning mode" MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts CL 357169. Reason for revert: appears to be failing on longtest SlowBot.¹ ¹https://storage.googleapis.com/go-build-log/a97c855b/linux-amd64-longtest_7c9857d4.log Change-Id: I3b94395671db78ed5fb2fb1019e7199e4ffbd272 Reviewed-on: https://go-review.googlesource.com/c/go/+/362249 Trust: Bryan C. Mills Run-TryBot: Bryan C. Mills Reviewed-by: Michael Matloob TryBot-Result: Go Bot --- src/cmd/go/internal/modload/buildlist.go | 86 ++++++----------------- src/cmd/go/internal/modload/init.go | 44 ++++++------ src/cmd/go/internal/modload/load.go | 24 +------ src/cmd/go/internal/modload/modfile.go | 14 ++-- src/cmd/go/testdata/script/work_prune.txt | 2 +- 5 files changed, 49 insertions(+), 121 deletions(-) diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go index 9e56265a41..27cab0b9c8 100644 --- a/src/cmd/go/internal/modload/buildlist.go +++ b/src/cmd/go/internal/modload/buildlist.go @@ -38,17 +38,11 @@ type Requirements struct { // If pruned, the graph includes only the root modules, the explicit // requirements of those root modules, and the transitive requirements of only // the root modules that do not support pruning. - // - // If workspace, the graph includes only the workspace modules, the explicit - // requirements of the workspace modules, and the transitive requirements of - // the workspace modules that do not support pruning. pruning modPruning - // rootModules is the set of root modules of the graph, sorted and capped to - // length. It may contain duplicates, and may contain multiple versions for a - // given module path. The root modules of the groph are the set of main - // modules in workspace mode, and the main module's direct requirements - // outside workspace mode. + // rootModules is the set of module versions explicitly required by the main + // modules, sorted and capped to length. It may contain duplicates, and may + // contain multiple versions for a given module path. rootModules []module.Version maxRootVersion map[string]string @@ -105,19 +99,6 @@ var requirements *Requirements // If vendoring is in effect, the caller must invoke initVendor on the returned // *Requirements before any other method. func newRequirements(pruning modPruning, rootModules []module.Version, direct map[string]bool) *Requirements { - if pruning == workspace { - return &Requirements{ - pruning: pruning, - rootModules: capVersionSlice(rootModules), - maxRootVersion: nil, - direct: direct, - } - } - - if inWorkspaceMode() && pruning != workspace { - panic("in workspace mode, but pruning is not workspace in newRequirements") - } - for i, m := range rootModules { if m.Version == "" && MainModules.Contains(m.Path) { panic(fmt.Sprintf("newRequirements called with untrimmed build list: rootModules[%v] is a main module", i)) @@ -310,11 +291,13 @@ func readModGraph(ctx context.Context, pruning modPruning, roots []module.Versio g: mvs.NewGraph(cmpVersion, MainModules.Versions()), } ) - if pruning != workspace { - if inWorkspaceMode() { - panic("pruning is not workspace in workspace mode") - } - mg.g.Require(MainModules.mustGetSingleMainModule(), roots) + for _, m := range MainModules.Versions() { + // Require all roots from all main modules. + _ = TODOWorkspaces("This flattens a level of the module graph, adding the dependencies " + + "of all main modules to a single requirements struct, and losing the information of which " + + "main module required which requirement. Rework the requirements struct and change this" + + "to reflect the structure of the main modules.") + mg.g.Require(m, roots) } var ( @@ -369,13 +352,9 @@ func readModGraph(ctx context.Context, pruning modPruning, roots []module.Versio // are sufficient to build the packages it contains. We must load its full // transitive dependency graph to be sure that we see all relevant // dependencies. - if pruning != pruned || summary.pruning == unpruned { - nextPruning := summary.pruning - if pruning == unpruned { - nextPruning = unpruned - } + if pruning == unpruned || summary.pruning == unpruned { for _, r := range summary.require { - enqueue(r, nextPruning) + enqueue(r, unpruned) } } }) @@ -445,15 +424,12 @@ func (mg *ModuleGraph) findError() error { } func (mg *ModuleGraph) allRootsSelected() bool { - var roots []module.Version - if inWorkspaceMode() { - roots = MainModules.Versions() - } else { - roots, _ = mg.g.RequiredBy(MainModules.mustGetSingleMainModule()) - } - for _, m := range roots { - if mg.Selected(m.Path) != m.Version { - return false + for _, mm := range MainModules.Versions() { + roots, _ := mg.g.RequiredBy(mm) + for _, m := range roots { + if mg.Selected(m.Path) != m.Version { + return false + } } } return true @@ -600,29 +576,10 @@ func tidyRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Require } func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version, rootsImported bool) (*Requirements, error) { - switch rs.pruning { - case unpruned: + if rs.pruning == unpruned { return updateUnprunedRoots(ctx, direct, rs, add) - case pruned: - return updatePrunedRoots(ctx, direct, rs, pkgs, add, rootsImported) - case workspace: - return updateWorkspaceRoots(ctx, rs, add) - default: - panic(fmt.Sprintf("unsupported pruning mode: %v", rs.pruning)) } -} - -func updateWorkspaceRoots(ctx context.Context, rs *Requirements, add []module.Version) (*Requirements, error) { - if len(add) != 0 { - // add should be empty in workspace mode because a non-empty add slice means - // that there are missing roots in the current pruning mode or that the - // pruning mode is being changed. But the pruning mode should always be - // 'workspace' in workspace mode and the set of roots in workspace mode is - // always complete because it's the set of workspace modules, which can't - // be edited by loading. - panic("add is not empty") - } - return rs, nil + return updatePrunedRoots(ctx, direct, rs, pkgs, add, rootsImported) } // tidyPrunedRoots returns a minimal set of root requirements that maintains the @@ -1199,6 +1156,7 @@ func updateUnprunedRoots(ctx context.Context, direct map[string]bool, rs *Requir } } + // TODO(matloob): Make roots into a map. var roots []module.Version for _, mainModule := range MainModules.Versions() { min, err := mvs.Req(mainModule, rootPaths, &mvsReqs{roots: keep}) @@ -1224,8 +1182,6 @@ func updateUnprunedRoots(ctx context.Context, direct map[string]bool, rs *Requir func convertPruning(ctx context.Context, rs *Requirements, pruning modPruning) (*Requirements, error) { if rs.pruning == pruning { return rs, nil - } else if rs.pruning == workspace || pruning == workspace { - panic("attempthing to convert to/from workspace pruning and another pruning type") } if pruning == unpruned { diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go index 512c9ebfbd..9aef5a7c33 100644 --- a/src/cmd/go/internal/modload/init.go +++ b/src/cmd/go/internal/modload/init.go @@ -704,7 +704,7 @@ func LoadModFile(ctx context.Context) *Requirements { } } - if MainModules.Index(mainModule).goVersionV == "" && rs.pruning != workspace { + if MainModules.Index(mainModule).goVersionV == "" { // TODO(#45551): Do something more principled instead of checking // cfg.CmdName directly here. if cfg.BuildMod == "mod" && cfg.CmdName != "mod graph" && cfg.CmdName != "mod why" { @@ -987,29 +987,29 @@ func makeMainModules(ms []module.Version, rootDirs []string, modFiles []*modfile // requirementsFromModFiles returns the set of non-excluded requirements from // the global modFile. func requirementsFromModFiles(ctx context.Context, modFiles []*modfile.File) *Requirements { - var roots []module.Version + rootCap := 0 + for i := range modFiles { + rootCap += len(modFiles[i].Require) + } + roots := make([]module.Version, 0, rootCap) + mPathCount := make(map[string]int) + for _, m := range MainModules.Versions() { + mPathCount[m.Path] = 1 + } direct := map[string]bool{} - var pruning modPruning - if inWorkspaceMode() { - pruning = workspace - roots = make([]module.Version, len(MainModules.Versions())) - copy(roots, MainModules.Versions()) - } else { - pruning = pruningForGoVersion(MainModules.GoVersion()) - if len(modFiles) != 1 { - panic(fmt.Errorf("requirementsFromModFiles called with %v modfiles outside workspace mode", len(modFiles))) - } - modFile := modFiles[0] - roots = make([]module.Version, 0, len(modFile.Require)) - mm := MainModules.mustGetSingleMainModule() + for _, modFile := range modFiles { + requirement: for _, r := range modFile.Require { - if index := MainModules.Index(mm); index != nil && index.exclude[r.Mod] { - if cfg.BuildMod == "mod" { - fmt.Fprintf(os.Stderr, "go: dropping requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) - } else { - fmt.Fprintf(os.Stderr, "go: ignoring requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) + // TODO(#45713): Maybe join + for _, mainModule := range MainModules.Versions() { + if index := MainModules.Index(mainModule); index != nil && index.exclude[r.Mod] { + if cfg.BuildMod == "mod" { + fmt.Fprintf(os.Stderr, "go: dropping requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) + } else { + fmt.Fprintf(os.Stderr, "go: ignoring requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) + } + continue requirement } - continue } roots = append(roots, r.Mod) @@ -1019,7 +1019,7 @@ func requirementsFromModFiles(ctx context.Context, modFiles []*modfile.File) *Re } } module.Sort(roots) - rs := newRequirements(pruning, roots, direct) + rs := newRequirements(pruningForGoVersion(MainModules.GoVersion()), roots, direct) return rs } diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go index 83fcafead3..845bf2f8a2 100644 --- a/src/cmd/go/internal/modload/load.go +++ b/src/cmd/go/internal/modload/load.go @@ -1004,11 +1004,7 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader { } var err error - desiredPruning := pruningForGoVersion(ld.GoVersion) - if ld.requirements.pruning == workspace { - desiredPruning = workspace - } - ld.requirements, err = convertPruning(ctx, ld.requirements, desiredPruning) + ld.requirements, err = convertPruning(ctx, ld.requirements, pruningForGoVersion(ld.GoVersion)) if err != nil { ld.errorf("go: %v\n", err) } @@ -1250,24 +1246,6 @@ func (ld *loader) updateRequirements(ctx context.Context) (changed bool, err err continue } - if inWorkspaceMode() { - // In workspace mode / workspace pruning mode, the roots are the main modules - // rather than the main module's direct dependencies. The check below on the selected - // roots does not apply. - if mg, err := rs.Graph(ctx); err != nil { - return false, err - } else if _, ok := mg.RequiredBy(dep.mod); !ok { - // dep.mod is not an explicit dependency, but needs to be. - // See comment on error returned below. - pkg.err = &DirectImportFromImplicitDependencyError{ - ImporterPath: pkg.path, - ImportedPath: dep.path, - Module: dep.mod, - } - } - continue - } - if pkg.err == nil && cfg.BuildMod != "mod" { if v, ok := rs.rootSelected(dep.mod.Path); !ok || v != dep.mod.Version { // dep.mod is not an explicit dependency, but needs to be. diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go index 40e6ed787d..a7e92222a1 100644 --- a/src/cmd/go/internal/modload/modfile.go +++ b/src/cmd/go/internal/modload/modfile.go @@ -118,9 +118,8 @@ type requireMeta struct { type modPruning uint8 const ( - pruned modPruning = iota // transitive dependencies of modules at go 1.17 and higher are pruned out - unpruned // no transitive dependencies are pruned out - workspace // pruned to the union of modules in the workspace + pruned modPruning = iota // transitive dependencies of modules at go 1.17 and higher are pruned out + unpruned // no transitive dependencies are pruned out ) func pruningForGoVersion(goVersion string) modPruning { @@ -555,7 +554,7 @@ type retraction struct { // // The caller must not modify the returned summary. func goModSummary(m module.Version) (*modFileSummary, error) { - if m.Version == "" && !inWorkspaceMode() && MainModules.Contains(m.Path) { + if m.Version == "" && MainModules.Contains(m.Path) { panic("internal error: goModSummary called on a main module") } @@ -719,14 +718,9 @@ var rawGoModSummaryCache par.Cache // module.Version → rawGoModSummary result func rawGoModData(m module.Version) (name string, data []byte, err error) { if m.Version == "" { // m is a replacement module with only a file path. - dir := m.Path if !filepath.IsAbs(dir) { - if inWorkspaceMode() && MainModules.Contains(m.Path) { - dir = MainModules.ModRoot(m) - } else { - dir = filepath.Join(replaceRelativeTo(), dir) - } + dir = filepath.Join(replaceRelativeTo(), dir) } name = filepath.Join(dir, "go.mod") if gomodActual, ok := fsys.OverlayPath(name); ok { diff --git a/src/cmd/go/testdata/script/work_prune.txt b/src/cmd/go/testdata/script/work_prune.txt index 00c3e10663..f0fb073c4b 100644 --- a/src/cmd/go/testdata/script/work_prune.txt +++ b/src/cmd/go/testdata/script/work_prune.txt @@ -14,7 +14,7 @@ # TODO(#48331): We currently load the wrong version of q. Fix this. go list -m -f '{{.Version}}' example.com/q -stdout '^v1.1.0$' +stdout '^v1.0.0$' # TODO(#48331): This should be 1.1.0. Fix this. -- go.work -- go 1.18 From bee0c739007617c840ac29a6f8fcf9f24cbf1505 Mon Sep 17 00:00:00 2001 From: Cuong Manh Le Date: Mon, 8 Nov 2021 13:08:58 +0700 Subject: [PATCH 036/752] cmd/compile: fix irgen mis-handling of ... argument when creating closure When bulding formal arguments of newly created closure, irgen forgets to set "..." field attribute, causing type mismatched between the closure function and the ONAME node represents that closure function. Fixes #49432 Change-Id: Ieddaa64980cdd3d8cea236a5a9de0204ee21ee39 Reviewed-on: https://go-review.googlesource.com/c/go/+/361961 Trust: Cuong Manh Le Trust: Dan Scales Run-TryBot: Cuong Manh Le TryBot-Result: Go Bot Reviewed-by: Dan Scales --- src/cmd/compile/internal/noder/stencil.go | 1 + test/typeparam/issue49432.go | 22 ++++++++++++++++++++++ 2 files changed, 23 insertions(+) create mode 100644 test/typeparam/issue49432.go diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go index 74281bc479..4ebd607c16 100644 --- a/src/cmd/compile/internal/noder/stencil.go +++ b/src/cmd/compile/internal/noder/stencil.go @@ -2085,6 +2085,7 @@ func startClosure(pos src.XPos, outer *ir.Func, typ *types.Type) (*ir.Func, []*t fn.Dcl = append(fn.Dcl, arg) f := types.NewField(pos, arg.Sym(), t) f.Nname = arg + f.SetIsDDD(typ.Params().Field(i).IsDDD()) formalParams = append(formalParams, f) } for i := 0; i < typ.NumResults(); i++ { diff --git a/test/typeparam/issue49432.go b/test/typeparam/issue49432.go new file mode 100644 index 0000000000..21d6ec4b70 --- /dev/null +++ b/test/typeparam/issue49432.go @@ -0,0 +1,22 @@ +// compile -G=3 + +// 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 + +type Handler func(in ...interface{}) + +type Foo[T any] struct{} + +func (b *Foo[T]) Bar(in ...interface{}) {} + +func (b *Foo[T]) Init() { + _ = Handler(b.Bar) +} + +func main() { + c := &Foo[int]{} + c.Init() +} From 5344dcae4139de85b9e3d8cea81f9b65fc2bd25f Mon Sep 17 00:00:00 2001 From: Cuong Manh Le Date: Mon, 8 Nov 2021 15:51:05 +0700 Subject: [PATCH 037/752] cmd/compile: remove unneeded "==" method in pre-defined "comparable" interface Fixes #49421 Change-Id: Iecf3952346ecd278198c1000014a321e230f7fa7 Reviewed-on: https://go-review.googlesource.com/c/go/+/361962 Trust: Cuong Manh Le Trust: Dan Scales Run-TryBot: Cuong Manh Le TryBot-Result: Go Bot Reviewed-by: Dan Scales --- .../compile/internal/reflectdata/reflect.go | 6 ----- src/cmd/compile/internal/types/universe.go | 6 ++--- test/typeparam/issue49421.go | 27 +++++++++++++++++++ 3 files changed, 30 insertions(+), 9 deletions(-) create mode 100644 test/typeparam/issue49421.go diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go index d396c249e4..4e20dbf29e 100644 --- a/src/cmd/compile/internal/reflectdata/reflect.go +++ b/src/cmd/compile/internal/reflectdata/reflect.go @@ -1304,12 +1304,6 @@ func writeITab(lsym *obj.LSym, typ, iface *types.Type) { break } } - if sigs[0].Sym.Name == "==" { - sigs = sigs[1:] - if len(sigs) == 0 { - break - } - } } if len(sigs) != 0 { base.Fatalf("incomplete itab") diff --git a/src/cmd/compile/internal/types/universe.go b/src/cmd/compile/internal/types/universe.go index d5239eb10c..13f62a3ab2 100644 --- a/src/cmd/compile/internal/types/universe.go +++ b/src/cmd/compile/internal/types/universe.go @@ -148,8 +148,8 @@ func makeErrorInterface() *Type { return NewInterface(NoPkg, []*Field{method}, false) } +// makeComparableInterface makes the the predefined "comparable" interface in the +// built-in package. It has a unique name, but no methods. func makeComparableInterface() *Type { - sig := NewSignature(NoPkg, FakeRecv(), nil, nil, nil) - method := NewField(src.NoXPos, LocalPkg.Lookup("=="), sig) - return NewInterface(NoPkg, []*Field{method}, false) + return NewInterface(NoPkg, nil, false) } diff --git a/test/typeparam/issue49421.go b/test/typeparam/issue49421.go new file mode 100644 index 0000000000..526e038bec --- /dev/null +++ b/test/typeparam/issue49421.go @@ -0,0 +1,27 @@ +// run -gcflags=-G=3 + +// 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() { + var a, b foo + bar(a, b) +} + +type foo int + +func (a foo) less(b foo) bool { + return a < b +} + +type lesser[T any] interface { + less(T) bool + comparable +} + +func bar[T lesser[T]](a, b T) { + a.less(b) +} From 6dcf83d882a668894f4423045833e97f7e3c31cf Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Tue, 9 Nov 2021 01:23:02 +0100 Subject: [PATCH 038/752] runtime: revert recent Windows crashdump changes Recent changes to runtime enabled crashdumps, which under some circumstances apparently might result in memory being uploaded to Microsoft. A change like this should go through the proper proposals process where we can discuss how to gate it and what all of its implications are. This reverts CL 307372 and its cleanup CL 360617. Change-Id: If2e74015899d746831da40546c82eacacdf739e1 Reviewed-on: https://go-review.googlesource.com/c/go/+/362454 Trust: Jason A. Donenfeld Run-TryBot: Jason A. Donenfeld TryBot-Result: Go Bot Reviewed-by: Ian Lance Taylor --- src/runtime/os_windows.go | 4 -- src/runtime/panic.go | 11 ----- src/runtime/signal_windows.go | 87 +++++++++-------------------------- 3 files changed, 22 insertions(+), 80 deletions(-) diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go index 0e17e75e3e..648239fb36 100644 --- a/src/runtime/os_windows.go +++ b/src/runtime/os_windows.go @@ -40,7 +40,6 @@ const ( //go:cgo_import_dynamic runtime._LoadLibraryW LoadLibraryW%1 "kernel32.dll" //go:cgo_import_dynamic runtime._LoadLibraryA LoadLibraryA%1 "kernel32.dll" //go:cgo_import_dynamic runtime._PostQueuedCompletionStatus PostQueuedCompletionStatus%4 "kernel32.dll" -//go:cgo_import_dynamic runtime._RaiseException RaiseException%4 "kernel32.dll" //go:cgo_import_dynamic runtime._ResumeThread ResumeThread%1 "kernel32.dll" //go:cgo_import_dynamic runtime._SetConsoleCtrlHandler SetConsoleCtrlHandler%2 "kernel32.dll" //go:cgo_import_dynamic runtime._SetErrorMode SetErrorMode%1 "kernel32.dll" @@ -94,7 +93,6 @@ var ( _PostQueuedCompletionStatus, _QueryPerformanceCounter, _QueryPerformanceFrequency, - _RaiseException, _ResumeThread, _SetConsoleCtrlHandler, _SetErrorMode, @@ -122,7 +120,6 @@ var ( _AddVectoredContinueHandler, _LoadLibraryExA, _LoadLibraryExW, - _WerSetFlags, _ stdFunction // Use RtlGenRandom to generate cryptographically random data. @@ -257,7 +254,6 @@ func loadOptionalSyscalls() { _AddVectoredContinueHandler = windowsFindfunc(k32, []byte("AddVectoredContinueHandler\000")) _LoadLibraryExA = windowsFindfunc(k32, []byte("LoadLibraryExA\000")) _LoadLibraryExW = windowsFindfunc(k32, []byte("LoadLibraryExW\000")) - _WerSetFlags = windowsFindfunc(k32, []byte("WerSetFlags\000")) useLoadLibraryEx = (_LoadLibraryExW != nil && _LoadLibraryExA != nil && _AddDllDirectory != nil) var advapi32dll = []byte("advapi32.dll\000") diff --git a/src/runtime/panic.go b/src/runtime/panic.go index eec69dfdc6..3d5f4edb45 100644 --- a/src/runtime/panic.go +++ b/src/runtime/panic.go @@ -1002,11 +1002,6 @@ var runningPanicDefers uint32 // panicking is incremented and decremented atomically. var panicking uint32 -// tracebackprinted is zero before gopanic() prints the traceback. After -// traceback is printed, it sets to 1 so that the subsequent exception handler -// won't print the traceback again. -var tracebackprinted uint32 - // paniclk is held while printing the panic information and stack trace, // so that two concurrent panics don't overlap their output. var paniclk mutex @@ -1050,9 +1045,6 @@ func fatalthrow() { startpanic_m() if dopanic_m(gp, pc, sp) { - // At this point, traceback has already been printed. - // Set tracebackprinted to 1 to avoid printing traceback again - tracebackprinted = 1 // crash uses a decent amount of nosplit stack and we're already // low on stack in throw, so crash on the system stack (unlike // fatalpanic). @@ -1094,9 +1086,6 @@ func fatalpanic(msgs *_panic) { }) if docrash { - // At this point, traceback has already been printed. - // Set tracebackprinted to 1 to avoid printing traceback again - tracebackprinted = 1 // By crashing outside the above systemstack call, debuggers // will not be confused when generating a backtrace. // Function crash is marked nosplit to avoid stack growth. diff --git a/src/runtime/signal_windows.go b/src/runtime/signal_windows.go index b036f3c965..16c36d07f1 100644 --- a/src/runtime/signal_windows.go +++ b/src/runtime/signal_windows.go @@ -22,38 +22,6 @@ func disableWER() { stdcall1(_SetErrorMode, uintptr(errormode)|SEM_FAILCRITICALERRORS|SEM_NOGPFAULTERRORBOX|SEM_NOOPENFILEERRORBOX) } -// isWin7 returns true on Windows 7. Otherwise it returns false. -// -//go:nosplit -func isWin7() bool { - var maj, min, build uint32 - stdcall3(_RtlGetNtVersionNumbers, uintptr(unsafe.Pointer(&maj)), uintptr(unsafe.Pointer(&min)), uintptr(unsafe.Pointer(&build))) - return maj < 6 || (maj == 6 && min <= 1) -} - -// enableWERNoUI re-enables Windows error reporting without fault reporting UI. -// -// This is marked nosplit since it is used during crash. -// -//go:nosplit -func enableWERNoUI() bool { - if _WerSetFlags == nil { - return false - } - - // Disable Fault reporting UI - const ( - WER_FAULT_REPORTING_NO_UI = 0x0020 - ) - if stdcall1(_WerSetFlags, WER_FAULT_REPORTING_NO_UI) != 0 { - return false - } - - // re-enable Windows Error Reporting - stdcall1(_SetErrorMode, 0) - return true -} - // in sys_windows_386.s and sys_windows_amd64.s func exceptiontramp() func firstcontinuetramp() @@ -140,7 +108,6 @@ func exceptionhandler(info *exceptionrecord, r *context, gp *g) int32 { // Don't go through any more of the Windows handler chain. // Crash now. winthrow(info, r, gp) - exit(2) } // After this point, it is safe to grow the stack. @@ -229,20 +196,6 @@ func lastcontinuehandler(info *exceptionrecord, r *context, gp *g) int32 { } winthrow(info, r, gp) - - _, _, docrash := gotraceback() - if docrash { - // Windows 7 apears to ignore WER_FAULT_REPORTING_NO_UI - // WerSetFlags API flag. So do not call enableWERNoUI - // on Windows 7. - if !isWin7() { - // trigger crash dump creation - if enableWERNoUI() { - return _EXCEPTION_CONTINUE_SEARCH - } - } - } - exit(2) return 0 // not reached } @@ -250,6 +203,11 @@ func lastcontinuehandler(info *exceptionrecord, r *context, gp *g) int32 { func winthrow(info *exceptionrecord, r *context, gp *g) { _g_ := getg() + if panicking != 0 { // traceback already printed + exit(2) + } + panicking = 1 + // In case we're handling a g0 stack overflow, blow away the // g0 stack bounds so we have room to print the traceback. If // this somehow overflows the stack, the OS will trap it. @@ -271,16 +229,18 @@ func winthrow(info *exceptionrecord, r *context, gp *g) { _g_.m.throwing = 1 _g_.m.caughtsig.set(gp) - level, _, _ := gotraceback() + level, _, docrash := gotraceback() if level > 0 { - // only print traceback when it hasn't been printed - if tracebackprinted == 0 { - tracebacktrap(r.ip(), r.sp(), r.lr(), gp) - tracebackothers(gp) - tracebackprinted = 1 - } + tracebacktrap(r.ip(), r.sp(), r.lr(), gp) + tracebackothers(gp) dumpregs(r) } + + if docrash { + crash() + } + + exit(2) } func sigpanic() { @@ -352,17 +312,14 @@ func signame(sig uint32) string { //go:nosplit func crash() { - // When GOTRACEBACK==crash, raise the same exception - // from kernel32.dll, so that Windows gets a chance - // to handle the exception by creating a crash dump. - - // Get the Exception code that caused the crash - gp := getg() - exceptionCode := gp.sig - - // RaiseException() here will not be handled in exceptionhandler() - // because it comes from kernel32.dll - stdcall4(_RaiseException, uintptr(unsafe.Pointer(&exceptionCode)), 0, 0, 0) + // TODO: This routine should do whatever is needed + // to make the Windows program abort/crash as it + // would if Go was not intercepting signals. + // On Unix the routine would remove the custom signal + // handler and then raise a signal (like SIGABRT). + // Something like that should happen here. + // It's okay to leave this empty for now: if crash returns + // the ordinary exit-after-panic happens. } // gsignalStack is unused on Windows. From b7529c3617a64ed5d1e2a6c7a9366d4a4988a38d Mon Sep 17 00:00:00 2001 From: Cuong Manh Le Date: Tue, 9 Nov 2021 10:37:43 +0700 Subject: [PATCH 039/752] cmd/go: fix mod_get_direct https://github.com/googleapis/google-cloud-go has changed the default branch from master to main, causing mod_get_direct failed on longtest. Change-Id: I8fe0356b2ff532d1fdedbcb1e1832d7335babaa0 Reviewed-on: https://go-review.googlesource.com/c/go/+/361965 Trust: Cuong Manh Le Run-TryBot: Cuong Manh Le TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/cmd/go/testdata/script/mod_get_direct.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cmd/go/testdata/script/mod_get_direct.txt b/src/cmd/go/testdata/script/mod_get_direct.txt index 42ccbcd38a..856e05bc32 100644 --- a/src/cmd/go/testdata/script/mod_get_direct.txt +++ b/src/cmd/go/testdata/script/mod_get_direct.txt @@ -10,7 +10,7 @@ env GO111MODULE=on env GOPROXY=direct env GOSUMDB=off -go list -m cloud.google.com/go@master +go list -m cloud.google.com/go@main ! stdout 'v0.0.0-' -- go.mod -- From 2559a98a3cda46084cbdd3ea49217fdc8074ce7a Mon Sep 17 00:00:00 2001 From: Katie Hockman Date: Mon, 8 Nov 2021 12:13:01 -0500 Subject: [PATCH 040/752] testing: remove package from fuzz crasher message Fixes #48149 Change-Id: Iaf91d2c54fda809c7da90cdfb6d1d075f474c69b Reviewed-on: https://go-review.googlesource.com/c/go/+/362116 Trust: Katie Hockman Run-TryBot: Katie Hockman Reviewed-by: Bryan C. Mills Reviewed-by: Julie Qiu --- src/testing/fuzz.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go index 10665168f4..46c9d63df4 100644 --- a/src/testing/fuzz.go +++ b/src/testing/fuzz.go @@ -356,7 +356,7 @@ func (f *F) Fuzz(ff interface{}) { crashPath := crashErr.CrashPath() fmt.Fprintf(f.w, "Crash written to %s\n", crashPath) testName := filepath.Base(crashPath) - fmt.Fprintf(f.w, "To re-run:\ngo test %s -run=%s/%s\n", f.fuzzContext.deps.ImportPath(), f.name, testName) + fmt.Fprintf(f.w, "To re-run:\ngo test -run=%s/%s\n", f.name, testName) } } // TODO(jayconrod,katiehockman): Aggregate statistics across workers From e90fd9a597c03b993f900e4b1997de67b12bb4f3 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Mon, 8 Nov 2021 13:09:41 -0500 Subject: [PATCH 041/752] go/types: rename isX predicates to allX, add simple is_X (step 1 of 2) This is a port of CL 360955 to go/types. Note that go/types and types2 differ in handling of untyped nil within both Checker.shift and Checker.implicitTypeAndValue. A missing comment was added to Checker.indexExpr. Change-Id: Ia9149ff9c0af68213c579090902ab7989828ddd2 Reviewed-on: https://go-review.googlesource.com/c/go/+/362534 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/types/builtins.go | 14 +++--- src/go/types/check.go | 6 +-- src/go/types/conversions.go | 12 ++--- src/go/types/expr.go | 90 ++++++++++++++++++------------------- src/go/types/index.go | 9 ++-- src/go/types/predicates.go | 66 +++++++++++++++++---------- src/go/types/sizes.go | 2 +- src/go/types/stmt.go | 8 ++-- src/go/types/typexpr.go | 2 +- 9 files changed, 115 insertions(+), 94 deletions(-) diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go index aefac786ca..0390ac0192 100644 --- a/src/go/types/builtins.go +++ b/src/go/types/builtins.go @@ -102,7 +102,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b if x.mode == invalid { return } - if isString(x.typ) { + if allString(x.typ) { if check.Types != nil { sig := makeSig(S, S, x.typ) sig.variadic = true @@ -147,7 +147,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b var val constant.Value switch typ = arrayPtrDeref(under(x.typ)); t := typ.(type) { case *Basic: - if isString(t) && id == _Len { + if is_String(t) && id == _Len { if x.mode == constant_ { mode = constant_ val = constant.MakeInt64(int64(len(constant.StringVal(x.val)))) @@ -183,7 +183,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b if t.underIs(func(t Type) bool { switch t := arrayPtrDeref(t).(type) { case *Basic: - if isString(t) && id == _Len { + if is_String(t) && id == _Len { return true } case *Array, *Slice, *Chan: @@ -272,7 +272,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b // because shifts of floats are not permitted) if x.mode == constant_ && y.mode == constant_ { toFloat := func(x *operand) { - if isNumeric(x.typ) && constant.Sign(constant.Imag(x.val)) == 0 { + if is_Numeric(x.typ) && constant.Sign(constant.Imag(x.val)) == 0 { x.typ = Typ[UntypedFloat] } } @@ -403,7 +403,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b if x.mode == constant_ { // an untyped constant number can always be considered // as a complex constant - if isNumeric(x.typ) { + if is_Numeric(x.typ) { x.typ = Typ[UntypedComplex] } } else { @@ -735,7 +735,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b // assert(pred) causes a typechecker error if pred is false. // The result of assert is the value of pred if there is no error. // Note: assert is only available in self-test mode. - if x.mode != constant_ || !isBoolean(x.typ) { + if x.mode != constant_ || !is_Boolean(x.typ) { check.invalidArg(x, _Test, "%s is not a boolean constant", x) return } @@ -801,7 +801,7 @@ func structure(typ Type) Type { func structureString(typ Type) Type { var su Type if underIs(typ, func(u Type) bool { - if isString(u) { + if is_String(u) { u = NewSlice(universeByte) } if su != nil && !Identical(su, u) { diff --git a/src/go/types/check.go b/src/go/types/check.go index 3a0e4a6a23..c828cf54e4 100644 --- a/src/go/types/check.go +++ b/src/go/types/check.go @@ -419,9 +419,9 @@ func (check *Checker) recordTypeAndValue(x ast.Expr, mode operandMode, typ Type, } if mode == constant_ { assert(val != nil) - // We check is(typ, IsConstType) here as constant expressions may be + // We check allBasic(typ, IsConstType) here as constant expressions may be // recorded as type parameters. - assert(typ == Typ[Invalid] || is(typ, IsConstType)) + assert(typ == Typ[Invalid] || allBasic(typ, IsConstType)) } if m := check.Types; m != nil { m[x] = TypeAndValue{mode, typ, val} @@ -451,7 +451,7 @@ func (check *Checker) recordCommaOkTypes(x ast.Expr, a [2]Type) { if a[0] == nil || a[1] == nil { return } - assert(isTyped(a[0]) && isTyped(a[1]) && (isBoolean(a[1]) || a[1] == universeError)) + assert(isTyped(a[0]) && isTyped(a[1]) && (is_Boolean(a[1]) || a[1] == universeError)) if m := check.Types; m != nil { for { tv := m[x] diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go index a6f0714ba0..c99bd6332a 100644 --- a/src/go/types/conversions.go +++ b/src/go/types/conversions.go @@ -22,7 +22,7 @@ func (check *Checker) conversion(x *operand, T Type) { // nothing to do case representableConst(x.val, check, t, val): return true - case isInteger(x.typ) && isString(t): + case is_Integer(x.typ) && is_String(t): codepoint := unicode.ReplacementChar if i, ok := constant.Uint64Val(x.val); ok && i <= unicode.MaxRune { codepoint = rune(i) @@ -91,7 +91,7 @@ func (check *Checker) conversion(x *operand, T Type) { // (See also the TODO below.) 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) { + } else if is_Integer(x.typ) && allString(T) { final = x.typ } check.updateExprType(x.expr, final, true) @@ -195,22 +195,22 @@ func convertibleToImpl(check *Checker, V, T Type, cause *string) bool { } // "V and T are both integer or floating point types" - if isIntegerOrFloat(V) && isIntegerOrFloat(T) { + if is_IntegerOrFloat(V) && is_IntegerOrFloat(T) { return true } // "V and T are both complex types" - if isComplex(V) && isComplex(T) { + if is_Complex(V) && is_Complex(T) { return true } // "V is an integer or a slice of bytes or runes and T is a string type" - if (isInteger(V) || isBytesOrRunes(Vu)) && isString(T) { + if (is_Integer(V) || isBytesOrRunes(Vu)) && is_String(T) { return true } // "V is a string and T is a slice of bytes or runes" - if isString(V) && isBytesOrRunes(Tu) { + if is_String(V) && isBytesOrRunes(Tu) { return true } diff --git a/src/go/types/expr.go b/src/go/types/expr.go index d4de212e06..cdb18eb963 100644 --- a/src/go/types/expr.go +++ b/src/go/types/expr.go @@ -64,10 +64,10 @@ var unaryOpPredicates opPredicates func init() { // Setting unaryOpPredicates in init avoids declaration cycles. unaryOpPredicates = opPredicates{ - token.ADD: isNumeric, - token.SUB: isNumeric, - token.XOR: isInteger, - token.NOT: isBoolean, + token.ADD: allNumeric, + token.SUB: allNumeric, + token.XOR: allInteger, + token.NOT: allBoolean, } } @@ -212,7 +212,7 @@ func (check *Checker) unary(x *operand, e *ast.UnaryExpr) { return } var prec uint - if isUnsigned(x.typ) { + if is_Unsigned(x.typ) { prec = uint(check.conf.sizeof(x.typ) * 8) } x.val = constant.UnaryOp(e.Op, x.val, prec) @@ -289,7 +289,7 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c } switch { - case isInteger(typ): + case is_Integer(typ): x := constant.ToInt(x) if x.Kind() != constant.Int { return false @@ -344,7 +344,7 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c return true } - case isFloat(typ): + case is_Float(typ): x := constant.ToFloat(x) if x.Kind() != constant.Float { return false @@ -374,7 +374,7 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c unreachable() } - case isComplex(typ): + case is_Complex(typ): x := constant.ToComplex(x) if x.Kind() != constant.Complex { return false @@ -406,10 +406,10 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c unreachable() } - case isString(typ): + case is_String(typ): return x.Kind() == constant.String - case isBoolean(typ): + case is_Boolean(typ): return x.Kind() == constant.Bool } @@ -437,7 +437,7 @@ func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, er assert(x.mode == constant_) v := x.val if !representableConst(x.val, check, typ, &v) { - if isNumeric(x.typ) && isNumeric(typ) { + if is_Numeric(x.typ) && is_Numeric(typ) { // numeric conversion : error msg // // integer -> integer : overflows @@ -445,7 +445,7 @@ func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, er // float -> integer : truncated // float -> float : overflows // - if !isInteger(x.typ) && isInteger(typ) { + if !is_Integer(x.typ) && is_Integer(typ) { return nil, _TruncatedFloat } else { return nil, _NumericOverflow @@ -569,7 +569,7 @@ func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) { // If x is the lhs of a shift, its final type must be integer. // We already know from the shift check that it is representable // as an integer if it is a constant. - if !isInteger(typ) { + if !is_Integer(typ) { check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s (type %s) must be integer", x, typ) return } @@ -631,7 +631,7 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const // both x and target are untyped xkind := x.typ.(*Basic).kind tkind := target.(*Basic).kind - if isNumeric(x.typ) && isNumeric(target) { + if is_Numeric(x.typ) && is_Numeric(target) { if xkind < tkind { return target, nil, 0 } @@ -641,10 +641,10 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const return x.typ, nil, 0 } - switch t := under(target).(type) { + switch u := under(target).(type) { case *Basic: if x.mode == constant_ { - v, code := check.representation(x, t) + v, code := check.representation(x, u) if code != 0 { return nil, nil, code } @@ -656,18 +656,18 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const // the value nil. switch x.typ.(*Basic).kind { case UntypedBool: - if !isBoolean(target) { + if !is_Boolean(target) { return nil, nil, _InvalidUntypedConversion } case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex: - if !isNumeric(target) { + if !is_Numeric(target) { return nil, nil, _InvalidUntypedConversion } case UntypedString: // Non-constant untyped string values are not permitted by the spec and // should not occur during normal typechecking passes, but this path is // reachable via the AssignableTo API. - if !isString(target) { + if !is_String(target) { return nil, nil, _InvalidUntypedConversion } case UntypedNil: @@ -682,7 +682,7 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const } case *TypeParam: // TODO(gri) review this code - doesn't look quite right - ok := t.underIs(func(t Type) bool { + ok := u.underIs(func(t Type) bool { target, _, _ := check.implicitTypeAndValue(x, t) return target != nil }) @@ -702,7 +702,7 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const return Typ[UntypedNil], nil, 0 } // cannot assign untyped values to non-empty interfaces - if !t.Empty() { + if !u.Empty() { return nil, nil, _InvalidUntypedConversion } return Default(x.typ), nil, 0 @@ -733,7 +733,7 @@ func (check *Checker) comparison(x, y *operand, op token.Token) { defined = Comparable(x.typ) && Comparable(y.typ) || x.isNil() && hasNil(y.typ) || y.isNil() && hasNil(x.typ) case token.LSS, token.LEQ, token.GTR, token.GEQ: // spec: The ordering operators <, <=, >, and >= apply to operands that are ordered." - defined = isOrdered(x.typ) && isOrdered(y.typ) + defined = allOrdered(x.typ) && allOrdered(y.typ) default: unreachable() } @@ -784,7 +784,7 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) { xval = constant.ToInt(x.val) } - if isInteger(x.typ) || isUntyped(x.typ) && xval != nil && xval.Kind() == constant.Int { + if allInteger(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 { @@ -810,7 +810,7 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) { if isUntyped(y.typ) { // Caution: Check for representability here, rather than in the switch - // below, because isInteger includes untyped integers (was bug #43697). + // below, because is_Integer includes untyped integers (was bug #43697). check.representable(y, Typ[Uint]) if y.mode == invalid { x.mode = invalid @@ -821,8 +821,8 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) { // Check that RHS is otherwise at least of integer type. switch { - case isInteger(y.typ): - if !isUnsigned(y.typ) && !check.allowVersion(check.pkg, 1, 13) { + case allInteger(y.typ): + if !allUnsigned(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 @@ -847,7 +847,7 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) { 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) { + if !is_Integer(x.typ) { x.typ = Typ[UntypedInt] } return @@ -864,7 +864,7 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) { // (e.g., 2.0, an untyped float) - this can only happen for untyped // non-integer numeric constants. Correct the type so that the shift // result is of integer type. - if !isInteger(x.typ) { + if !is_Integer(x.typ) { x.typ = Typ[UntypedInt] } // x is a constant so xval != nil and it must be of Int kind. @@ -910,7 +910,7 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) { } // non-constant shift - lhs must be an integer - if !isInteger(x.typ) { + if !allInteger(x.typ) { check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s must be integer", x) x.mode = invalid return @@ -924,19 +924,19 @@ var binaryOpPredicates opPredicates func init() { // Setting binaryOpPredicates in init avoids declaration cycles. binaryOpPredicates = opPredicates{ - token.ADD: isNumericOrString, - token.SUB: isNumeric, - token.MUL: isNumeric, - token.QUO: isNumeric, - token.REM: isInteger, + token.ADD: allNumericOrString, + token.SUB: allNumeric, + token.MUL: allNumeric, + token.QUO: allNumeric, + token.REM: allInteger, - token.AND: isInteger, - token.OR: isInteger, - token.XOR: isInteger, - token.AND_NOT: isInteger, + token.AND: allInteger, + token.OR: allInteger, + token.XOR: allInteger, + token.AND_NOT: allInteger, - token.LAND: isBoolean, - token.LOR: isBoolean, + token.LAND: allBoolean, + token.LOR: allBoolean, } } @@ -966,10 +966,10 @@ func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token if IsInterface(x.typ) || IsInterface(y.typ) { return true } - if isBoolean(x.typ) != isBoolean(y.typ) { + if allBoolean(x.typ) != allBoolean(y.typ) { return false } - if isString(x.typ) != isString(y.typ) { + if allString(x.typ) != allString(y.typ) { return false } if x.isNil() && !hasNil(y.typ) { @@ -1022,14 +1022,14 @@ func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token if op == token.QUO || op == token.REM { // check for zero divisor - if (x.mode == constant_ || isInteger(x.typ)) && y.mode == constant_ && constant.Sign(y.val) == 0 { + if (x.mode == constant_ || allInteger(x.typ)) && y.mode == constant_ && constant.Sign(y.val) == 0 { check.invalidOp(&y, _DivByZero, "division by zero") x.mode = invalid return } // check for divisor underflow in complex division (see issue 20227) - if x.mode == constant_ && y.mode == constant_ && isComplex(x.typ) { + if x.mode == constant_ && y.mode == constant_ && is_Complex(x.typ) { re, im := constant.Real(y.val), constant.Imag(y.val) re2, im2 := constant.BinaryOp(re, token.MUL, re), constant.BinaryOp(im, token.MUL, im) if constant.Sign(re2) == 0 && constant.Sign(im2) == 0 { @@ -1048,7 +1048,7 @@ func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token return } // force integer division of integer operands - if op == token.QUO && isInteger(x.typ) { + if op == token.QUO && is_Integer(x.typ) { op = token.QUO_ASSIGN } x.val = constant.BinaryOp(x.val, op, y.val) diff --git a/src/go/types/index.go b/src/go/types/index.go index a85d314efa..5d35458011 100644 --- a/src/go/types/index.go +++ b/src/go/types/index.go @@ -47,11 +47,12 @@ func (check *Checker) indexExpr(x *operand, e *typeparams.IndexExpr) (isFuncInst return false } + // ordinary index expression valid := false length := int64(-1) // valid if >= 0 switch typ := under(x.typ).(type) { case *Basic: - if isString(typ) { + if is_String(typ) { valid = true if x.mode == constant_ { length = int64(len(constant.StringVal(x.val))) @@ -109,7 +110,7 @@ func (check *Checker) indexExpr(x *operand, e *typeparams.IndexExpr) (isFuncInst var k, e Type // k is only set for maps switch t := u.(type) { case *Basic: - if isString(t) { + if is_String(t) { e = universeByte mode = value } @@ -217,7 +218,7 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) { return case *Basic: - if isString(u) { + if is_String(u) { if e.Slice3 { check.invalidOp(x, _InvalidSliceExpr, "3-index slice of string") x.mode = invalid @@ -372,7 +373,7 @@ func (check *Checker) isValidIndex(x *operand, code errorCode, what string, allo } // spec: "the index x must be of integer type or an untyped constant" - if !isInteger(x.typ) { + if !allInteger(x.typ) { check.invalidArg(x, code, "%s %s must be integer", what, x) return false } diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go index 3c76d15c79..4ca962e77e 100644 --- a/src/go/types/predicates.go +++ b/src/go/types/predicates.go @@ -27,33 +27,55 @@ func isGeneric(typ Type) bool { return named != nil && named.obj != nil && named.targs == nil && named.TypeParams() != nil } -func is(typ Type, what BasicInfo) bool { - switch t := under(typ).(type) { +// The is_X predicates below report whether t is an X. +// If t is a type parameter the result is false; i.e., +// these predicates don't look inside a type parameter. + +func is_Boolean(t Type) bool { return isBasic(t, IsBoolean) } +func is_Integer(t Type) bool { return isBasic(t, IsInteger) } +func is_Unsigned(t Type) bool { return isBasic(t, IsUnsigned) } +func is_Float(t Type) bool { return isBasic(t, IsFloat) } +func is_Complex(t Type) bool { return isBasic(t, IsComplex) } +func is_Numeric(t Type) bool { return isBasic(t, IsNumeric) } +func is_String(t Type) bool { return isBasic(t, IsString) } +func is_IntegerOrFloat(t Type) bool { return isBasic(t, IsInteger|IsFloat) } + +// isBasic reports whether under(t) is a basic type with the specified info. +// If t is a type parameter the result is false; i.e., +// isBasic does not look inside a type parameter. +func isBasic(t Type, info BasicInfo) bool { + u, _ := under(t).(*Basic) + return u != nil && u.info&info != 0 +} + +// The allX predicates below report whether t is an X. +// If t is a type parameter the result is true if is_X is true +// for all specified types of the type parameter's type set. +// allX is an optimized version of is_X(structure(t)) (which +// is the same as underIs(t, is_X)). + +func allBoolean(typ Type) bool { return allBasic(typ, IsBoolean) } +func allInteger(typ Type) bool { return allBasic(typ, IsInteger) } +func allUnsigned(typ Type) bool { return allBasic(typ, IsUnsigned) } +func allNumeric(typ Type) bool { return allBasic(typ, IsNumeric) } +func allString(typ Type) bool { return allBasic(typ, IsString) } +func allOrdered(typ Type) bool { return allBasic(typ, IsOrdered) } +func allNumericOrString(typ Type) bool { return allBasic(typ, IsNumeric|IsString) } + +// allBasic reports whether under(t) is a basic type with the specified info. +// If t is a type parameter, the result is true if isBasic(t, info) is true +// for all specific types of the type parameter's type set. +// allBasic(t, info) is an optimized version of isBasic(structure(t), info). +func allBasic(t Type, info BasicInfo) bool { + switch u := under(t).(type) { case *Basic: - return t.info&what != 0 + return u.info&info != 0 case *TypeParam: - return t.underIs(func(typ Type) bool { return is(typ, what) }) + return u.is(func(t *term) bool { return t != nil && isBasic(t.typ, info) }) } return false } -func isBoolean(typ Type) bool { return is(typ, IsBoolean) } -func isInteger(typ Type) bool { return is(typ, IsInteger) } -func isUnsigned(typ Type) bool { return is(typ, IsUnsigned) } -func isFloat(typ Type) bool { return is(typ, IsFloat) } -func isComplex(typ Type) bool { return is(typ, IsComplex) } -func isNumeric(typ Type) bool { return is(typ, IsNumeric) } -func isString(typ Type) bool { return is(typ, IsString) } - -// Note that if typ is a type parameter, isInteger(typ) || isFloat(typ) does not -// produce the expected result because a type set that contains both an integer -// and a floating-point type is neither (all) integers, nor (all) floats. -// Use isIntegerOrFloat instead. -func isIntegerOrFloat(typ Type) bool { return is(typ, IsInteger|IsFloat) } - -// isNumericOrString is the equivalent of isIntegerOrFloat for isNumeric(typ) || isString(typ). -func isNumericOrString(typ Type) bool { return is(typ, IsNumeric|IsString) } - // isTyped reports whether typ is typed; i.e., not an untyped // constant or boolean. isTyped may be called with types that // are not fully set up. @@ -69,8 +91,6 @@ func isUntyped(typ Type) bool { return !isTyped(typ) } -func isOrdered(typ Type) bool { return is(typ, IsOrdered) } - func isConstType(typ Type) bool { // Type parameters are never const types. t := asBasic(typ) diff --git a/src/go/types/sizes.go b/src/go/types/sizes.go index 4c85bfe057..badba82cfa 100644 --- a/src/go/types/sizes.go +++ b/src/go/types/sizes.go @@ -82,7 +82,7 @@ func (s *StdSizes) Alignof(T Type) int64 { return 1 } // complex{64,128} are aligned like [2]float{32,64}. - if isComplex(T) { + if is_Complex(T) { a /= 2 } if a > s.MaxAlign { diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go index cc4eceae5d..6e69646455 100644 --- a/src/go/types/stmt.go +++ b/src/go/types/stmt.go @@ -456,7 +456,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) { if x.mode == invalid { return } - if !isNumeric(x.typ) { + if !allNumeric(x.typ) { check.invalidOp(s.X, _NonNumericIncDec, "%s%s (non-numeric type %s)", s.X, s.Tok, x.typ) return } @@ -572,7 +572,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) { check.simpleStmt(s.Init) var x operand check.expr(&x, s.Cond) - if x.mode != invalid && !isBoolean(x.typ) { + if x.mode != invalid && !allBoolean(x.typ) { check.error(s.Cond, _InvalidCond, "non-boolean condition in if statement") } check.stmt(inner, s.Body) @@ -804,7 +804,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) { if s.Cond != nil { var x operand check.expr(&x, s.Cond) - if x.mode != invalid && !isBoolean(x.typ) { + if x.mode != invalid && !allBoolean(x.typ) { check.error(s.Cond, _InvalidCond, "non-boolean condition in for statement") } } @@ -944,7 +944,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) { func rangeKeyVal(typ Type) (key, val Type) { switch typ := arrayPtrDeref(typ).(type) { case *Basic: - if isString(typ) { + if is_String(typ) { return Typ[Int], universeRune // use 'rune' name } case *Array: diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go index e1d942a5c6..30e817f416 100644 --- a/src/go/types/typexpr.go +++ b/src/go/types/typexpr.go @@ -489,7 +489,7 @@ func (check *Checker) arrayLength(e ast.Expr) int64 { return -1 } - if isUntyped(x.typ) || isInteger(x.typ) { + if isUntyped(x.typ) || is_Integer(x.typ) { if val := constant.ToInt(x.val); val.Kind() == constant.Int { if representableConst(val, check, Typ[Int], nil) { if n, ok := constant.Int64Val(val); ok && n >= 0 { From 2ade8ae325e6410f9696f431e6c50479216e63ae Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 9 Nov 2021 10:20:50 -0500 Subject: [PATCH 042/752] go/types: rename is_X predicates back to isX (step 2 of 2) This is a port of CL 361134 to go/types. Change-Id: Ibac4365a85561b32a90b0118d48aa9302f227b2e Reviewed-on: https://go-review.googlesource.com/c/go/+/362554 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/types/builtins.go | 12 ++++++------ src/go/types/check.go | 2 +- src/go/types/conversions.go | 12 ++++++------ src/go/types/expr.go | 36 ++++++++++++++++++------------------ src/go/types/index.go | 6 +++--- src/go/types/predicates.go | 24 ++++++++++++------------ src/go/types/sizes.go | 2 +- src/go/types/stmt.go | 2 +- src/go/types/typexpr.go | 2 +- 9 files changed, 49 insertions(+), 49 deletions(-) diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go index 0390ac0192..577a71fd60 100644 --- a/src/go/types/builtins.go +++ b/src/go/types/builtins.go @@ -147,7 +147,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b var val constant.Value switch typ = arrayPtrDeref(under(x.typ)); t := typ.(type) { case *Basic: - if is_String(t) && id == _Len { + if isString(t) && id == _Len { if x.mode == constant_ { mode = constant_ val = constant.MakeInt64(int64(len(constant.StringVal(x.val)))) @@ -183,7 +183,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b if t.underIs(func(t Type) bool { switch t := arrayPtrDeref(t).(type) { case *Basic: - if is_String(t) && id == _Len { + if isString(t) && id == _Len { return true } case *Array, *Slice, *Chan: @@ -272,7 +272,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b // because shifts of floats are not permitted) if x.mode == constant_ && y.mode == constant_ { toFloat := func(x *operand) { - if is_Numeric(x.typ) && constant.Sign(constant.Imag(x.val)) == 0 { + if isNumeric(x.typ) && constant.Sign(constant.Imag(x.val)) == 0 { x.typ = Typ[UntypedFloat] } } @@ -403,7 +403,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b if x.mode == constant_ { // an untyped constant number can always be considered // as a complex constant - if is_Numeric(x.typ) { + if isNumeric(x.typ) { x.typ = Typ[UntypedComplex] } } else { @@ -735,7 +735,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b // assert(pred) causes a typechecker error if pred is false. // The result of assert is the value of pred if there is no error. // Note: assert is only available in self-test mode. - if x.mode != constant_ || !is_Boolean(x.typ) { + if x.mode != constant_ || !isBoolean(x.typ) { check.invalidArg(x, _Test, "%s is not a boolean constant", x) return } @@ -801,7 +801,7 @@ func structure(typ Type) Type { func structureString(typ Type) Type { var su Type if underIs(typ, func(u Type) bool { - if is_String(u) { + if isString(u) { u = NewSlice(universeByte) } if su != nil && !Identical(su, u) { diff --git a/src/go/types/check.go b/src/go/types/check.go index c828cf54e4..1d55fb4342 100644 --- a/src/go/types/check.go +++ b/src/go/types/check.go @@ -451,7 +451,7 @@ func (check *Checker) recordCommaOkTypes(x ast.Expr, a [2]Type) { if a[0] == nil || a[1] == nil { return } - assert(isTyped(a[0]) && isTyped(a[1]) && (is_Boolean(a[1]) || a[1] == universeError)) + assert(isTyped(a[0]) && isTyped(a[1]) && (isBoolean(a[1]) || a[1] == universeError)) if m := check.Types; m != nil { for { tv := m[x] diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go index c99bd6332a..c171b2c8d6 100644 --- a/src/go/types/conversions.go +++ b/src/go/types/conversions.go @@ -22,7 +22,7 @@ func (check *Checker) conversion(x *operand, T Type) { // nothing to do case representableConst(x.val, check, t, val): return true - case is_Integer(x.typ) && is_String(t): + case isInteger(x.typ) && isString(t): codepoint := unicode.ReplacementChar if i, ok := constant.Uint64Val(x.val); ok && i <= unicode.MaxRune { codepoint = rune(i) @@ -91,7 +91,7 @@ func (check *Checker) conversion(x *operand, T Type) { // (See also the TODO below.) if IsInterface(T) || constArg && !isConstType(T) || x.isNil() { final = Default(x.typ) // default type of untyped nil is untyped nil - } else if is_Integer(x.typ) && allString(T) { + } else if isInteger(x.typ) && allString(T) { final = x.typ } check.updateExprType(x.expr, final, true) @@ -195,22 +195,22 @@ func convertibleToImpl(check *Checker, V, T Type, cause *string) bool { } // "V and T are both integer or floating point types" - if is_IntegerOrFloat(V) && is_IntegerOrFloat(T) { + if isIntegerOrFloat(V) && isIntegerOrFloat(T) { return true } // "V and T are both complex types" - if is_Complex(V) && is_Complex(T) { + if isComplex(V) && isComplex(T) { return true } // "V is an integer or a slice of bytes or runes and T is a string type" - if (is_Integer(V) || isBytesOrRunes(Vu)) && is_String(T) { + if (isInteger(V) || isBytesOrRunes(Vu)) && isString(T) { return true } // "V is a string and T is a slice of bytes or runes" - if is_String(V) && isBytesOrRunes(Tu) { + if isString(V) && isBytesOrRunes(Tu) { return true } diff --git a/src/go/types/expr.go b/src/go/types/expr.go index cdb18eb963..83022ed660 100644 --- a/src/go/types/expr.go +++ b/src/go/types/expr.go @@ -212,7 +212,7 @@ func (check *Checker) unary(x *operand, e *ast.UnaryExpr) { return } var prec uint - if is_Unsigned(x.typ) { + if isUnsigned(x.typ) { prec = uint(check.conf.sizeof(x.typ) * 8) } x.val = constant.UnaryOp(e.Op, x.val, prec) @@ -289,7 +289,7 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c } switch { - case is_Integer(typ): + case isInteger(typ): x := constant.ToInt(x) if x.Kind() != constant.Int { return false @@ -344,7 +344,7 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c return true } - case is_Float(typ): + case isFloat(typ): x := constant.ToFloat(x) if x.Kind() != constant.Float { return false @@ -374,7 +374,7 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c unreachable() } - case is_Complex(typ): + case isComplex(typ): x := constant.ToComplex(x) if x.Kind() != constant.Complex { return false @@ -406,10 +406,10 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c unreachable() } - case is_String(typ): + case isString(typ): return x.Kind() == constant.String - case is_Boolean(typ): + case isBoolean(typ): return x.Kind() == constant.Bool } @@ -437,7 +437,7 @@ func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, er assert(x.mode == constant_) v := x.val if !representableConst(x.val, check, typ, &v) { - if is_Numeric(x.typ) && is_Numeric(typ) { + if isNumeric(x.typ) && isNumeric(typ) { // numeric conversion : error msg // // integer -> integer : overflows @@ -445,7 +445,7 @@ func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, er // float -> integer : truncated // float -> float : overflows // - if !is_Integer(x.typ) && is_Integer(typ) { + if !isInteger(x.typ) && isInteger(typ) { return nil, _TruncatedFloat } else { return nil, _NumericOverflow @@ -569,7 +569,7 @@ func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) { // If x is the lhs of a shift, its final type must be integer. // We already know from the shift check that it is representable // as an integer if it is a constant. - if !is_Integer(typ) { + if !isInteger(typ) { check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s (type %s) must be integer", x, typ) return } @@ -631,7 +631,7 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const // both x and target are untyped xkind := x.typ.(*Basic).kind tkind := target.(*Basic).kind - if is_Numeric(x.typ) && is_Numeric(target) { + if isNumeric(x.typ) && isNumeric(target) { if xkind < tkind { return target, nil, 0 } @@ -656,18 +656,18 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const // the value nil. switch x.typ.(*Basic).kind { case UntypedBool: - if !is_Boolean(target) { + if !isBoolean(target) { return nil, nil, _InvalidUntypedConversion } case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex: - if !is_Numeric(target) { + if !isNumeric(target) { return nil, nil, _InvalidUntypedConversion } case UntypedString: // Non-constant untyped string values are not permitted by the spec and // should not occur during normal typechecking passes, but this path is // reachable via the AssignableTo API. - if !is_String(target) { + if !isString(target) { return nil, nil, _InvalidUntypedConversion } case UntypedNil: @@ -810,7 +810,7 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) { if isUntyped(y.typ) { // Caution: Check for representability here, rather than in the switch - // below, because is_Integer includes untyped integers (was bug #43697). + // below, because isInteger includes untyped integers (was bug #43697). check.representable(y, Typ[Uint]) if y.mode == invalid { x.mode = invalid @@ -847,7 +847,7 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) { if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown { x.val = constant.MakeUnknown() // ensure the correct type - see comment below - if !is_Integer(x.typ) { + if !isInteger(x.typ) { x.typ = Typ[UntypedInt] } return @@ -864,7 +864,7 @@ func (check *Checker) shift(x, y *operand, e ast.Expr, op token.Token) { // (e.g., 2.0, an untyped float) - this can only happen for untyped // non-integer numeric constants. Correct the type so that the shift // result is of integer type. - if !is_Integer(x.typ) { + if !isInteger(x.typ) { x.typ = Typ[UntypedInt] } // x is a constant so xval != nil and it must be of Int kind. @@ -1029,7 +1029,7 @@ func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token } // check for divisor underflow in complex division (see issue 20227) - if x.mode == constant_ && y.mode == constant_ && is_Complex(x.typ) { + if x.mode == constant_ && y.mode == constant_ && isComplex(x.typ) { re, im := constant.Real(y.val), constant.Imag(y.val) re2, im2 := constant.BinaryOp(re, token.MUL, re), constant.BinaryOp(im, token.MUL, im) if constant.Sign(re2) == 0 && constant.Sign(im2) == 0 { @@ -1048,7 +1048,7 @@ func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token return } // force integer division of integer operands - if op == token.QUO && is_Integer(x.typ) { + if op == token.QUO && isInteger(x.typ) { op = token.QUO_ASSIGN } x.val = constant.BinaryOp(x.val, op, y.val) diff --git a/src/go/types/index.go b/src/go/types/index.go index 5d35458011..7ef8231f0b 100644 --- a/src/go/types/index.go +++ b/src/go/types/index.go @@ -52,7 +52,7 @@ func (check *Checker) indexExpr(x *operand, e *typeparams.IndexExpr) (isFuncInst length := int64(-1) // valid if >= 0 switch typ := under(x.typ).(type) { case *Basic: - if is_String(typ) { + if isString(typ) { valid = true if x.mode == constant_ { length = int64(len(constant.StringVal(x.val))) @@ -110,7 +110,7 @@ func (check *Checker) indexExpr(x *operand, e *typeparams.IndexExpr) (isFuncInst var k, e Type // k is only set for maps switch t := u.(type) { case *Basic: - if is_String(t) { + if isString(t) { e = universeByte mode = value } @@ -218,7 +218,7 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) { return case *Basic: - if is_String(u) { + if isString(u) { if e.Slice3 { check.invalidOp(x, _InvalidSliceExpr, "3-index slice of string") x.mode = invalid diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go index 4ca962e77e..1ecb6a8c7e 100644 --- a/src/go/types/predicates.go +++ b/src/go/types/predicates.go @@ -27,18 +27,18 @@ func isGeneric(typ Type) bool { return named != nil && named.obj != nil && named.targs == nil && named.TypeParams() != nil } -// The is_X predicates below report whether t is an X. +// The isX predicates below report whether t is an X. // If t is a type parameter the result is false; i.e., // these predicates don't look inside a type parameter. -func is_Boolean(t Type) bool { return isBasic(t, IsBoolean) } -func is_Integer(t Type) bool { return isBasic(t, IsInteger) } -func is_Unsigned(t Type) bool { return isBasic(t, IsUnsigned) } -func is_Float(t Type) bool { return isBasic(t, IsFloat) } -func is_Complex(t Type) bool { return isBasic(t, IsComplex) } -func is_Numeric(t Type) bool { return isBasic(t, IsNumeric) } -func is_String(t Type) bool { return isBasic(t, IsString) } -func is_IntegerOrFloat(t Type) bool { return isBasic(t, IsInteger|IsFloat) } +func isBoolean(t Type) bool { return isBasic(t, IsBoolean) } +func isInteger(t Type) bool { return isBasic(t, IsInteger) } +func isUnsigned(t Type) bool { return isBasic(t, IsUnsigned) } +func isFloat(t Type) bool { return isBasic(t, IsFloat) } +func isComplex(t Type) bool { return isBasic(t, IsComplex) } +func isNumeric(t Type) bool { return isBasic(t, IsNumeric) } +func isString(t Type) bool { return isBasic(t, IsString) } +func isIntegerOrFloat(t Type) bool { return isBasic(t, IsInteger|IsFloat) } // isBasic reports whether under(t) is a basic type with the specified info. // If t is a type parameter the result is false; i.e., @@ -49,10 +49,10 @@ func isBasic(t Type, info BasicInfo) bool { } // The allX predicates below report whether t is an X. -// If t is a type parameter the result is true if is_X is true +// If t is a type parameter the result is true if isX is true // for all specified types of the type parameter's type set. -// allX is an optimized version of is_X(structure(t)) (which -// is the same as underIs(t, is_X)). +// allX is an optimized version of isX(structure(t)) (which +// is the same as underIs(t, isX)). func allBoolean(typ Type) bool { return allBasic(typ, IsBoolean) } func allInteger(typ Type) bool { return allBasic(typ, IsInteger) } diff --git a/src/go/types/sizes.go b/src/go/types/sizes.go index badba82cfa..4c85bfe057 100644 --- a/src/go/types/sizes.go +++ b/src/go/types/sizes.go @@ -82,7 +82,7 @@ func (s *StdSizes) Alignof(T Type) int64 { return 1 } // complex{64,128} are aligned like [2]float{32,64}. - if is_Complex(T) { + if isComplex(T) { a /= 2 } if a > s.MaxAlign { diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go index 6e69646455..11032f44dd 100644 --- a/src/go/types/stmt.go +++ b/src/go/types/stmt.go @@ -944,7 +944,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) { func rangeKeyVal(typ Type) (key, val Type) { switch typ := arrayPtrDeref(typ).(type) { case *Basic: - if is_String(typ) { + if isString(typ) { return Typ[Int], universeRune // use 'rune' name } case *Array: diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go index 30e817f416..e1d942a5c6 100644 --- a/src/go/types/typexpr.go +++ b/src/go/types/typexpr.go @@ -489,7 +489,7 @@ func (check *Checker) arrayLength(e ast.Expr) int64 { return -1 } - if isUntyped(x.typ) || is_Integer(x.typ) { + if isUntyped(x.typ) || isInteger(x.typ) { if val := constant.ToInt(x.val); val.Kind() == constant.Int { if representableConst(val, check, Typ[Int], nil) { if n, ok := constant.Int64Val(val); ok && n >= 0 { From 47e3c4bc74f5f260cbc9c5e6d1ababde0a114a97 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Mon, 8 Nov 2021 18:10:30 -0800 Subject: [PATCH 043/752] cmd/compile: disable doubleCheck and remove unused checkDictionary In stencil.go, change doubleCheck to false, which will turn off some double-checking code which isn't needed generally, now that we have lots of tests of end-to-end runs. Also, removed checkDictionary() which is unused and is unlikely to be useful in the future. Change-Id: I4e5acceab80f4904b174422bae21ca82cf04f943 Reviewed-on: https://go-review.googlesource.com/c/go/+/361923 Trust: Dan Scales Run-TryBot: Dan Scales Reviewed-by: Keith Randall TryBot-Result: Go Bot --- src/cmd/compile/internal/noder/stencil.go | 50 +---------------------- 1 file changed, 1 insertion(+), 49 deletions(-) diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go index 4ebd607c16..cfbbee3ceb 100644 --- a/src/cmd/compile/internal/noder/stencil.go +++ b/src/cmd/compile/internal/noder/stencil.go @@ -22,7 +22,7 @@ import ( ) // Enable extra consistency checks. -const doubleCheck = true +const doubleCheck = false func assert(p bool) { base.Assert(p) @@ -802,11 +802,6 @@ func (g *genInst) genericSubst(newsym *types.Sym, nameNode *ir.Name, shapes []*t // Make sure name/type of newf is set before substituting the body. newf.Body = subst.list(gf.Body) - // Add code to check that the dictionary is correct. - // TODO: must be adjusted to deal with shapes, but will go away soon when we move - // to many->1 shape to concrete mapping. - // newf.Body.Prepend(subst.checkDictionary(dictionaryName, shapes)...) - if len(subst.defnMap) > 0 { base.Fatalf("defnMap is not empty") } @@ -859,49 +854,6 @@ func (subst *subster) localvar(name *ir.Name) *ir.Name { return m } -// checkDictionary returns code that does runtime consistency checks -// between the dictionary and the types it should contain. -func (subst *subster) checkDictionary(name *ir.Name, targs []*types.Type) (code []ir.Node) { - if false { - return // checking turned off - } - // TODO: when moving to GCshape, this test will become harder. Call into - // runtime to check the expected shape is correct? - pos := name.Pos() - // Convert dictionary to *[N]uintptr - d := ir.NewConvExpr(pos, ir.OCONVNOP, types.Types[types.TUNSAFEPTR], name) - d.SetTypecheck(1) - d = ir.NewConvExpr(pos, ir.OCONVNOP, types.NewArray(types.Types[types.TUINTPTR], int64(len(targs))).PtrTo(), d) - d.SetTypecheck(1) - types.CheckSize(d.Type().Elem()) - - // Check that each type entry in the dictionary is correct. - for i, t := range targs { - if t.HasShape() { - // Check the concrete type, not the shape type. - base.Fatalf("shape type in dictionary %s %+v\n", name.Sym().Name, t) - } - want := reflectdata.TypePtr(t) - typed(types.Types[types.TUINTPTR], want) - deref := ir.NewStarExpr(pos, d) - typed(d.Type().Elem(), deref) - idx := ir.NewConstExpr(constant.MakeUint64(uint64(i)), name) // TODO: what to set orig to? - typed(types.Types[types.TUINTPTR], idx) - got := ir.NewIndexExpr(pos, deref, idx) - typed(types.Types[types.TUINTPTR], got) - cond := ir.NewBinaryExpr(pos, ir.ONE, want, got) - typed(types.Types[types.TBOOL], cond) - panicArg := ir.NewNilExpr(pos) - typed(types.NewInterface(types.LocalPkg, nil, false), panicArg) - then := ir.NewUnaryExpr(pos, ir.OPANIC, panicArg) - then.SetTypecheck(1) - x := ir.NewIfStmt(pos, cond, []ir.Node{then}, nil) - x.SetTypecheck(1) - code = append(code, x) - } - return -} - // getDictionaryEntry gets the i'th entry in the dictionary dict. func getDictionaryEntry(pos src.XPos, dict *ir.Name, i int, size int) ir.Node { // Convert dictionary to *[N]uintptr From 34abc12b2a24fd76cdfad531f0a229f3cbb55bc3 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Mon, 8 Nov 2021 18:08:59 +0000 Subject: [PATCH 044/752] cmd/compile/internal/types2: roll-forward removal of asX converters This CL reverts CL 361964, rolling forward the original CL 362254 with a fix for re-entrant expansion via type hashing (compare patchsets 1 and 2). Change-Id: I62869e50e919f42eb8d6fef5b0d7a5ec8960bd84 Reviewed-on: https://go-review.googlesource.com/c/go/+/362118 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Cuong Manh Le Reviewed-by: Robert Griesemer TryBot-Result: Go Bot --- .../compile/internal/types2/assignments.go | 2 +- src/cmd/compile/internal/types2/builtins.go | 8 ++-- src/cmd/compile/internal/types2/call.go | 2 +- src/cmd/compile/internal/types2/context.go | 3 ++ .../compile/internal/types2/conversions.go | 21 +++++----- src/cmd/compile/internal/types2/expr.go | 6 +-- src/cmd/compile/internal/types2/index.go | 8 ++-- src/cmd/compile/internal/types2/lookup.go | 9 ++--- src/cmd/compile/internal/types2/predicates.go | 5 ++- src/cmd/compile/internal/types2/sizes.go | 2 +- src/cmd/compile/internal/types2/type.go | 39 +------------------ src/cmd/compile/internal/types2/typestring.go | 2 +- src/cmd/compile/internal/types2/typexpr.go | 2 +- 13 files changed, 38 insertions(+), 71 deletions(-) diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go index bfc5578683..609d7d0962 100644 --- a/src/cmd/compile/internal/types2/assignments.go +++ b/src/cmd/compile/internal/types2/assignments.go @@ -71,7 +71,7 @@ func (check *Checker) assignment(x *operand, T Type, context string) { // x.typ is typed // A generic (non-instantiated) function value cannot be assigned to a variable. - if sig := asSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 { + if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 { check.errorf(x, "cannot use generic function %s without instantiation in %s", x, context) } diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go index ade4c0a49f..916aed40b3 100644 --- a/src/cmd/compile/internal/types2/builtins.go +++ b/src/cmd/compile/internal/types2/builtins.go @@ -294,7 +294,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( // (applyTypeFunc never calls f with a type parameter) f := func(typ Type) Type { assert(asTypeParam(typ) == nil) - if t := asBasic(typ); t != nil { + if t, _ := under(typ).(*Basic); t != nil { switch t.kind { case Float32: return Typ[Complex64] @@ -418,7 +418,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( // (applyTypeFunc never calls f with a type parameter) f := func(typ Type) Type { assert(asTypeParam(typ) == nil) - if t := asBasic(typ); t != nil { + if t, _ := under(typ).(*Basic); t != nil { switch t.kind { case Complex64: return Typ[Float32] @@ -704,7 +704,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( return } - typ := asPointer(x.typ) + typ, _ := under(x.typ).(*Pointer) if typ == nil { check.errorf(x, invalidArg+"%s is not a pointer", x) return @@ -894,7 +894,7 @@ func makeSig(res Type, args ...Type) *Signature { // otherwise it returns typ. func arrayPtrDeref(typ Type) Type { if p, ok := typ.(*Pointer); ok { - if a := asArray(p.base); a != nil { + if a, _ := under(p.base).(*Array); a != nil { return a } } diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go index 74edd4d442..3a571285c1 100644 --- a/src/cmd/compile/internal/types2/call.go +++ b/src/cmd/compile/internal/types2/call.go @@ -132,7 +132,7 @@ func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind { case 1: check.expr(x, call.ArgList[0]) if x.mode != invalid { - if t := asInterface(T); t != nil { + if t, _ := under(T).(*Interface); t != nil { if !t.IsMethodSet() { check.errorf(call, "cannot use interface %s in conversion (contains specific type constraints or is comparable)", T) break diff --git a/src/cmd/compile/internal/types2/context.go b/src/cmd/compile/internal/types2/context.go index a8f8591243..f6137eea43 100644 --- a/src/cmd/compile/internal/types2/context.go +++ b/src/cmd/compile/internal/types2/context.go @@ -39,6 +39,9 @@ func (ctxt *Context) TypeHash(typ Type, targs []Type) string { var buf bytes.Buffer h := newTypeHasher(&buf, ctxt) + // Caution: don't use asNamed here. TypeHash may be called for unexpanded + // types. We don't need anything other than name and type arguments below, + // which do not require expansion. if named, _ := typ.(*Named); named != nil && len(targs) > 0 { // Don't use WriteType because we need to use the provided targs // and not any targs that might already be with the *Named type. diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go index ccabbaf0d7..dd89f29762 100644 --- a/src/cmd/compile/internal/types2/conversions.go +++ b/src/cmd/compile/internal/types2/conversions.go @@ -18,7 +18,7 @@ func (check *Checker) conversion(x *operand, T Type) { constArg := x.mode == constant_ constConvertibleTo := func(T Type, val *constant.Value) bool { - switch t := asBasic(T); { + switch t, _ := under(T).(*Basic); { case t == nil: // nothing to do case representableConst(x.val, check, t, val): @@ -173,9 +173,9 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { // "V a slice, T is a pointer-to-array type, // and the slice and array types have identical element types." - if s := asSlice(V); s != nil { - if p := asPointer(T); p != nil { - if a := asArray(p.Elem()); a != nil { + if s, _ := under(V).(*Slice); s != nil { + if p, _ := under(T).(*Pointer); p != nil { + if a, _ := under(p.Elem()).(*Array); a != nil { if Identical(s.Elem(), a.Elem()) { if check == nil || check.allowVersion(check.pkg, 1, 17) { return true @@ -262,26 +262,27 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { // use the toT convenience converters in the predicates below. func isUintptr(typ Type) bool { - t := asBasic(typ) + t, _ := under(typ).(*Basic) return t != nil && t.kind == Uintptr } func isUnsafePointer(typ Type) bool { - // TODO(gri): Is this asBasic(typ) instead of typ.(*Basic) correct? + // TODO(gri): Is this under(typ).(*Basic) instead of typ.(*Basic) correct? // (The former calls under(), while the latter doesn't.) // The spec does not say so, but gc claims it is. See also // issue 6326. - t := asBasic(typ) + t, _ := under(typ).(*Basic) return t != nil && t.kind == UnsafePointer } func isPointer(typ Type) bool { - return asPointer(typ) != nil + _, ok := under(typ).(*Pointer) + return ok } func isBytesOrRunes(typ Type) bool { - if s := asSlice(typ); s != nil { - t := asBasic(s.elem) + if s, _ := under(typ).(*Slice); s != nil { + t, _ := under(s.elem).(*Basic) return t != nil && (t.kind == Byte || t.kind == Rune) } return false diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index d24532d780..8125fba717 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -116,7 +116,7 @@ func (check *Checker) overflow(x *operand) { // x.typ cannot be a type parameter (type // parameters cannot be constant types). if isTyped(x.typ) { - check.representable(x, asBasic(x.typ)) + check.representable(x, under(x.typ).(*Basic)) return } @@ -617,7 +617,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) { // If the new type is not final and still untyped, just // update the recorded type. if !final && isUntyped(typ) { - old.typ = asBasic(typ) + old.typ = under(typ).(*Basic) check.untyped[x] = old return } @@ -1394,7 +1394,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin duplicate := false // if the key is of interface type, the type is also significant when checking for duplicates xkey := keyVal(x.val) - if asInterface(utyp.key) != nil { + if IsInterface(utyp.key) { for _, vtyp := range visited[xkey] { if Identical(vtyp, x.typ) { duplicate = true diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go index 67110704e9..f096674536 100644 --- a/src/cmd/compile/internal/types2/index.go +++ b/src/cmd/compile/internal/types2/index.go @@ -34,7 +34,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo return false case value: - if sig := asSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 { + if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 { // function instantiation return true } @@ -72,7 +72,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo x.typ = typ.elem case *Pointer: - if typ := asArray(typ.base); typ != nil { + if typ, _ := under(typ.base).(*Array); typ != nil { valid = true length = typ.len x.mode = variable @@ -120,7 +120,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo mode = value } case *Pointer: - if t := asArray(t.base); t != nil { + if t, _ := under(t.base).(*Array); t != nil { l = t.len e = t.elem } @@ -245,7 +245,7 @@ func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) { x.typ = &Slice{elem: u.elem} case *Pointer: - if u := asArray(u.base); u != nil { + if u, _ := under(u.base).(*Array); u != nil { valid = true length = u.len x.typ = &Slice{elem: u.elem} diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index e0fd74482a..0612400590 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -122,7 +122,6 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o seen[named] = true // look for a matching attached method - named.resolve(nil) if i, m := lookupMethod(named.methods, pkg, name); m != nil { // potential match // caution: method may not have a proper signature yet @@ -306,7 +305,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, return } - if ityp := asInterface(V); ityp != nil { + if ityp, _ := under(V).(*Interface); ityp != nil { // TODO(gri) the methods are sorted - could do this more efficiently for _, m := range T.typeSet().methods { _, f := ityp.typeSet().LookupMethod(m.pkg, m.name) @@ -417,7 +416,7 @@ func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Fun // no static check is required if T is an interface // spec: "If T is an interface type, x.(T) asserts that the // dynamic type of x implements the interface T." - if asInterface(T) != nil && !forceStrict { + if IsInterface(T) && !forceStrict { return } return check.missingMethod(T, V, false) @@ -435,8 +434,8 @@ func deref(typ Type) (Type, bool) { // derefStructPtr dereferences typ if it is a (named or unnamed) pointer to a // (named or unnamed) struct and returns its base. Otherwise it returns typ. func derefStructPtr(typ Type) Type { - if p := asPointer(typ); p != nil { - if asStruct(p.base) != nil { + if p, _ := under(typ).(*Pointer); p != nil { + if _, ok := under(p.base).(*Struct); ok { return p.base } } diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go index 7fbb91eb61..8d676ed8f6 100644 --- a/src/cmd/compile/internal/types2/predicates.go +++ b/src/cmd/compile/internal/types2/predicates.go @@ -72,7 +72,7 @@ func hasName(t Type) bool { // are not fully set up. func isTyped(t Type) bool { // isTyped is called with types that are not fully - // set up. Must not call asBasic()! + // set up. Must not call under()! b, _ := t.(*Basic) return b == nil || b.info&IsUntyped == 0 } @@ -84,7 +84,8 @@ func isUntyped(t Type) bool { // IsInterface reports whether t is an interface type. func IsInterface(t Type) bool { - return asInterface(t) != nil + _, ok := under(t).(*Interface) + return ok } // isTypeParam reports whether t is a type parameter. diff --git a/src/cmd/compile/internal/types2/sizes.go b/src/cmd/compile/internal/types2/sizes.go index 6a3d19d8ea..609b6f585e 100644 --- a/src/cmd/compile/internal/types2/sizes.go +++ b/src/cmd/compile/internal/types2/sizes.go @@ -243,7 +243,7 @@ func (conf *Config) offsetsof(T *Struct) []int64 { func (conf *Config) offsetof(typ Type, index []int) int64 { var o int64 for _, i := range index { - s := asStruct(typ) + s := under(typ).(*Struct) o += conf.offsetsof(s)[i] typ = s.fields[i].typ } diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go index 300c81f5fa..d1655c55f8 100644 --- a/src/cmd/compile/internal/types2/type.go +++ b/src/cmd/compile/internal/types2/type.go @@ -27,45 +27,8 @@ func under(t Type) Type { return t } -// Convenience converters - -func asBasic(t Type) *Basic { - u, _ := under(t).(*Basic) - return u -} - -func asArray(t Type) *Array { - u, _ := under(t).(*Array) - return u -} - -func asSlice(t Type) *Slice { - u, _ := under(t).(*Slice) - return u -} - -func asStruct(t Type) *Struct { - u, _ := under(t).(*Struct) - return u -} - -func asPointer(t Type) *Pointer { - u, _ := under(t).(*Pointer) - return u -} - -func asSignature(t Type) *Signature { - u, _ := under(t).(*Signature) - return u -} - -func asInterface(t Type) *Interface { - u, _ := under(t).(*Interface) - return u -} - // If the argument to asNamed, or asTypeParam is of the respective type -// (possibly after expanding resolving a *Named type), these methods return that type. +// (possibly after resolving a *Named type), these methods return that type. // Otherwise the result is nil. func asNamed(t Type) *Named { diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go index f18a32016f..f151f47a5e 100644 --- a/src/cmd/compile/internal/types2/typestring.go +++ b/src/cmd/compile/internal/types2/typestring.go @@ -361,7 +361,7 @@ func (w *typeWriter) tuple(tup *Tuple, variadic bool) { } else { // special case: // append(s, "foo"...) leads to signature func([]byte, string...) - if t := asBasic(typ); t == nil || t.kind != String { + if t, _ := under(typ).(*Basic); t == nil || t.kind != String { w.error("expected string type") continue } diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go index dcd7cfebe8..a08e472703 100644 --- a/src/cmd/compile/internal/types2/typexpr.go +++ b/src/cmd/compile/internal/types2/typexpr.go @@ -148,7 +148,7 @@ func (check *Checker) varType(e syntax.Expr) Type { // are in the middle of type-checking parameter declarations that might belong to // interface methods. Delay this check to the end of type-checking. check.later(func() { - if t := asInterface(typ); t != nil { + if t, _ := under(typ).(*Interface); t != nil { pos := syntax.StartPos(e) tset := computeInterfaceTypeSet(check, pos, t) // TODO(gri) is this the correct position? if !tset.IsMethodSet() { From 90f47dbba635802bb009404e321fa4759ac76d20 Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Tue, 9 Nov 2021 10:59:32 -0500 Subject: [PATCH 045/752] runtime/pprof: include labels in profile dump For tests of pprof label support having the sample labels in the output is needed for effective debugging. For #48577 Change-Id: Ic7c5bc90cb33e8fb477f7db62d9b56a7a9d6ffa8 Reviewed-on: https://go-review.googlesource.com/c/go/+/362614 Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Go Bot Reviewed-by: Cherry Mui --- src/runtime/pprof/pprof_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index 417d5034a6..704c0c516d 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -494,6 +494,7 @@ func profileOk(t *testing.T, matches matchFunc, need []string, avoid []string, p p := parseProfile(t, prof.Bytes(), func(count uintptr, stk []*profile.Location, labels map[string][]string) { fmt.Fprintf(&buf, "%d:", count) fprintStack(&buf, stk) + fmt.Fprintf(&buf, " labels: %v\n", labels) samples += count for i, spec := range need { if matches(spec, count, stk, labels) { @@ -675,7 +676,6 @@ func fprintStack(w io.Writer, stk []*profile.Location) { } fmt.Fprintf(w, ")") } - fmt.Fprintf(w, "\n") } // Test that profiling of division operations is okay, especially on ARM. See issue 6681. From 15a54d627ca7a0bdf45a3d1862b35a892024cacc Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Tue, 9 Nov 2021 11:35:52 -0500 Subject: [PATCH 046/752] runtime: add upper half and carry bit with zero https://golang.org/cl/246763 accidentally changed this from upper + 0 + carry to upper + old vdsoSP + carry. The old value of vdsoPC is usually zero, so this typically works. However, the reentrant case will have a non-zero value, resulting in a bogus returned time. Fixes #49481 Change-Id: I0110b84277bf911804cb0ff8097aebf1b7eb100a Reviewed-on: https://go-review.googlesource.com/c/go/+/362674 Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Go Bot Reviewed-by: Cherry Mui --- src/runtime/sys_linux_arm.s | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/runtime/sys_linux_arm.s b/src/runtime/sys_linux_arm.s index 65935de99f..ca443b699f 100644 --- a/src/runtime/sys_linux_arm.s +++ b/src/runtime/sys_linux_arm.s @@ -456,7 +456,7 @@ finish: MOVW $1000000000, R3 MULLU R0, R3, (R1, R0) ADD.S R2, R0 - ADC R4, R1 + ADC $0, R1 // Add carry bit to upper half. MOVW R0, ret_lo+0(FP) MOVW R1, ret_hi+4(FP) From 36dbf7f7e63f3738795bb04593c3c011e987d1f3 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Thu, 28 Oct 2021 13:22:07 -0400 Subject: [PATCH 047/752] cmd/go: add //go:embed all:pattern When //go:embed d matches directory d, it embeds the directory tree rooted at d, but it excludes files beginning with . and _, as well as files having problematic names that will not be packaged into modules (names such as .git and com1). After long discussions on #42328 and #43854, we decided to keep the behavior of excluding . and _ files by default, but to allow the pattern prefix 'all:' to override this default. This CL implements that change. Note that paths like .git and com1 are still excluded, as they must be, since they will never be packed into a module. Fixes #43854. Change-Id: I4f3731e14ecffd4b691fda3a0890b460027fe209 Reviewed-on: https://go-review.googlesource.com/c/go/+/359413 Trust: Russ Cox Run-TryBot: Russ Cox TryBot-Result: Go Bot Reviewed-by: Jonathan Amsterdam Reviewed-by: Bryan C. Mills --- src/cmd/go/internal/load/pkg.go | 11 ++++++++--- src/cmd/go/testdata/script/embed.txt | 20 ++++++++++++++++++++ src/embed/embed.go | 5 +++++ 3 files changed, 33 insertions(+), 3 deletions(-) diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go index c6c5fb00a8..360d265de6 100644 --- a/src/cmd/go/internal/load/pkg.go +++ b/src/cmd/go/internal/load/pkg.go @@ -2017,13 +2017,18 @@ func resolveEmbed(pkgdir string, patterns []string) (files []string, pmap map[st for _, pattern = range patterns { pid++ + glob := pattern + all := strings.HasPrefix(pattern, "all:") + if all { + glob = pattern[len("all:"):] + } // Check pattern is valid for //go:embed. - if _, err := path.Match(pattern, ""); err != nil || !validEmbedPattern(pattern) { + if _, err := path.Match(glob, ""); err != nil || !validEmbedPattern(glob) { return nil, nil, fmt.Errorf("invalid pattern syntax") } // Glob to find matches. - match, err := fsys.Glob(pkgdir + string(filepath.Separator) + filepath.FromSlash(pattern)) + match, err := fsys.Glob(pkgdir + string(filepath.Separator) + filepath.FromSlash(glob)) if err != nil { return nil, nil, err } @@ -2086,7 +2091,7 @@ func resolveEmbed(pkgdir string, patterns []string) (files []string, pmap map[st } rel := filepath.ToSlash(path[len(pkgdir)+1:]) name := info.Name() - if path != file && (isBadEmbedName(name) || name[0] == '.' || name[0] == '_') { + if path != file && (isBadEmbedName(name) || ((name[0] == '.' || name[0] == '_') && !all)) { // Ignore bad names, assuming they won't go into modules. // Also avoid hidden files that user may not know about. // See golang.org/issue/42328. diff --git a/src/cmd/go/testdata/script/embed.txt b/src/cmd/go/testdata/script/embed.txt index 04b17cd62b..5f7f6edd77 100644 --- a/src/cmd/go/testdata/script/embed.txt +++ b/src/cmd/go/testdata/script/embed.txt @@ -60,6 +60,18 @@ rm t/x.txt ! go build m/use stderr '^x.go:5:12: pattern [*]t: cannot embed directory t: contains no embeddable files$' +# all still ignores .git and symlinks +cp x.go3 x.go +! go build -x +stderr '^x.go:5:12: pattern all:t: cannot embed directory t: contains no embeddable files$' + +# all finds dot files and underscore files +cp x.txt t/.x.txt +go build -x +rm t/.x.txt +cp x.txt t/_x.txt +go build -x + -- x.go -- package p @@ -92,6 +104,14 @@ import "embed" //go:embed *t var X embed.FS +-- x.go3 -- +package p + +import "embed" + +//go:embed all:t +var X embed.FS + -- x.txt -- hello diff --git a/src/embed/embed.go b/src/embed/embed.go index f87cc5b963..24c3a89e9b 100644 --- a/src/embed/embed.go +++ b/src/embed/embed.go @@ -80,6 +80,11 @@ // var content embed.FS // // The difference is that ‘image/*’ embeds ‘image/.tempfile’ while ‘image’ does not. +// Neither embeds ‘image/dir/.tempfile’. +// +// If a pattern begins with the prefix ‘all:’, then the rule for walking directories is changed +// to include those files beginning with ‘.’ or ‘_’. For example, ‘all:image’ embeds +// both ‘image/.tempfile’ and ‘image/dir/.tempfile’. // // 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. From 55e6e825d4c90544248c3a725b4dee9fb45848e7 Mon Sep 17 00:00:00 2001 From: Carl Johnson Date: Tue, 31 Aug 2021 20:35:35 +0000 Subject: [PATCH 048/752] net/http: add MaxBytesHandler Fixes #39567 Change-Id: I226089b678a6a13d7ce69f360a23fc5bd297d550 GitHub-Last-Rev: 6435fd5881fc70a276d04df5a60440e365924b49 GitHub-Pull-Request: golang/go#48104 Reviewed-on: https://go-review.googlesource.com/c/go/+/346569 Trust: Damien Neil Trust: Ian Lance Taylor Run-TryBot: Damien Neil TryBot-Result: Go Bot Reviewed-by: Damien Neil --- src/net/http/serve_test.go | 60 ++++++++++++++++++++++++++++++++++++++ src/net/http/server.go | 9 ++++++ 2 files changed, 69 insertions(+) diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go index 30a6555d30..1156b187ae 100644 --- a/src/net/http/serve_test.go +++ b/src/net/http/serve_test.go @@ -6682,3 +6682,63 @@ func testQuerySemicolon(t *testing.T, query string, wantX string, allowSemicolon } } } + +func TestMaxBytesHandler(t *testing.T) { + setParallel(t) + defer afterTest(t) + + for _, maxSize := range []int64{100, 1_000, 1_000_000} { + for _, requestSize := range []int64{100, 1_000, 1_000_000} { + t.Run(fmt.Sprintf("max size %d request size %d", maxSize, requestSize), + func(t *testing.T) { + testMaxBytesHandler(t, maxSize, requestSize) + }) + } + } +} + +func testMaxBytesHandler(t *testing.T, maxSize, requestSize int64) { + var ( + handlerN int64 + handlerErr error + ) + echo := HandlerFunc(func(w ResponseWriter, r *Request) { + var buf bytes.Buffer + handlerN, handlerErr = io.Copy(&buf, r.Body) + io.Copy(w, &buf) + }) + + ts := httptest.NewServer(MaxBytesHandler(echo, maxSize)) + defer ts.Close() + + c := ts.Client() + var buf strings.Builder + body := strings.NewReader(strings.Repeat("a", int(requestSize))) + res, err := c.Post(ts.URL, "text/plain", body) + if err != nil { + t.Errorf("unexpected connection error: %v", err) + } else { + _, err = io.Copy(&buf, res.Body) + res.Body.Close() + if err != nil { + t.Errorf("unexpected read error: %v", err) + } + } + if handlerN > maxSize { + t.Errorf("expected max request body %d; got %d", maxSize, handlerN) + } + if requestSize > maxSize && handlerErr == nil { + t.Error("expected error on handler side; got nil") + } + if requestSize <= maxSize { + if handlerErr != nil { + t.Errorf("%d expected nil error on handler side; got %v", requestSize, handlerErr) + } + if handlerN != requestSize { + t.Errorf("expected request of size %d; got %d", requestSize, handlerN) + } + } + if buf.Len() != int(handlerN) { + t.Errorf("expected echo of size %d; got %d", handlerN, buf.Len()) + } +} diff --git a/src/net/http/server.go b/src/net/http/server.go index 08fd478ed9..c4a2d57dd4 100644 --- a/src/net/http/server.go +++ b/src/net/http/server.go @@ -3610,3 +3610,12 @@ func tlsRecordHeaderLooksLikeHTTP(hdr [5]byte) bool { } return false } + +// MaxBytesHandler returns a Handler that runs h with its ResponseWriter and Request.Body wrapped by a MaxBytesReader. +func MaxBytesHandler(h Handler, n int64) Handler { + return HandlerFunc(func(w ResponseWriter, r *Request) { + r2 := *r + r2.Body = MaxBytesReader(w, r.Body, n) + h.ServeHTTP(w, &r2) + }) +} From 01103d533a086afd6c06f3eec5057d46f117d2ff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Chigot?= Date: Tue, 9 Nov 2021 10:01:05 +0100 Subject: [PATCH 049/752] cmd/link: fix GCC startfiles names on AIX Since GCC version 11, the 64-bit version of GCC starting files are now suffixed by "_64" instead of being stored without suffix under "ppc64" multilib directory. Change-Id: Ibe53521ed24d36e5f6282e3574849b9ae11a1e9a Reviewed-on: https://go-review.googlesource.com/c/go/+/362594 Reviewed-by: Cherry Mui Run-TryBot: Cherry Mui TryBot-Result: Go Bot Trust: Ian Lance Taylor --- src/cmd/link/internal/ld/lib.go | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go index 01ab6474b8..91665b2ebb 100644 --- a/src/cmd/link/internal/ld/lib.go +++ b/src/cmd/link/internal/ld/lib.go @@ -1499,8 +1499,19 @@ func (ctxt *Link) hostlink() { } return strings.Trim(string(out), "\n") } - argv = append(argv, getPathFile("crtcxa.o")) - argv = append(argv, getPathFile("crtdbase.o")) + // Since GCC version 11, the 64-bit version of GCC starting files + // are now suffixed by "_64". Even under "-maix64" multilib directory + // "crtcxa.o" is 32-bit. + crtcxa := getPathFile("crtcxa_64.o") + if !filepath.IsAbs(crtcxa) { + crtcxa = getPathFile("crtcxa.o") + } + crtdbase := getPathFile("crtdbase_64.o") + if !filepath.IsAbs(crtdbase) { + crtdbase = getPathFile("crtdbase.o") + } + argv = append(argv, crtcxa) + argv = append(argv, crtdbase) } if ctxt.linkShared { From 81f37a72ea8a05ea3f5771a92b34b352769518cf Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 9 Nov 2021 11:09:13 -0500 Subject: [PATCH 050/752] go/types: minor cleanups in predicates.go This is a clean port of CL 360956 to go/types. Change-Id: Iac437e72bb760e7e90236a86e7473d6a440df081 Reviewed-on: https://go-review.googlesource.com/c/go/+/362615 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/types/predicates.go | 89 ++++++++++++++++++-------------------- 1 file changed, 42 insertions(+), 47 deletions(-) diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go index 1ecb6a8c7e..622c773126 100644 --- a/src/go/types/predicates.go +++ b/src/go/types/predicates.go @@ -8,25 +8,6 @@ package types import "go/token" -// hasName reports whether typ has a name. This includes -// predeclared types, defined types, and type parameters. -// hasName may be called with types that are not fully set up. -func hasName(typ Type) bool { - switch typ.(type) { - case *Basic, *Named, *TypeParam: - return true - } - return false -} - -// isGeneric reports whether a type is a generic, uninstantiated type (generic -// signatures are not included). -func isGeneric(typ Type) bool { - // A parameterized type is only instantiated if it doesn't have an instantiation already. - named, _ := typ.(*Named) - return named != nil && named.obj != nil && named.targs == nil && named.TypeParams() != nil -} - // The isX predicates below report whether t is an X. // If t is a type parameter the result is false; i.e., // these predicates don't look inside a type parameter. @@ -39,6 +20,7 @@ func isComplex(t Type) bool { return isBasic(t, IsComplex) } func isNumeric(t Type) bool { return isBasic(t, IsNumeric) } func isString(t Type) bool { return isBasic(t, IsString) } func isIntegerOrFloat(t Type) bool { return isBasic(t, IsInteger|IsFloat) } +func isConstType(t Type) bool { return isBasic(t, IsConstType) } // isBasic reports whether under(t) is a basic type with the specified info. // If t is a type parameter the result is false; i.e., @@ -76,38 +58,52 @@ func allBasic(t Type, info BasicInfo) bool { return false } -// isTyped reports whether typ is typed; i.e., not an untyped +// hasName reports whether t has a name. This includes +// predeclared types, defined types, and type parameters. +// hasName may be called with types that are not fully set up. +func hasName(t Type) bool { + switch t.(type) { + case *Basic, *Named, *TypeParam: + return true + } + return false +} + +// isTyped reports whether t is typed; i.e., not an untyped // constant or boolean. isTyped may be called with types that // are not fully set up. -func isTyped(typ Type) bool { +func isTyped(t Type) bool { // isTyped is called with types that are not fully // set up. Must not call asBasic()! - t, _ := typ.(*Basic) - return t == nil || t.info&IsUntyped == 0 + b, _ := t.(*Basic) + return b == nil || b.info&IsUntyped == 0 } -// isUntyped(typ) is the same as !isTyped(typ). -func isUntyped(typ Type) bool { - return !isTyped(typ) +// isUntyped(t) is the same as !isTyped(t). +func isUntyped(t Type) bool { + return !isTyped(t) } -func isConstType(typ Type) bool { - // Type parameters are never const types. - t := asBasic(typ) - return t != nil && t.info&IsConstType != 0 +// IsInterface reports whether t is an interface type. +func IsInterface(t Type) bool { + return asInterface(t) != nil } -// IsInterface reports whether typ is an interface type. -func IsInterface(typ Type) bool { - return asInterface(typ) != nil -} - -// isTypeParam reports whether typ is a type parameter. -func isTypeParam(typ Type) bool { - _, ok := under(typ).(*TypeParam) +// isTypeParam reports whether t is a type parameter. +func isTypeParam(t Type) bool { + _, ok := under(t).(*TypeParam) return ok } +// isGeneric reports whether a type is a generic, uninstantiated type +// (generic signatures are not included). +// TODO(gri) should we include signatures or assert that they are not present? +func isGeneric(t Type) bool { + // A parameterized type is only generic if it doesn't have an instantiation already. + named, _ := t.(*Named) + return named != nil && named.obj != nil && named.targs == nil && named.TypeParams() != nil +} + // Comparable reports whether values of type T are comparable. func Comparable(T Type) bool { return comparable(T, nil) @@ -144,15 +140,15 @@ func comparable(T Type, seen map[Type]bool) bool { return false } -// hasNil reports whether a type includes the nil value. -func hasNil(typ Type) bool { - switch t := under(typ).(type) { +// hasNil reports whether type t includes the nil value. +func hasNil(t Type) bool { + switch u := under(t).(type) { case *Basic: - return t.kind == UnsafePointer + return u.kind == UnsafePointer case *Slice, *Pointer, *Signature, *Interface, *Map, *Chan: return true case *TypeParam: - return t.underIs(hasNil) + return u.underIs(hasNil) } return false } @@ -394,9 +390,8 @@ func identicalTParams(x, y []*TypeParam, cmpTags bool, p *ifacePair) bool { // Default returns the default "typed" type for an "untyped" type; // it returns the incoming type for all other types. The default type // for untyped nil is untyped nil. -// -func Default(typ Type) Type { - if t, ok := typ.(*Basic); ok { +func Default(t Type) Type { + if t, ok := t.(*Basic); ok { switch t.kind { case UntypedBool: return Typ[Bool] @@ -412,5 +407,5 @@ func Default(typ Type) Type { return Typ[String] } } - return typ + return t } From 526b2ef0ea3a13d7e9af635918ef3ef86353f220 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 9 Nov 2021 11:14:37 -0500 Subject: [PATCH 051/752] go/types: check non-generic conversions first This is a clean port of CL 361269 to go/types. Change-Id: I2caaf08eabdf1707ae83ec1e628fd26f21b2b8e5 Reviewed-on: https://go-review.googlesource.com/c/go/+/362616 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/types/conversions.go | 119 +++++++++++++++++++----------------- 1 file changed, 62 insertions(+), 57 deletions(-) diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go index c171b2c8d6..f73e6a0964 100644 --- a/src/go/types/conversions.go +++ b/src/go/types/conversions.go @@ -120,64 +120,8 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { return true } - // determine type parameter operands with specific type terms - Vp, _ := under(x.typ).(*TypeParam) - Tp, _ := under(T).(*TypeParam) - if Vp != nil && !Vp.hasTerms() { - Vp = nil - } - if Tp != nil && !Tp.hasTerms() { - Tp = nil - } - - errorf := func(format string, args ...interface{}) { - if check != nil && cause != nil { - msg := check.sprintf(format, args...) - if *cause != "" { - msg += "\n\t" + *cause - } - *cause = msg - } - } - - // generic cases with specific type terms - // (generic operands cannot be constants, so we can ignore x.val) - switch { - case Vp != nil && Tp != nil: - return Vp.is(func(V *term) bool { - return Tp.is(func(T *term) bool { - if !convertibleToImpl(check, V.typ, T.typ, cause) { - errorf("cannot convert %s (in %s) to %s (in %s)", V.typ, Vp, T.typ, Tp) - return false - } - return true - }) - }) - case Vp != nil: - return Vp.is(func(V *term) bool { - if !convertibleToImpl(check, V.typ, T, cause) { - errorf("cannot convert %s (in %s) to %s", V.typ, Vp, T) - return false - } - return true - }) - case Tp != nil: - return Tp.is(func(T *term) bool { - if !convertibleToImpl(check, x.typ, T.typ, cause) { - errorf("cannot convert %s to %s (in %s)", x.typ, T.typ, Tp) - return false - } - return true - }) - } - - // non-generic case - return convertibleToImpl(check, x.typ, T, cause) -} - -// convertibleToImpl should only be called by convertibleTo -func convertibleToImpl(check *Checker, V, T Type, cause *string) bool { // "V and T have identical underlying types if tags are ignored" + V := x.typ Vu := under(V) Tu := under(T) if IdenticalIgnoreTags(Vu, Tu) { @@ -241,6 +185,67 @@ func convertibleToImpl(check *Checker, V, T Type, cause *string) bool { } } + // optimization: if we don't have type parameters, we're done + Vp, _ := Vu.(*TypeParam) + Tp, _ := Tu.(*TypeParam) + if Vp == nil && Tp == nil { + return false + } + + errorf := func(format string, args ...interface{}) { + if check != nil && cause != nil { + msg := check.sprintf(format, args...) + if *cause != "" { + msg += "\n\t" + *cause + } + *cause = msg + } + } + + // generic cases with specific type terms + // (generic operands cannot be constants, so we can ignore x.val) + switch { + case Vp != nil && Tp != nil: + x := *x // don't clobber outer x + return Vp.is(func(V *term) bool { + if V == nil { + return false // no specific types + } + x.typ = V.typ + return Tp.is(func(T *term) bool { + if !x.convertibleTo(check, T.typ, cause) { + errorf("cannot convert %s (in %s) to %s (in %s)", V.typ, Vp, T.typ, Tp) + return false + } + return true + }) + }) + case Vp != nil: + x := *x // don't clobber outer x + return Vp.is(func(V *term) bool { + if V == nil { + return false // no specific types + } + x.typ = V.typ + if !x.convertibleTo(check, T, cause) { + errorf("cannot convert %s (in %s) to %s", V.typ, Vp, T) + return false + } + return true + }) + case Tp != nil: + return Tp.is(func(T *term) bool { + if T == nil { + return false // no specific types + } + if !x.convertibleTo(check, T.typ, cause) { + errorf("cannot convert %s to %s (in %s)", x.typ, T.typ, Tp) + return false + } + return true + }) + } + return false } From f59d36d2e3f0707c8bf2b157009ffc38a9b74d25 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 9 Nov 2021 11:19:20 -0500 Subject: [PATCH 052/752] go/types: make object test an external test This is a port of CL 361409 to go/types. Change-Id: I17ccf8a5b4ba715fd8a87ea2c1811700fb1157e3 Reviewed-on: https://go-review.googlesource.com/c/go/+/362538 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/types/object_test.go | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/src/go/types/object_test.go b/src/go/types/object_test.go index c12af64df7..e9a4bd6dbf 100644 --- a/src/go/types/object_test.go +++ b/src/go/types/object_test.go @@ -2,13 +2,15 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -package types +package types_test import ( "go/ast" "go/parser" "go/token" "testing" + + . "go/types" ) func TestIsAlias(t *testing.T) { @@ -36,15 +38,15 @@ func TestIsAlias(t *testing.T) { name *TypeName alias bool }{ - {NewTypeName(0, nil, "t0", nil), false}, // no type yet - {NewTypeName(0, pkg, "t0", nil), false}, // no type yet - {t1, false}, // type name refers to named type and vice versa - {NewTypeName(0, nil, "t2", &emptyInterface), true}, // type name refers to unnamed type - {NewTypeName(0, pkg, "t3", n1), true}, // type name refers to named type with different type name - {NewTypeName(0, nil, "t4", Typ[Int32]), true}, // type name refers to basic type with different name - {NewTypeName(0, nil, "int32", Typ[Int32]), false}, // type name refers to basic type with same name - {NewTypeName(0, pkg, "int32", Typ[Int32]), true}, // type name is declared in user-defined package (outside Universe) - {NewTypeName(0, nil, "rune", Typ[Rune]), true}, // type name refers to basic type rune which is an alias already + {NewTypeName(0, nil, "t0", nil), false}, // no type yet + {NewTypeName(0, pkg, "t0", nil), false}, // no type yet + {t1, false}, // type name refers to named type and vice versa + {NewTypeName(0, nil, "t2", NewInterfaceType(nil, nil)), true}, // type name refers to unnamed type + {NewTypeName(0, pkg, "t3", n1), true}, // type name refers to named type with different type name + {NewTypeName(0, nil, "t4", Typ[Int32]), true}, // type name refers to basic type with different name + {NewTypeName(0, nil, "int32", Typ[Int32]), false}, // type name refers to basic type with same name + {NewTypeName(0, pkg, "int32", Typ[Int32]), true}, // type name is declared in user-defined package (outside Universe) + {NewTypeName(0, nil, "rune", Typ[Rune]), true}, // type name refers to basic type rune which is an alias already {t5, false}, // type name refers to type parameter and vice versa } { check(test.name, test.alias) From d3aedb72c687cc58e10755eff006a4dd45cb8e15 Mon Sep 17 00:00:00 2001 From: Chaoqun Han Date: Mon, 8 Nov 2021 22:58:51 +0800 Subject: [PATCH 053/752] cmd/compile: NewSelectorExpr use n.Pos instead of base.Pos Fixes #49436 Change-Id: I4c8851e7aaee631d5eb22f2ef0aea5a25e936d87 Reviewed-on: https://go-review.googlesource.com/c/go/+/361917 Run-TryBot: Dan Scales TryBot-Result: Go Bot Reviewed-by: Keith Randall Trust: David Chase --- src/cmd/compile/internal/typecheck/subr.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go index 1986845f64..5b5b043715 100644 --- a/src/cmd/compile/internal/typecheck/subr.go +++ b/src/cmd/compile/internal/typecheck/subr.go @@ -160,7 +160,7 @@ func AddImplicitDots(n *ir.SelectorExpr) *ir.SelectorExpr { 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 := ir.NewSelectorExpr(n.Pos(), ir.ODOT, n.X, path[c].field.Sym) dot.SetImplicit(true) dot.SetType(path[c].field.Type) n.X = dot From 8c20584a8206844be705c50efe8aabb6ab9c503e Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Mon, 8 Nov 2021 13:57:50 -0800 Subject: [PATCH 054/752] bufio: document that NewWriter can return its argument Fixes #49446 Change-Id: Ib0b53a7dd5d567a2dd0bdf29f53d276587b60afb Reviewed-on: https://go-review.googlesource.com/c/go/+/361921 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Go Bot Reviewed-by: Tobias Klauser --- src/bufio/bufio.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/bufio/bufio.go b/src/bufio/bufio.go index 063a7785f3..9ea058db3e 100644 --- a/src/bufio/bufio.go +++ b/src/bufio/bufio.go @@ -593,6 +593,8 @@ func NewWriterSize(w io.Writer, size int) *Writer { } // NewWriter returns a new Writer whose buffer has the default size. +// If the argument io.Writer is already a Writer with large enough buffer size, +// it returns the underlying Writer. func NewWriter(w io.Writer) *Writer { return NewWriterSize(w, defaultBufSize) } From f48115c6502a3fb791dc4b37f5817024c9731ee3 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Mon, 8 Nov 2021 18:30:30 -0800 Subject: [PATCH 055/752] os: clarify that File.{Read,Write} use the buffer Fixes #49470 Change-Id: I81fd4b0e2eef1d8d430b5d1d10c4f824e803a75c Reviewed-on: https://go-review.googlesource.com/c/go/+/362335 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Go Bot Reviewed-by: Brad Fitzpatrick --- src/os/file.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/os/file.go b/src/os/file.go index e717f171e7..2823128554 100644 --- a/src/os/file.go +++ b/src/os/file.go @@ -109,7 +109,7 @@ func (e *LinkError) Unwrap() error { return e.Err } -// Read reads up to len(b) bytes from the File. +// Read reads up to len(b) bytes from the File and stores them in b. // It returns the number of bytes read and any error encountered. // At end of file, Read returns 0, io.EOF. func (f *File) Read(b []byte) (n int, err error) { @@ -166,7 +166,7 @@ type onlyWriter struct { io.Writer } -// Write writes len(b) bytes to the File. +// Write writes len(b) bytes from b to the File. // It returns the number of bytes written and an error, if any. // Write returns a non-nil error when n != len(b). func (f *File) Write(b []byte) (n int, err error) { From 233ea216c730a1902579ab2dea6d752e02d6f6f3 Mon Sep 17 00:00:00 2001 From: Dmitri Shuralyov Date: Tue, 9 Nov 2021 13:31:45 -0500 Subject: [PATCH 056/752] all: update vendored golang.org/x/{arch,sys,term} for Go 1.18 release The Go 1.18 code freeze has recently started. This is a time to update all golang.org/x/... module versions that contribute packages to the std and cmd modules in the standard library to latest master versions. This CL updates only the lower-level modules arch, sys, term for better bisection. The next CL will update further ones. For #36905. Change-Id: I455428c051ec49b446b8b558a6f579cd9be4d796 Reviewed-on: https://go-review.googlesource.com/c/go/+/362734 Trust: Dmitri Shuralyov Run-TryBot: Dmitri Shuralyov Reviewed-by: Heschi Kreinick TryBot-Result: Go Bot --- src/cmd/go.mod | 6 +- src/cmd/go.sum | 11 +- .../golang.org/x/arch/ppc64/ppc64asm/gnu.go | 14 +- .../golang.org/x/arch/ppc64/ppc64asm/plan9.go | 71 ++-- .../golang.org/x/arch/x86/x86asm/plan9x.go | 1 + .../golang.org/x/sys/unix/sockcmsg_linux.go | 49 +++ .../golang.org/x/sys/unix/syscall_aix.go | 22 +- .../golang.org/x/sys/unix/syscall_bsd.go | 24 +- .../golang.org/x/sys/unix/syscall_darwin.go | 21 +- .../golang.org/x/sys/unix/syscall_linux.go | 42 +-- .../golang.org/x/sys/unix/syscall_solaris.go | 16 +- .../x/sys/unix/syscall_zos_s390x.go | 16 +- .../golang.org/x/sys/unix/zerrors_linux.go | 26 ++ .../x/sys/unix/zerrors_linux_386.go | 1 + .../x/sys/unix/zerrors_linux_amd64.go | 1 + .../x/sys/unix/zerrors_linux_arm.go | 1 + .../x/sys/unix/zerrors_linux_arm64.go | 1 + .../x/sys/unix/zerrors_linux_mips.go | 1 + .../x/sys/unix/zerrors_linux_mips64.go | 1 + .../x/sys/unix/zerrors_linux_mips64le.go | 1 + .../x/sys/unix/zerrors_linux_mipsle.go | 1 + .../x/sys/unix/zerrors_linux_ppc.go | 1 + .../x/sys/unix/zerrors_linux_ppc64.go | 1 + .../x/sys/unix/zerrors_linux_ppc64le.go | 1 + .../x/sys/unix/zerrors_linux_riscv64.go | 1 + .../x/sys/unix/zerrors_linux_s390x.go | 1 + .../x/sys/unix/zerrors_linux_sparc64.go | 1 + .../golang.org/x/sys/unix/zsyscall_aix_ppc.go | 22 +- .../x/sys/unix/zsyscall_aix_ppc64.go | 20 +- .../x/sys/unix/zsyscall_aix_ppc64_gc.go | 20 +- .../x/sys/unix/zsyscall_aix_ppc64_gccgo.go | 18 +- .../x/sys/unix/zsysnum_linux_386.go | 1 + .../x/sys/unix/zsysnum_linux_amd64.go | 1 + .../x/sys/unix/zsysnum_linux_arm.go | 2 + .../x/sys/unix/zsysnum_linux_arm64.go | 1 + .../x/sys/unix/zsysnum_linux_mips.go | 1 + .../x/sys/unix/zsysnum_linux_mips64.go | 1 + .../x/sys/unix/zsysnum_linux_mips64le.go | 1 + .../x/sys/unix/zsysnum_linux_mipsle.go | 1 + .../x/sys/unix/zsysnum_linux_ppc.go | 1 + .../x/sys/unix/zsysnum_linux_ppc64.go | 1 + .../x/sys/unix/zsysnum_linux_ppc64le.go | 1 + .../x/sys/unix/zsysnum_linux_riscv64.go | 1 + .../x/sys/unix/zsysnum_linux_s390x.go | 1 + .../x/sys/unix/zsysnum_linux_sparc64.go | 1 + .../x/sys/unix/ztypes_darwin_amd64.go | 6 +- .../x/sys/unix/ztypes_darwin_arm64.go | 6 +- .../golang.org/x/sys/unix/ztypes_linux.go | 7 +- .../x/sys/unix/ztypes_openbsd_386.go | 11 +- .../x/sys/unix/ztypes_openbsd_amd64.go | 11 +- .../x/sys/unix/ztypes_openbsd_arm.go | 11 +- .../x/sys/unix/ztypes_openbsd_arm64.go | 11 +- .../x/sys/unix/ztypes_openbsd_mips64.go | 11 +- .../golang.org/x/sys/windows/aliases.go | 4 +- .../golang.org/x/sys/windows/eventlog.go | 1 + .../golang.org/x/sys/windows/mksyscall.go | 1 + .../vendor/golang.org/x/sys/windows/race.go | 1 + .../vendor/golang.org/x/sys/windows/race0.go | 1 + .../golang.org/x/sys/windows/service.go | 14 +- .../vendor/golang.org/x/sys/windows/str.go | 1 + .../golang.org/x/sys/windows/syscall.go | 1 + .../x/sys/windows/syscall_windows.go | 26 +- .../golang.org/x/sys/windows/types_windows.go | 337 +++++++++++++++++- .../x/sys/windows/zsyscall_windows.go | 120 +++++++ .../vendor/golang.org/x/term/codereview.cfg | 1 + src/cmd/vendor/golang.org/x/term/term.go | 2 + src/cmd/vendor/modules.txt | 6 +- src/go.mod | 2 +- src/go.sum | 4 +- src/vendor/golang.org/x/sys/cpu/cpu_x86.go | 7 +- src/vendor/golang.org/x/sys/cpu/cpu_x86.s | 24 -- src/vendor/modules.txt | 2 +- 72 files changed, 790 insertions(+), 267 deletions(-) create mode 100644 src/cmd/vendor/golang.org/x/term/codereview.cfg diff --git a/src/cmd/go.mod b/src/cmd/go.mod index f7802a1675..ea4e8a3104 100644 --- a/src/cmd/go.mod +++ b/src/cmd/go.mod @@ -4,16 +4,16 @@ go 1.18 require ( github.com/google/pprof v0.0.0-20211104044539-f987b9c94b31 - golang.org/x/arch v0.0.0-20210901143047-ebb09ed340f1 + golang.org/x/arch v0.0.0-20210923205945-b76863e36670 golang.org/x/mod v0.5.1-0.20210913215816-37dd6891021a golang.org/x/sync v0.0.0-20210220032951-036812b2e83c - golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b + golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 golang.org/x/tools v0.1.8-0.20211025211149-f916b54a1784 ) require ( github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d // indirect golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 // indirect - golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac // indirect + golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e // indirect golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect ) diff --git a/src/cmd/go.sum b/src/cmd/go.sum index 25c25d81bd..01da0f686c 100644 --- a/src/cmd/go.sum +++ b/src/cmd/go.sum @@ -5,18 +5,19 @@ github.com/google/pprof v0.0.0-20211104044539-f987b9c94b31 h1:YvpxjnjGhf/vDEeYOy github.com/google/pprof v0.0.0-20211104044539-f987b9c94b31/go.mod h1:KgnwoLYCZ8IQu3XUZ8Nc/bM9CCZFOyjUNOSygVozoDg= github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d h1:uGg2frlt3IcT7kbV6LEp5ONv4vmoO2FW4qSO+my/aoM= github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d/go.mod h1:aYm2/VgdVmcIU8iMfdMvDMsRAQjcfZSKFby6HOFvi/w= -golang.org/x/arch v0.0.0-20210901143047-ebb09ed340f1 h1:MwxAfiDvuwX8Nnnc6iRDhzyMyyc2tz5tYyCP/pZcPCg= -golang.org/x/arch v0.0.0-20210901143047-ebb09ed340f1/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= +golang.org/x/arch v0.0.0-20210923205945-b76863e36670 h1:18EFjUmQOcUvxNYSkA6jO9VAiXCnxFY6NyDX0bHDmkU= +golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ= golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/mod v0.5.1-0.20210913215816-37dd6891021a h1:55PVa91KndtPGH2lus5l2gDZqoO/x+Oa5CV0lVf8Ij8= golang.org/x/mod v0.5.1-0.20210913215816-37dd6891021a/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac h1:oN6lz7iLW/YC7un8pq+9bOLyXrprv2+DKfkJY+2LJJw= golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b h1:9zKuko04nR4gjZ4+DNjHqRlAJqbJETHwiNKDqTfOjfE= -golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= +golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e h1:i6Vklmyu+fZMFYpum+sR4ZWABGW7MyIxfJZXYvcnbns= +golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY= +golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/tools v0.1.8-0.20211025211149-f916b54a1784 h1:+xP+QoP2SEPgbn+07I/yJTzP+gavj0XKGS6+JU5tlck= golang.org/x/tools v0.1.8-0.20211025211149-f916b54a1784/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= diff --git a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go index 225ef4fb88..b4c9bf8df6 100644 --- a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go +++ b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/gnu.go @@ -297,12 +297,17 @@ func GNUSyntax(inst Inst, pc uint64) string { gnuArg(&inst, 0, inst.Args[0], PC), gnuArg(&inst, 2, inst.Args[2], PC)) startArg = 4 - } else if r == 0 { + } else { str = fmt.Sprintf("%s %s,%s,%s", opName, gnuArg(&inst, 0, inst.Args[0], PC), gnuArg(&inst, 1, inst.Args[1], PC), gnuArg(&inst, 2, inst.Args[2], PC)) startArg = 4 + if r == 1 { + // This is an illegal encoding (ra != 0 && r == 1) on ISA 3.1. + v := uint64(inst.Enc)<<32 | uint64(inst.SuffixEnc) + return fmt.Sprintf(".quad 0x%x", v) + } } buf.WriteString(str) @@ -317,11 +322,16 @@ func GNUSyntax(inst Inst, pc uint64) string { str := fmt.Sprintf("%s %s,%d", opName, gnuArg(&inst, 0, inst.Args[0], PC), d) buf.WriteString(str) startArg = 4 - } else if r == 0 { + } else { str := fmt.Sprintf("%s %s,%d(%s)", opName, gnuArg(&inst, 0, inst.Args[0], PC), d, gnuArg(&inst, 2, inst.Args[2], PC)) + if r == 1 { + // This is an invalid encoding (ra != 0 && r == 1) on ISA 3.1. + v := uint64(inst.Enc)<<32 | uint64(inst.SuffixEnc) + return fmt.Sprintf(".quad 0x%x", v) + } buf.WriteString(str) startArg = 4 } diff --git a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/plan9.go b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/plan9.go index 89b917320a..88e8e1c747 100644 --- a/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/plan9.go +++ b/src/cmd/vendor/golang.org/x/arch/ppc64/ppc64asm/plan9.go @@ -30,18 +30,7 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64)) strin break } if s := plan9Arg(&inst, i, pc, a, symname); s != "" { - // In the case for some BC instructions, a CondReg arg has - // both the CR and the branch condition encoded in its value. - // plan9Arg will return a string with the string representation - // of these values separated by a blank that will be treated - // as 2 args from this point on. - if strings.IndexByte(s, ' ') > 0 { - t := strings.Split(s, " ") - args = append(args, t[0]) - args = append(args, t[1]) - } else { - args = append(args, s) - } + args = append(args, s) } } var op string @@ -61,7 +50,7 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64)) strin case 1: return fmt.Sprintf("%s %s", op, args[0]) case 2: - if inst.Op == COPY || inst.Op == PASTECC || inst.Op == FCMPO || inst.Op == FCMPU { + if inst.Op == COPY || inst.Op == PASTECC { return op + " " + args[0] + "," + args[1] } return op + " " + args[1] + "," + args[0] @@ -97,13 +86,13 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64)) strin STQ, STFD, STFDU, STFS, STFSU: return op + " " + strings.Join(args, ",") - case CMPD, CMPDI, CMPLD, CMPLDI, CMPW, CMPWI, CMPLW, CMPLWI: - if len(args) == 2 { - return op + " " + args[0] + "," + args[1] - } else if len(args) == 3 { - return op + " " + args[0] + "," + args[1] + "," + args[2] + case FCMPU, FCMPO, CMPD, CMPDI, CMPLD, CMPLDI, CMPW, CMPWI, CMPLW, CMPLWI: + crf := int(inst.Args[0].(CondReg) - CR0) + cmpstr := op + " " + args[1] + "," + args[2] + if crf != 0 { // print CRx as the final operand if not implied (i.e BF != 0) + cmpstr += "," + args[0] } - return op + " " + args[0] + " ??" + return cmpstr case LIS: return "ADDIS $0," + args[1] + "," + args[0] @@ -152,16 +141,15 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64)) strin } return op + " " + strings.Join(args, ", ") case BC: - if int(inst.Args[0].(Imm))&0x1c == 12 { // jump on cond bit set - if len(args) == 4 { - return fmt.Sprintf("B%s %s,%s", args[1], args[2], args[3]) + bo := int(inst.Args[0].(Imm)) + bi := int(inst.Args[1].(CondReg) - Cond0LT) + bcname := condName[((bo&0x8)>>1)|(bi&0x3)] + if bo&0x17 == 4 { // jump only a CR bit set/unset, no hints (at bits) set. + if bi >= 4 { + return fmt.Sprintf("B%s CR%d,%s", bcname, bi>>2, args[2]) + } else { + return fmt.Sprintf("B%s %s", bcname, args[2]) } - return fmt.Sprintf("B%s %s", args[1], args[2]) - } else if int(inst.Args[0].(Imm))&0x1c == 4 && revCondMap[args[1]] != "" { // jump on cond bit not set - if len(args) == 4 { - return fmt.Sprintf("B%s %s,%s", revCondMap[args[1]], args[2], args[3]) - } - return fmt.Sprintf("B%s %s", revCondMap[args[1]], args[2]) } return op + " " + strings.Join(args, ",") case BCCTR: @@ -203,19 +191,14 @@ func plan9Arg(inst *Inst, argIndex int, pc uint64, arg Arg, symname func(uint64) if inst.Op == ISEL { return fmt.Sprintf("$%d", (arg - Cond0LT)) } - if arg == CR0 && (strings.HasPrefix(inst.Op.String(), "cmp") || strings.HasPrefix(inst.Op.String(), "fcmp")) { - return "" // don't show cr0 for cmp instructions - } else if arg >= CR0 { - return fmt.Sprintf("CR%d", int(arg-CR0)) - } bit := [4]string{"LT", "GT", "EQ", "SO"}[(arg-Cond0LT)%4] - if strings.HasPrefix(inst.Op.String(), "cr") { - return fmt.Sprintf("CR%d%s", int(arg-Cond0LT)/4, bit) - } if arg <= Cond0SO { return bit + } else if arg > Cond0SO && arg <= Cond7SO { + return fmt.Sprintf("CR%d%s", int(arg-Cond0LT)/4, bit) + } else { + return fmt.Sprintf("CR%d", int(arg-CR0)) } - return fmt.Sprintf("%s CR%d", bit, int(arg-Cond0LT)/4) case Imm: return fmt.Sprintf("$%d", arg) case SpReg: @@ -281,6 +264,20 @@ var revCondMap = map[string]string{ "LT": "GE", "GT": "LE", "EQ": "NE", } +// Lookup table to map BI[0:1] and BO[3] to an extended mnemonic for CR ops. +// Bits 0-1 map to a bit with a CR field, and bit 2 selects the inverted (0) +// or regular (1) extended mnemonic. +var condName = []string{ + "GE", + "LE", + "NE", + "NSO", + "LT", + "GT", + "EQ", + "SO", +} + // plan9OpMap maps an Op to its Plan 9 mnemonics, if different than its GNU mnemonics. var plan9OpMap = map[Op]string{ LWARX: "LWAR", diff --git a/src/cmd/vendor/golang.org/x/arch/x86/x86asm/plan9x.go b/src/cmd/vendor/golang.org/x/arch/x86/x86asm/plan9x.go index a93bffd441..59d8f97753 100644 --- a/src/cmd/vendor/golang.org/x/arch/x86/x86asm/plan9x.go +++ b/src/cmd/vendor/golang.org/x/arch/x86/x86asm/plan9x.go @@ -204,6 +204,7 @@ var plan9Suffix = [maxOp + 1]bool{ OUT: true, POP: true, POPA: true, + POPCNT: true, PUSH: true, PUSHA: true, RCL: true, diff --git a/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_linux.go index 8bf4570594..5f63147e06 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_linux.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_linux.go @@ -34,3 +34,52 @@ func ParseUnixCredentials(m *SocketControlMessage) (*Ucred, error) { ucred := *(*Ucred)(unsafe.Pointer(&m.Data[0])) return &ucred, nil } + +// PktInfo4 encodes Inet4Pktinfo into a socket control message of type IP_PKTINFO. +func PktInfo4(info *Inet4Pktinfo) []byte { + b := make([]byte, CmsgSpace(SizeofInet4Pktinfo)) + h := (*Cmsghdr)(unsafe.Pointer(&b[0])) + h.Level = SOL_IP + h.Type = IP_PKTINFO + h.SetLen(CmsgLen(SizeofInet4Pktinfo)) + *(*Inet4Pktinfo)(h.data(0)) = *info + return b +} + +// PktInfo6 encodes Inet6Pktinfo into a socket control message of type IPV6_PKTINFO. +func PktInfo6(info *Inet6Pktinfo) []byte { + b := make([]byte, CmsgSpace(SizeofInet6Pktinfo)) + h := (*Cmsghdr)(unsafe.Pointer(&b[0])) + h.Level = SOL_IPV6 + h.Type = IPV6_PKTINFO + h.SetLen(CmsgLen(SizeofInet6Pktinfo)) + *(*Inet6Pktinfo)(h.data(0)) = *info + return b +} + +// ParseOrigDstAddr decodes a socket control message containing the original +// destination address. To receive such a message the IP_RECVORIGDSTADDR or +// IPV6_RECVORIGDSTADDR option must be enabled on the socket. +func ParseOrigDstAddr(m *SocketControlMessage) (Sockaddr, error) { + switch { + case m.Header.Level == SOL_IP && m.Header.Type == IP_ORIGDSTADDR: + pp := (*RawSockaddrInet4)(unsafe.Pointer(&m.Data[0])) + sa := new(SockaddrInet4) + p := (*[2]byte)(unsafe.Pointer(&pp.Port)) + sa.Port = int(p[0])<<8 + int(p[1]) + sa.Addr = pp.Addr + return sa, nil + + case m.Header.Level == SOL_IPV6 && m.Header.Type == IPV6_ORIGDSTADDR: + pp := (*RawSockaddrInet6)(unsafe.Pointer(&m.Data[0])) + sa := new(SockaddrInet6) + p := (*[2]byte)(unsafe.Pointer(&pp.Port)) + sa.Port = int(p[0])<<8 + int(p[1]) + sa.ZoneId = pp.Scope_id + sa.Addr = pp.Addr + return sa, nil + + default: + return nil, EINVAL + } +} 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 d8efb715ff..6192750ce3 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_aix.go @@ -70,9 +70,7 @@ func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil } @@ -85,9 +83,7 @@ func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) sa.raw.Scope_id = sa.ZoneId - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil } @@ -261,9 +257,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { sa := new(SockaddrInet4) p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil case AF_INET6: @@ -272,9 +266,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) sa.ZoneId = pp.Scope_id - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil } return nil, EAFNOSUPPORT @@ -385,6 +377,11 @@ func (w WaitStatus) TrapCause() int { return -1 } //sys fcntl(fd int, cmd int, arg int) (val int, err error) +//sys fsyncRange(fd int, how int, start int64, length int64) (err error) = fsync_range +func Fsync(fd int) error { + return fsyncRange(fd, O_SYNC, 0, 0) +} + /* * Direct access */ @@ -401,7 +398,6 @@ func (w WaitStatus) TrapCause() int { return -1 } //sys Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) //sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) //sys Fdatasync(fd int) (err error) -//sys Fsync(fd int) (err error) // readdir_r //sysnb Getpgid(pid int) (pgid int, err error) 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 95ac3946b5..0ce4523261 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_bsd.go @@ -163,9 +163,7 @@ func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil } @@ -179,9 +177,7 @@ func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) sa.raw.Scope_id = sa.ZoneId - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil } @@ -210,9 +206,7 @@ func (sa *SockaddrDatalink) sockaddr() (unsafe.Pointer, _Socklen, error) { sa.raw.Nlen = sa.Nlen sa.raw.Alen = sa.Alen sa.raw.Slen = sa.Slen - for i := 0; i < len(sa.raw.Data); i++ { - sa.raw.Data[i] = sa.Data[i] - } + sa.raw.Data = sa.Data return unsafe.Pointer(&sa.raw), SizeofSockaddrDatalink, nil } @@ -228,9 +222,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { sa.Nlen = pp.Nlen sa.Alen = pp.Alen sa.Slen = pp.Slen - for i := 0; i < len(sa.Data); i++ { - sa.Data[i] = pp.Data[i] - } + sa.Data = pp.Data return sa, nil case AF_UNIX: @@ -262,9 +254,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { sa := new(SockaddrInet4) p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil case AF_INET6: @@ -273,9 +263,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) sa.ZoneId = pp.Scope_id - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil } return anyToSockaddrGOOS(fd, rsa) 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 a8c13317d7..8826f41435 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_darwin.go @@ -430,8 +430,25 @@ func GetsockoptXucred(fd, level, opt int) (*Xucred, error) { return x, err } -func SysctlKinfoProcSlice(name string) ([]KinfoProc, error) { - mib, err := sysctlmib(name) +func SysctlKinfoProc(name string, args ...int) (*KinfoProc, error) { + mib, err := sysctlmib(name, args...) + if err != nil { + return nil, err + } + + var kinfo KinfoProc + n := uintptr(SizeofKinfoProc) + if err := sysctl(mib, (*byte)(unsafe.Pointer(&kinfo)), &n, nil, 0); err != nil { + return nil, err + } + if n != SizeofKinfoProc { + return nil, EIO + } + return &kinfo, nil +} + +func SysctlKinfoProcSlice(name string, args ...int) ([]KinfoProc, error) { + mib, err := sysctlmib(name, args...) if err != nil { return nil, 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 fff38a84c9..bc9dc2e10a 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go @@ -372,9 +372,7 @@ func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil } @@ -387,9 +385,7 @@ func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) sa.raw.Scope_id = sa.ZoneId - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil } @@ -438,9 +434,7 @@ func (sa *SockaddrLinklayer) sockaddr() (unsafe.Pointer, _Socklen, error) { sa.raw.Hatype = sa.Hatype sa.raw.Pkttype = sa.Pkttype sa.raw.Halen = sa.Halen - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), SizeofSockaddrLinklayer, nil } @@ -855,12 +849,10 @@ func (sa *SockaddrTIPC) sockaddr() (unsafe.Pointer, _Socklen, error) { if sa.Addr == nil { return nil, 0, EINVAL } - sa.raw.Family = AF_TIPC sa.raw.Scope = int8(sa.Scope) sa.raw.Addrtype = sa.Addr.tipcAddrtype() sa.raw.Addr = sa.Addr.tipcAddr() - return unsafe.Pointer(&sa.raw), SizeofSockaddrTIPC, nil } @@ -874,9 +866,7 @@ type SockaddrL2TPIP struct { func (sa *SockaddrL2TPIP) sockaddr() (unsafe.Pointer, _Socklen, error) { sa.raw.Family = AF_INET sa.raw.Conn_id = sa.ConnId - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP, nil } @@ -892,9 +882,7 @@ func (sa *SockaddrL2TPIP6) sockaddr() (unsafe.Pointer, _Socklen, error) { sa.raw.Family = AF_INET6 sa.raw.Conn_id = sa.ConnId sa.raw.Scope_id = sa.ZoneId - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), SizeofSockaddrL2TPIP6, nil } @@ -990,9 +978,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { sa.Hatype = pp.Hatype sa.Pkttype = pp.Pkttype sa.Halen = pp.Halen - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil case AF_UNIX: @@ -1031,18 +1017,14 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { pp := (*RawSockaddrL2TPIP)(unsafe.Pointer(rsa)) sa := new(SockaddrL2TPIP) sa.ConnId = pp.Conn_id - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil default: pp := (*RawSockaddrInet4)(unsafe.Pointer(rsa)) sa := new(SockaddrInet4) p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil } @@ -1058,9 +1040,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { sa := new(SockaddrL2TPIP6) sa.ConnId = pp.Conn_id sa.ZoneId = pp.Scope_id - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil default: pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) @@ -1068,9 +1048,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) sa.ZoneId = pp.Scope_id - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil } 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 d2a6495c7e..8b88ac2133 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_solaris.go @@ -92,9 +92,7 @@ func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), SizeofSockaddrInet4, nil } @@ -107,9 +105,7 @@ func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) sa.raw.Scope_id = sa.ZoneId - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), SizeofSockaddrInet6, nil } @@ -417,9 +413,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { sa := new(SockaddrInet4) p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil case AF_INET6: @@ -428,9 +422,7 @@ func anyToSockaddr(fd int, rsa *RawSockaddrAny) (Sockaddr, error) { p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) sa.ZoneId = pp.Scope_id - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil } return nil, EAFNOSUPPORT diff --git a/src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go b/src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go index 1ffd8bfcfb..5fb76a1468 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_zos_s390x.go @@ -67,9 +67,7 @@ func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, _Socklen, error) { p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil } @@ -83,9 +81,7 @@ func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, _Socklen, error) { p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) sa.raw.Scope_id = sa.ZoneId - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), _Socklen(sa.raw.Len), nil } @@ -144,9 +140,7 @@ func anyToSockaddr(_ int, rsa *RawSockaddrAny) (Sockaddr, error) { sa := new(SockaddrInet4) p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil case AF_INET6: @@ -155,9 +149,7 @@ func anyToSockaddr(_ int, rsa *RawSockaddrAny) (Sockaddr, error) { p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) sa.ZoneId = pp.Scope_id - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil } return nil, EAFNOSUPPORT 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 78d4b85ece..3bbc527519 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go @@ -116,6 +116,7 @@ const ( ARPHRD_LAPB = 0x204 ARPHRD_LOCALTLK = 0x305 ARPHRD_LOOPBACK = 0x304 + ARPHRD_MCTP = 0x122 ARPHRD_METRICOM = 0x17 ARPHRD_NETLINK = 0x338 ARPHRD_NETROM = 0x0 @@ -472,6 +473,7 @@ const ( DM_DEV_WAIT = 0xc138fd08 DM_DIR = "mapper" DM_GET_TARGET_VERSION = 0xc138fd11 + DM_IMA_MEASUREMENT_FLAG = 0x80000 DM_INACTIVE_PRESENT_FLAG = 0x40 DM_INTERNAL_SUSPEND_FLAG = 0x40000 DM_IOCTL = 0xfd @@ -716,6 +718,7 @@ const ( ETH_P_LOOPBACK = 0x9000 ETH_P_MACSEC = 0x88e5 ETH_P_MAP = 0xf9 + ETH_P_MCTP = 0xfa ETH_P_MOBITEX = 0x15 ETH_P_MPLS_MC = 0x8848 ETH_P_MPLS_UC = 0x8847 @@ -751,6 +754,21 @@ const ( ETH_P_WCCP = 0x883e ETH_P_X25 = 0x805 ETH_P_XDSA = 0xf8 + EV_ABS = 0x3 + EV_CNT = 0x20 + EV_FF = 0x15 + EV_FF_STATUS = 0x17 + EV_KEY = 0x1 + EV_LED = 0x11 + EV_MAX = 0x1f + EV_MSC = 0x4 + EV_PWR = 0x16 + EV_REL = 0x2 + EV_REP = 0x14 + EV_SND = 0x12 + EV_SW = 0x5 + EV_SYN = 0x0 + EV_VERSION = 0x10001 EXABYTE_ENABLE_NEST = 0xf0 EXT2_SUPER_MAGIC = 0xef53 EXT3_SUPER_MAGIC = 0xef53 @@ -789,9 +807,11 @@ const ( FAN_DELETE_SELF = 0x400 FAN_DENY = 0x2 FAN_ENABLE_AUDIT = 0x40 + FAN_EPIDFD = -0x2 FAN_EVENT_INFO_TYPE_DFID = 0x3 FAN_EVENT_INFO_TYPE_DFID_NAME = 0x2 FAN_EVENT_INFO_TYPE_FID = 0x1 + FAN_EVENT_INFO_TYPE_PIDFD = 0x4 FAN_EVENT_METADATA_LEN = 0x18 FAN_EVENT_ON_CHILD = 0x8000000 FAN_MARK_ADD = 0x1 @@ -811,6 +831,7 @@ const ( FAN_MOVE_SELF = 0x800 FAN_NOFD = -0x1 FAN_NONBLOCK = 0x2 + FAN_NOPIDFD = -0x1 FAN_ONDIR = 0x40000000 FAN_OPEN = 0x20 FAN_OPEN_EXEC = 0x1000 @@ -821,6 +842,7 @@ const ( FAN_REPORT_DIR_FID = 0x400 FAN_REPORT_FID = 0x200 FAN_REPORT_NAME = 0x800 + FAN_REPORT_PIDFD = 0x80 FAN_REPORT_TID = 0x100 FAN_UNLIMITED_MARKS = 0x20 FAN_UNLIMITED_QUEUE = 0x10 @@ -1997,6 +2019,7 @@ const ( PR_SPEC_ENABLE = 0x2 PR_SPEC_FORCE_DISABLE = 0x8 PR_SPEC_INDIRECT_BRANCH = 0x1 + PR_SPEC_L1D_FLUSH = 0x2 PR_SPEC_NOT_AFFECTED = 0x0 PR_SPEC_PRCTL = 0x1 PR_SPEC_STORE_BYPASS = 0x0 @@ -2432,12 +2455,15 @@ const ( SMART_WRITE_THRESHOLDS = 0xd7 SMB_SUPER_MAGIC = 0x517b SOCKFS_MAGIC = 0x534f434b + SOCK_BUF_LOCK_MASK = 0x3 SOCK_DCCP = 0x6 SOCK_IOC_TYPE = 0x89 SOCK_PACKET = 0xa SOCK_RAW = 0x3 + SOCK_RCVBUF_LOCK = 0x2 SOCK_RDM = 0x4 SOCK_SEQPACKET = 0x5 + SOCK_SNDBUF_LOCK = 0x1 SOL_AAL = 0x109 SOL_ALG = 0x117 SOL_ATM = 0x108 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 697811a460..80c790840c 100644 --- 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 @@ -293,6 +293,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x6 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 7d8d93bfc4..da55638a44 100644 --- 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 @@ -294,6 +294,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x6 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 f707d50894..c3da063c70 100644 --- 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 @@ -300,6 +300,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x6 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 3a67a9c852..fd9f0d1dbf 100644 --- 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 @@ -290,6 +290,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x6 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 a7ccef56c5..c358ada0d3 100644 --- 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 @@ -293,6 +293,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x20 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 f7b7cec910..1dc1ee16b9 100644 --- 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 @@ -293,6 +293,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x20 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 4fcacf9584..3ae187dd93 100644 --- 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 @@ -293,6 +293,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x20 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 6f6c223a2c..39895f0dd1 100644 --- 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 @@ -293,6 +293,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x20 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go index 59e522bcf4..a98a45537b 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go @@ -348,6 +348,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x6 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 d4264a0f73..0a8fbbffaa 100644 --- 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 @@ -352,6 +352,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x6 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 21cbec1dd3..cb835a1442 100644 --- 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 @@ -352,6 +352,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x6 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 9b05bf12fc..73cf6554b0 100644 --- 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 @@ -281,6 +281,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x6 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 bd82ace09a..04b6dfaf5f 100644 --- 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 @@ -356,6 +356,7 @@ const ( SO_BPF_EXTENSIONS = 0x30 SO_BROADCAST = 0x6 SO_BSDCOMPAT = 0xe + SO_BUF_LOCK = 0x48 SO_BUSY_POLL = 0x2e SO_BUSY_POLL_BUDGET = 0x46 SO_CNX_ADVICE = 0x35 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 1f8bded56b..8c87d979d4 100644 --- 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 @@ -347,6 +347,7 @@ const ( SO_BPF_EXTENSIONS = 0x32 SO_BROADCAST = 0x20 SO_BSDCOMPAT = 0x400 + SO_BUF_LOCK = 0x51 SO_BUSY_POLL = 0x30 SO_BUSY_POLL_BUDGET = 0x49 SO_CNX_ADVICE = 0x37 diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc.go index 91a23cc728..85e0cc3866 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc.go @@ -17,6 +17,7 @@ int getdirent(int, uintptr_t, size_t); int wait4(int, uintptr_t, int, uintptr_t); int ioctl(int, int, uintptr_t); int fcntl(uintptr_t, int, uintptr_t); +int fsync_range(int, int, long long, long long); int acct(uintptr_t); int chdir(uintptr_t); int chroot(uintptr_t); @@ -29,7 +30,6 @@ int fchmod(int, unsigned int); int fchmodat(int, uintptr_t, unsigned int, int); int fchownat(int, uintptr_t, int, int, int); int fdatasync(int); -int fsync(int); int getpgid(int); int getpgrp(); int getpid(); @@ -255,6 +255,16 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func fsyncRange(fd int, how int, start int64, length int64) (err error) { + r0, er := C.fsync_range(C.int(fd), C.int(how), C.longlong(start), C.longlong(length)) + if r0 == -1 && er != nil { + err = er + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func Acct(path string) (err error) { _p0 := uintptr(unsafe.Pointer(C.CString(path))) r0, er := C.acct(C.uintptr_t(_p0)) @@ -379,16 +389,6 @@ func Fdatasync(fd int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Fsync(fd int) (err error) { - r0, er := C.fsync(C.int(fd)) - if r0 == -1 && er != nil { - err = er - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getpgid(pid int) (pgid int, err error) { r0, er := C.getpgid(C.int(pid)) pgid = int(r0) diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64.go index 33c2609b8b..f1d4a73b08 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64.go @@ -135,6 +135,16 @@ func fcntl(fd int, cmd int, arg int) (val int, err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func fsyncRange(fd int, how int, start int64, length int64) (err error) { + _, e1 := callfsync_range(fd, how, start, length) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func Acct(path string) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) @@ -283,16 +293,6 @@ func Fdatasync(fd int) (err error) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func Fsync(fd int) (err error) { - _, e1 := callfsync(fd) - if e1 != 0 { - err = errnoErr(e1) - } - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func Getpgid(pid int) (pgid int, err error) { r0, e1 := callgetpgid(pid) pgid = int(r0) diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gc.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gc.go index 8b737fa971..2caa5adf95 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gc.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gc.go @@ -18,6 +18,7 @@ import ( //go:cgo_import_dynamic libc_wait4 wait4 "libc.a/shr_64.o" //go:cgo_import_dynamic libc_ioctl ioctl "libc.a/shr_64.o" //go:cgo_import_dynamic libc_fcntl fcntl "libc.a/shr_64.o" +//go:cgo_import_dynamic libc_fsync_range fsync_range "libc.a/shr_64.o" //go:cgo_import_dynamic libc_acct acct "libc.a/shr_64.o" //go:cgo_import_dynamic libc_chdir chdir "libc.a/shr_64.o" //go:cgo_import_dynamic libc_chroot chroot "libc.a/shr_64.o" @@ -30,7 +31,6 @@ import ( //go:cgo_import_dynamic libc_fchmodat fchmodat "libc.a/shr_64.o" //go:cgo_import_dynamic libc_fchownat fchownat "libc.a/shr_64.o" //go:cgo_import_dynamic libc_fdatasync fdatasync "libc.a/shr_64.o" -//go:cgo_import_dynamic libc_fsync fsync "libc.a/shr_64.o" //go:cgo_import_dynamic libc_getpgid getpgid "libc.a/shr_64.o" //go:cgo_import_dynamic libc_getpgrp getpgrp "libc.a/shr_64.o" //go:cgo_import_dynamic libc_getpid getpid "libc.a/shr_64.o" @@ -136,6 +136,7 @@ import ( //go:linkname libc_wait4 libc_wait4 //go:linkname libc_ioctl libc_ioctl //go:linkname libc_fcntl libc_fcntl +//go:linkname libc_fsync_range libc_fsync_range //go:linkname libc_acct libc_acct //go:linkname libc_chdir libc_chdir //go:linkname libc_chroot libc_chroot @@ -148,7 +149,6 @@ import ( //go:linkname libc_fchmodat libc_fchmodat //go:linkname libc_fchownat libc_fchownat //go:linkname libc_fdatasync libc_fdatasync -//go:linkname libc_fsync libc_fsync //go:linkname libc_getpgid libc_getpgid //go:linkname libc_getpgrp libc_getpgrp //go:linkname libc_getpid libc_getpid @@ -257,6 +257,7 @@ var ( libc_wait4, libc_ioctl, libc_fcntl, + libc_fsync_range, libc_acct, libc_chdir, libc_chroot, @@ -269,7 +270,6 @@ var ( libc_fchmodat, libc_fchownat, libc_fdatasync, - libc_fsync, libc_getpgid, libc_getpgrp, libc_getpid, @@ -430,6 +430,13 @@ func callfcntl(fd uintptr, cmd int, arg uintptr) (r1 uintptr, e1 Errno) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func callfsync_range(fd int, how int, start int64, length int64) (r1 uintptr, e1 Errno) { + r1, _, e1 = syscall6(uintptr(unsafe.Pointer(&libc_fsync_range)), 4, uintptr(fd), uintptr(how), uintptr(start), uintptr(length), 0, 0) + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func callacct(_p0 uintptr) (r1 uintptr, e1 Errno) { r1, _, e1 = syscall6(uintptr(unsafe.Pointer(&libc_acct)), 1, _p0, 0, 0, 0, 0, 0) return @@ -514,13 +521,6 @@ func callfdatasync(fd int) (r1 uintptr, e1 Errno) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func callfsync(fd int) (r1 uintptr, e1 Errno) { - r1, _, e1 = syscall6(uintptr(unsafe.Pointer(&libc_fsync)), 1, uintptr(fd), 0, 0, 0, 0, 0) - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func callgetpgid(pid int) (r1 uintptr, e1 Errno) { r1, _, e1 = rawSyscall6(uintptr(unsafe.Pointer(&libc_getpgid)), 1, uintptr(pid), 0, 0, 0, 0, 0) return diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gccgo.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gccgo.go index 3c260917ed..944a714b1a 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gccgo.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_aix_ppc64_gccgo.go @@ -16,6 +16,7 @@ int getdirent(int, uintptr_t, size_t); int wait4(int, uintptr_t, int, uintptr_t); int ioctl(int, int, uintptr_t); int fcntl(uintptr_t, int, uintptr_t); +int fsync_range(int, int, long long, long long); int acct(uintptr_t); int chdir(uintptr_t); int chroot(uintptr_t); @@ -28,7 +29,6 @@ int fchmod(int, unsigned int); int fchmodat(int, uintptr_t, unsigned int, int); int fchownat(int, uintptr_t, int, int, int); int fdatasync(int); -int fsync(int); int getpgid(int); int getpgrp(); int getpid(); @@ -199,6 +199,14 @@ func callfcntl(fd uintptr, cmd int, arg uintptr) (r1 uintptr, e1 Errno) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func callfsync_range(fd int, how int, start int64, length int64) (r1 uintptr, e1 Errno) { + r1 = uintptr(C.fsync_range(C.int(fd), C.int(how), C.longlong(start), C.longlong(length))) + e1 = syscall.GetErrno() + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func callacct(_p0 uintptr) (r1 uintptr, e1 Errno) { r1 = uintptr(C.acct(C.uintptr_t(_p0))) e1 = syscall.GetErrno() @@ -295,14 +303,6 @@ func callfdatasync(fd int) (r1 uintptr, e1 Errno) { // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT -func callfsync(fd int) (r1 uintptr, e1 Errno) { - r1 = uintptr(C.fsync(C.int(fd))) - e1 = syscall.GetErrno() - return -} - -// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT - func callgetpgid(pid int) (r1 uintptr, e1 Errno) { r1 = uintptr(C.getpgid(C.int(pid))) e1 = syscall.GetErrno() 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 aa7ce85d15..31847d2305 100644 --- 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 @@ -444,4 +444,5 @@ const ( SYS_LANDLOCK_ADD_RULE = 445 SYS_LANDLOCK_RESTRICT_SELF = 446 SYS_MEMFD_SECRET = 447 + SYS_PROCESS_MRELEASE = 448 ) 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 b830326386..3503cbbde3 100644 --- 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 @@ -366,4 +366,5 @@ const ( SYS_LANDLOCK_ADD_RULE = 445 SYS_LANDLOCK_RESTRICT_SELF = 446 SYS_MEMFD_SECRET = 447 + SYS_PROCESS_MRELEASE = 448 ) 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 d75f65a0aa..5ecd24bf68 100644 --- 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 @@ -7,6 +7,7 @@ package unix const ( + SYS_SYSCALL_MASK = 0 SYS_RESTART_SYSCALL = 0 SYS_EXIT = 1 SYS_FORK = 2 @@ -407,4 +408,5 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 444 SYS_LANDLOCK_ADD_RULE = 445 SYS_LANDLOCK_RESTRICT_SELF = 446 + SYS_PROCESS_MRELEASE = 448 ) 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 8b02f09e9b..7e5c94cc7f 100644 --- 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 @@ -311,4 +311,5 @@ const ( SYS_LANDLOCK_ADD_RULE = 445 SYS_LANDLOCK_RESTRICT_SELF = 446 SYS_MEMFD_SECRET = 447 + SYS_PROCESS_MRELEASE = 448 ) 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 026695abb1..e1e2a2bf59 100644 --- 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 @@ -428,4 +428,5 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 4444 SYS_LANDLOCK_ADD_RULE = 4445 SYS_LANDLOCK_RESTRICT_SELF = 4446 + SYS_PROCESS_MRELEASE = 4448 ) 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 7320ba9583..7651915a3a 100644 --- 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 @@ -358,4 +358,5 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 5444 SYS_LANDLOCK_ADD_RULE = 5445 SYS_LANDLOCK_RESTRICT_SELF = 5446 + SYS_PROCESS_MRELEASE = 5448 ) 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 45082dd67f..a26a2c050b 100644 --- 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 @@ -358,4 +358,5 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 5444 SYS_LANDLOCK_ADD_RULE = 5445 SYS_LANDLOCK_RESTRICT_SELF = 5446 + SYS_PROCESS_MRELEASE = 5448 ) 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 570a857a56..fda9a6a991 100644 --- 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 @@ -428,4 +428,5 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 4444 SYS_LANDLOCK_ADD_RULE = 4445 SYS_LANDLOCK_RESTRICT_SELF = 4446 + SYS_PROCESS_MRELEASE = 4448 ) diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go index 638498d62e..e8496150d4 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/zsysnum_linux_ppc.go @@ -435,4 +435,5 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 444 SYS_LANDLOCK_ADD_RULE = 445 SYS_LANDLOCK_RESTRICT_SELF = 446 + SYS_PROCESS_MRELEASE = 448 ) 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 702beebfef..5ee0678a36 100644 --- 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 @@ -407,4 +407,5 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 444 SYS_LANDLOCK_ADD_RULE = 445 SYS_LANDLOCK_RESTRICT_SELF = 446 + SYS_PROCESS_MRELEASE = 448 ) 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 bfc87ea444..29c0f9a39e 100644 --- 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 @@ -407,4 +407,5 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 444 SYS_LANDLOCK_ADD_RULE = 445 SYS_LANDLOCK_RESTRICT_SELF = 446 + SYS_PROCESS_MRELEASE = 448 ) 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 a390e147d3..5c9a9a3b61 100644 --- 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 @@ -309,4 +309,5 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 444 SYS_LANDLOCK_ADD_RULE = 445 SYS_LANDLOCK_RESTRICT_SELF = 446 + SYS_PROCESS_MRELEASE = 448 ) 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 3e791e6cd2..913f50f98b 100644 --- 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 @@ -372,4 +372,5 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 444 SYS_LANDLOCK_ADD_RULE = 445 SYS_LANDLOCK_RESTRICT_SELF = 446 + SYS_PROCESS_MRELEASE = 448 ) 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 78802a5cf7..0de03a7227 100644 --- 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 @@ -386,4 +386,5 @@ const ( SYS_LANDLOCK_CREATE_RULESET = 444 SYS_LANDLOCK_ADD_RULE = 445 SYS_LANDLOCK_RESTRICT_SELF = 446 + SYS_PROCESS_MRELEASE = 448 ) 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 7efe5ccba3..885842c0eb 100644 --- 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 @@ -641,13 +641,13 @@ type Eproc struct { Tdev int32 Tpgid int32 Tsess uintptr - Wmesg [8]int8 + Wmesg [8]byte Xsize int32 Xrssize int16 Xccount int16 Xswrss int16 Flag int32 - Login [12]int8 + Login [12]byte Spare [4]int32 _ [4]byte } @@ -688,7 +688,7 @@ type ExternProc struct { P_priority uint8 P_usrpri uint8 P_nice int8 - P_comm [17]int8 + P_comm [17]byte P_pgrp uintptr P_addr uintptr P_xstat uint16 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 b23a2efe81..b23c02337d 100644 --- 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 @@ -641,13 +641,13 @@ type Eproc struct { Tdev int32 Tpgid int32 Tsess uintptr - Wmesg [8]int8 + Wmesg [8]byte Xsize int32 Xrssize int16 Xccount int16 Xswrss int16 Flag int32 - Login [12]int8 + Login [12]byte Spare [4]int32 _ [4]byte } @@ -688,7 +688,7 @@ type ExternProc struct { P_priority uint8 P_usrpri uint8 P_nice int8 - P_comm [17]int8 + P_comm [17]byte P_pgrp uintptr P_addr uintptr P_xstat uint16 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 249ecfcd4c..620a6702fe 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go @@ -3264,7 +3264,8 @@ const ( LWTUNNEL_ENCAP_BPF = 0x6 LWTUNNEL_ENCAP_SEG6_LOCAL = 0x7 LWTUNNEL_ENCAP_RPL = 0x8 - LWTUNNEL_ENCAP_MAX = 0x8 + LWTUNNEL_ENCAP_IOAM6 = 0x9 + LWTUNNEL_ENCAP_MAX = 0x9 MPLS_IPTUNNEL_UNSPEC = 0x0 MPLS_IPTUNNEL_DST = 0x1 @@ -3617,7 +3618,9 @@ const ( 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_COALESCE_USE_CQE_MODE_TX = 0x18 + ETHTOOL_A_COALESCE_USE_CQE_MODE_RX = 0x19 + ETHTOOL_A_COALESCE_MAX = 0x19 ETHTOOL_A_PAUSE_UNSPEC = 0x0 ETHTOOL_A_PAUSE_HEADER = 0x1 ETHTOOL_A_PAUSE_AUTONEG = 0x2 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 2a8b1e6f73..baf5fe6504 100644 --- 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 @@ -564,12 +564,11 @@ type Uvmexp struct { Kmapent int32 } -const SizeofClockinfo = 0x14 +const SizeofClockinfo = 0x10 type Clockinfo struct { - Hz int32 - Tick int32 - Tickadj int32 - Stathz int32 - Profhz int32 + Hz int32 + Tick int32 + Stathz int32 + Profhz int32 } 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 b1759cf705..e21ae8ecfa 100644 --- 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 @@ -564,12 +564,11 @@ type Uvmexp struct { Kmapent int32 } -const SizeofClockinfo = 0x14 +const SizeofClockinfo = 0x10 type Clockinfo struct { - Hz int32 - Tick int32 - Tickadj int32 - Stathz int32 - Profhz int32 + Hz int32 + Tick int32 + Stathz int32 + Profhz int32 } 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 e807de2065..f190651cd9 100644 --- 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 @@ -565,12 +565,11 @@ type Uvmexp struct { Kmapent int32 } -const SizeofClockinfo = 0x14 +const SizeofClockinfo = 0x10 type Clockinfo struct { - Hz int32 - Tick int32 - Tickadj int32 - Stathz int32 - Profhz int32 + Hz int32 + Tick int32 + Stathz int32 + Profhz int32 } 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 ff3aecaee4..84747c582c 100644 --- 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 @@ -558,12 +558,11 @@ type Uvmexp struct { Kmapent int32 } -const SizeofClockinfo = 0x14 +const SizeofClockinfo = 0x10 type Clockinfo struct { - Hz int32 - Tick int32 - Tickadj int32 - Stathz int32 - Profhz int32 + Hz int32 + Tick int32 + Stathz int32 + Profhz int32 } 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 9ecda69174..ac5c8b6370 100644 --- 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 @@ -558,12 +558,11 @@ type Uvmexp struct { Kmapent int32 } -const SizeofClockinfo = 0x14 +const SizeofClockinfo = 0x10 type Clockinfo struct { - Hz int32 - Tick int32 - Tickadj int32 - Stathz int32 - Profhz int32 + Hz int32 + Tick int32 + Stathz int32 + Profhz int32 } diff --git a/src/cmd/vendor/golang.org/x/sys/windows/aliases.go b/src/cmd/vendor/golang.org/x/sys/windows/aliases.go index af3af60db9..a20ebea633 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/aliases.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/aliases.go @@ -2,8 +2,8 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// +build windows -// +build go1.9 +//go:build windows && go1.9 +// +build windows,go1.9 package windows diff --git a/src/cmd/vendor/golang.org/x/sys/windows/eventlog.go b/src/cmd/vendor/golang.org/x/sys/windows/eventlog.go index 40af946e16..2cd60645ee 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/eventlog.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/eventlog.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows // +build windows package windows diff --git a/src/cmd/vendor/golang.org/x/sys/windows/mksyscall.go b/src/cmd/vendor/golang.org/x/sys/windows/mksyscall.go index 328e3b2ace..6102910989 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/mksyscall.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/mksyscall.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build generate // +build generate package windows diff --git a/src/cmd/vendor/golang.org/x/sys/windows/race.go b/src/cmd/vendor/golang.org/x/sys/windows/race.go index a74e3e24b5..9196b089ca 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/race.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/race.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows && race // +build windows,race package windows diff --git a/src/cmd/vendor/golang.org/x/sys/windows/race0.go b/src/cmd/vendor/golang.org/x/sys/windows/race0.go index e44a3cbf67..7bae4817a0 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/race0.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/race0.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows && !race // +build windows,!race package windows diff --git a/src/cmd/vendor/golang.org/x/sys/windows/service.go b/src/cmd/vendor/golang.org/x/sys/windows/service.go index b269850d06..f8deca8397 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/service.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/service.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows // +build windows package windows @@ -16,8 +17,6 @@ const ( SC_MANAGER_ALL_ACCESS = 0xf003f ) -//sys OpenSCManager(machineName *uint16, databaseName *uint16, access uint32) (handle Handle, err error) [failretval==0] = advapi32.OpenSCManagerW - const ( SERVICE_KERNEL_DRIVER = 1 SERVICE_FILE_SYSTEM_DRIVER = 2 @@ -132,6 +131,14 @@ const ( SC_EVENT_DATABASE_CHANGE = 0 SC_EVENT_PROPERTY_CHANGE = 1 SC_EVENT_STATUS_CHANGE = 2 + + SERVICE_START_REASON_DEMAND = 0x00000001 + SERVICE_START_REASON_AUTO = 0x00000002 + SERVICE_START_REASON_TRIGGER = 0x00000004 + SERVICE_START_REASON_RESTART_ON_FAILURE = 0x00000008 + SERVICE_START_REASON_DELAYEDAUTO = 0x00000010 + + SERVICE_DYNAMIC_INFORMATION_LEVEL_START_REASON = 1 ) type SERVICE_STATUS struct { @@ -216,6 +223,7 @@ type QUERY_SERVICE_LOCK_STATUS struct { LockDuration uint32 } +//sys OpenSCManager(machineName *uint16, databaseName *uint16, access uint32) (handle Handle, err error) [failretval==0] = advapi32.OpenSCManagerW //sys CloseServiceHandle(handle Handle) (err error) = advapi32.CloseServiceHandle //sys CreateService(mgr Handle, serviceName *uint16, displayName *uint16, access uint32, srvType uint32, startType uint32, errCtl uint32, pathName *uint16, loadOrderGroup *uint16, tagId *uint32, dependencies *uint16, serviceStartName *uint16, password *uint16) (handle Handle, err error) [failretval==0] = advapi32.CreateServiceW //sys OpenService(mgr Handle, serviceName *uint16, access uint32) (handle Handle, err error) [failretval==0] = advapi32.OpenServiceW @@ -235,3 +243,5 @@ type QUERY_SERVICE_LOCK_STATUS struct { //sys NotifyServiceStatusChange(service Handle, notifyMask uint32, notifier *SERVICE_NOTIFY) (ret error) = advapi32.NotifyServiceStatusChangeW //sys SubscribeServiceChangeNotifications(service Handle, eventType uint32, callback uintptr, callbackCtx uintptr, subscription *uintptr) (ret error) = sechost.SubscribeServiceChangeNotifications? //sys UnsubscribeServiceChangeNotifications(subscription uintptr) = sechost.UnsubscribeServiceChangeNotifications? +//sys RegisterServiceCtrlHandlerEx(serviceName *uint16, handlerProc uintptr, context uintptr) (handle Handle, err error) = advapi32.RegisterServiceCtrlHandlerExW +//sys QueryServiceDynamicInformation(service Handle, infoLevel uint32, dynamicInfo unsafe.Pointer) (err error) = advapi32.QueryServiceDynamicInformation? diff --git a/src/cmd/vendor/golang.org/x/sys/windows/str.go b/src/cmd/vendor/golang.org/x/sys/windows/str.go index 917cc2aae4..4fc01434e4 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/str.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/str.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows // +build windows package windows diff --git a/src/cmd/vendor/golang.org/x/sys/windows/syscall.go b/src/cmd/vendor/golang.org/x/sys/windows/syscall.go index 6122f557a0..72074d582f 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/syscall.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/syscall.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build windows // +build windows // Package windows contains an interface to the low-level operating system 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 d3b59ae69c..2ff6aa0470 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go @@ -401,6 +401,11 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys LoadResource(module Handle, resInfo Handle) (resData Handle, err error) = kernel32.LoadResource //sys LockResource(resData Handle) (addr uintptr, err error) = kernel32.LockResource +// Version APIs +//sys GetFileVersionInfoSize(filename string, zeroHandle *Handle) (bufSize uint32, err error) = version.GetFileVersionInfoSizeW +//sys GetFileVersionInfo(filename string, handle uint32, bufSize uint32, buffer unsafe.Pointer) (err error) = version.GetFileVersionInfoW +//sys VerQueryValue(block unsafe.Pointer, subBlock string, pointerToBufferPointer unsafe.Pointer, bufSize *uint32) (err error) = version.VerQueryValueW + // Process Status API (PSAPI) //sys EnumProcesses(processIds []uint32, bytesReturned *uint32) (err error) = psapi.EnumProcesses //sys EnumProcessModules(process Handle, module *Handle, cb uint32, cbNeeded *uint32) (err error) = psapi.EnumProcessModules @@ -418,11 +423,16 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys RtlInitString(destinationString *NTString, sourceString *byte) = ntdll.RtlInitString //sys NtCreateFile(handle *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, allocationSize *int64, attributes uint32, share uint32, disposition uint32, options uint32, eabuffer uintptr, ealength uint32) (ntstatus error) = ntdll.NtCreateFile //sys NtCreateNamedPipeFile(pipe *Handle, access uint32, oa *OBJECT_ATTRIBUTES, iosb *IO_STATUS_BLOCK, share uint32, disposition uint32, options uint32, typ uint32, readMode uint32, completionMode uint32, maxInstances uint32, inboundQuota uint32, outputQuota uint32, timeout *int64) (ntstatus error) = ntdll.NtCreateNamedPipeFile +//sys NtSetInformationFile(handle Handle, iosb *IO_STATUS_BLOCK, inBuffer *byte, inBufferLen uint32, class uint32) (ntstatus error) = ntdll.NtSetInformationFile //sys RtlDosPathNameToNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) = ntdll.RtlDosPathNameToNtPathName_U_WithStatus //sys RtlDosPathNameToRelativeNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) = ntdll.RtlDosPathNameToRelativeNtPathName_U_WithStatus //sys RtlDefaultNpAcl(acl **ACL) (ntstatus error) = ntdll.RtlDefaultNpAcl //sys NtQueryInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32, retLen *uint32) (ntstatus error) = ntdll.NtQueryInformationProcess //sys NtSetInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32) (ntstatus error) = ntdll.NtSetInformationProcess +//sys NtQuerySystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32, retLen *uint32) (ntstatus error) = ntdll.NtQuerySystemInformation +//sys NtSetSystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32) (ntstatus error) = ntdll.NtSetSystemInformation +//sys RtlAddFunctionTable(functionTable *RUNTIME_FUNCTION, entryCount uint32, baseAddress uintptr) (ret bool) = ntdll.RtlAddFunctionTable +//sys RtlDeleteFunctionTable(functionTable *RUNTIME_FUNCTION) (ret bool) = ntdll.RtlDeleteFunctionTable // syscall interface implementation for other packages @@ -883,9 +893,7 @@ func (sa *SockaddrInet4) sockaddr() (unsafe.Pointer, int32, error) { p := (*[2]byte)(unsafe.Pointer(&sa.raw.Port)) p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil } @@ -905,9 +913,7 @@ func (sa *SockaddrInet6) sockaddr() (unsafe.Pointer, int32, error) { p[0] = byte(sa.Port >> 8) p[1] = byte(sa.Port) sa.raw.Scope_id = sa.ZoneId - for i := 0; i < len(sa.Addr); i++ { - sa.raw.Addr[i] = sa.Addr[i] - } + sa.raw.Addr = sa.Addr return unsafe.Pointer(&sa.raw), int32(unsafe.Sizeof(sa.raw)), nil } @@ -980,9 +986,7 @@ func (rsa *RawSockaddrAny) Sockaddr() (Sockaddr, error) { sa := new(SockaddrInet4) p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil case AF_INET6: @@ -991,9 +995,7 @@ func (rsa *RawSockaddrAny) Sockaddr() (Sockaddr, error) { p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) sa.ZoneId = pp.Scope_id - for i := 0; i < len(sa.Addr); i++ { - sa.Addr[i] = pp.Addr[i] - } + sa.Addr = pp.Addr return sa, nil } return nil, syscall.EAFNOSUPPORT 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 88e0ce5d0d..286dd1eab9 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go @@ -66,9 +66,21 @@ var signals = [...]string{ } const ( - FILE_LIST_DIRECTORY = 0x00000001 - FILE_APPEND_DATA = 0x00000004 + FILE_READ_DATA = 0x00000001 + FILE_READ_ATTRIBUTES = 0x00000080 + FILE_READ_EA = 0x00000008 + FILE_WRITE_DATA = 0x00000002 FILE_WRITE_ATTRIBUTES = 0x00000100 + FILE_WRITE_EA = 0x00000010 + FILE_APPEND_DATA = 0x00000004 + FILE_EXECUTE = 0x00000020 + + FILE_GENERIC_READ = STANDARD_RIGHTS_READ | FILE_READ_DATA | FILE_READ_ATTRIBUTES | FILE_READ_EA | SYNCHRONIZE + FILE_GENERIC_WRITE = STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | FILE_WRITE_ATTRIBUTES | FILE_WRITE_EA | FILE_APPEND_DATA | SYNCHRONIZE + FILE_GENERIC_EXECUTE = STANDARD_RIGHTS_EXECUTE | FILE_READ_ATTRIBUTES | FILE_EXECUTE | SYNCHRONIZE + + FILE_LIST_DIRECTORY = 0x00000001 + FILE_TRAVERSE = 0x00000020 FILE_SHARE_READ = 0x00000001 FILE_SHARE_WRITE = 0x00000002 @@ -1789,7 +1801,53 @@ type reparseDataBuffer struct { } const ( - FSCTL_GET_REPARSE_POINT = 0x900A8 + FSCTL_CREATE_OR_GET_OBJECT_ID = 0x0900C0 + FSCTL_DELETE_OBJECT_ID = 0x0900A0 + FSCTL_DELETE_REPARSE_POINT = 0x0900AC + FSCTL_DUPLICATE_EXTENTS_TO_FILE = 0x098344 + FSCTL_DUPLICATE_EXTENTS_TO_FILE_EX = 0x0983E8 + FSCTL_FILESYSTEM_GET_STATISTICS = 0x090060 + FSCTL_FILE_LEVEL_TRIM = 0x098208 + FSCTL_FIND_FILES_BY_SID = 0x09008F + FSCTL_GET_COMPRESSION = 0x09003C + FSCTL_GET_INTEGRITY_INFORMATION = 0x09027C + FSCTL_GET_NTFS_VOLUME_DATA = 0x090064 + FSCTL_GET_REFS_VOLUME_DATA = 0x0902D8 + FSCTL_GET_OBJECT_ID = 0x09009C + FSCTL_GET_REPARSE_POINT = 0x0900A8 + FSCTL_GET_RETRIEVAL_POINTER_COUNT = 0x09042B + FSCTL_GET_RETRIEVAL_POINTERS = 0x090073 + FSCTL_GET_RETRIEVAL_POINTERS_AND_REFCOUNT = 0x0903D3 + FSCTL_IS_PATHNAME_VALID = 0x09002C + FSCTL_LMR_SET_LINK_TRACKING_INFORMATION = 0x1400EC + FSCTL_MARK_HANDLE = 0x0900FC + FSCTL_OFFLOAD_READ = 0x094264 + FSCTL_OFFLOAD_WRITE = 0x098268 + FSCTL_PIPE_PEEK = 0x11400C + FSCTL_PIPE_TRANSCEIVE = 0x11C017 + FSCTL_PIPE_WAIT = 0x110018 + FSCTL_QUERY_ALLOCATED_RANGES = 0x0940CF + FSCTL_QUERY_FAT_BPB = 0x090058 + FSCTL_QUERY_FILE_REGIONS = 0x090284 + FSCTL_QUERY_ON_DISK_VOLUME_INFO = 0x09013C + FSCTL_QUERY_SPARING_INFO = 0x090138 + FSCTL_READ_FILE_USN_DATA = 0x0900EB + FSCTL_RECALL_FILE = 0x090117 + FSCTL_REFS_STREAM_SNAPSHOT_MANAGEMENT = 0x090440 + FSCTL_SET_COMPRESSION = 0x09C040 + FSCTL_SET_DEFECT_MANAGEMENT = 0x098134 + FSCTL_SET_ENCRYPTION = 0x0900D7 + FSCTL_SET_INTEGRITY_INFORMATION = 0x09C280 + FSCTL_SET_INTEGRITY_INFORMATION_EX = 0x090380 + FSCTL_SET_OBJECT_ID = 0x090098 + FSCTL_SET_OBJECT_ID_EXTENDED = 0x0900BC + FSCTL_SET_REPARSE_POINT = 0x0900A4 + FSCTL_SET_SPARSE = 0x0900C4 + FSCTL_SET_ZERO_DATA = 0x0980C8 + FSCTL_SET_ZERO_ON_DEALLOCATION = 0x090194 + FSCTL_SIS_COPYFILE = 0x090100 + FSCTL_WRITE_USN_CLOSE_RECORD = 0x0900EF + MAXIMUM_REPARSE_DATA_BUFFER_SIZE = 16 * 1024 IO_REPARSE_TAG_MOUNT_POINT = 0xA0000003 IO_REPARSE_TAG_SYMLINK = 0xA000000C @@ -2308,6 +2366,12 @@ type LIST_ENTRY struct { Blink *LIST_ENTRY } +type RUNTIME_FUNCTION struct { + BeginAddress uint32 + EndAddress uint32 + UnwindData uint32 +} + type LDR_DATA_TABLE_ENTRY struct { reserved1 [2]uintptr InMemoryOrderLinks LIST_ENTRY @@ -2498,6 +2562,60 @@ const ( FILE_PIPE_SERVER_END = 0x00000001 ) +const ( + // FileInformationClass for NtSetInformationFile + FileBasicInformation = 4 + FileRenameInformation = 10 + FileDispositionInformation = 13 + FilePositionInformation = 14 + FileEndOfFileInformation = 20 + FileValidDataLengthInformation = 39 + FileShortNameInformation = 40 + FileIoPriorityHintInformation = 43 + FileReplaceCompletionInformation = 61 + FileDispositionInformationEx = 64 + FileCaseSensitiveInformation = 71 + FileLinkInformation = 72 + FileCaseSensitiveInformationForceAccessCheck = 75 + FileKnownFolderInformation = 76 + + // Flags for FILE_RENAME_INFORMATION + FILE_RENAME_REPLACE_IF_EXISTS = 0x00000001 + FILE_RENAME_POSIX_SEMANTICS = 0x00000002 + FILE_RENAME_SUPPRESS_PIN_STATE_INHERITANCE = 0x00000004 + FILE_RENAME_SUPPRESS_STORAGE_RESERVE_INHERITANCE = 0x00000008 + FILE_RENAME_NO_INCREASE_AVAILABLE_SPACE = 0x00000010 + FILE_RENAME_NO_DECREASE_AVAILABLE_SPACE = 0x00000020 + FILE_RENAME_PRESERVE_AVAILABLE_SPACE = 0x00000030 + FILE_RENAME_IGNORE_READONLY_ATTRIBUTE = 0x00000040 + FILE_RENAME_FORCE_RESIZE_TARGET_SR = 0x00000080 + FILE_RENAME_FORCE_RESIZE_SOURCE_SR = 0x00000100 + FILE_RENAME_FORCE_RESIZE_SR = 0x00000180 + + // Flags for FILE_DISPOSITION_INFORMATION_EX + FILE_DISPOSITION_DO_NOT_DELETE = 0x00000000 + FILE_DISPOSITION_DELETE = 0x00000001 + FILE_DISPOSITION_POSIX_SEMANTICS = 0x00000002 + FILE_DISPOSITION_FORCE_IMAGE_SECTION_CHECK = 0x00000004 + FILE_DISPOSITION_ON_CLOSE = 0x00000008 + FILE_DISPOSITION_IGNORE_READONLY_ATTRIBUTE = 0x00000010 + + // Flags for FILE_CASE_SENSITIVE_INFORMATION + FILE_CS_FLAG_CASE_SENSITIVE_DIR = 0x00000001 + + // Flags for FILE_LINK_INFORMATION + FILE_LINK_REPLACE_IF_EXISTS = 0x00000001 + FILE_LINK_POSIX_SEMANTICS = 0x00000002 + FILE_LINK_SUPPRESS_STORAGE_RESERVE_INHERITANCE = 0x00000008 + FILE_LINK_NO_INCREASE_AVAILABLE_SPACE = 0x00000010 + FILE_LINK_NO_DECREASE_AVAILABLE_SPACE = 0x00000020 + FILE_LINK_PRESERVE_AVAILABLE_SPACE = 0x00000030 + FILE_LINK_IGNORE_READONLY_ATTRIBUTE = 0x00000040 + FILE_LINK_FORCE_RESIZE_TARGET_SR = 0x00000080 + FILE_LINK_FORCE_RESIZE_SOURCE_SR = 0x00000100 + FILE_LINK_FORCE_RESIZE_SR = 0x00000180 +) + // ProcessInformationClasses for NtQueryInformationProcess and NtSetInformationProcess. const ( ProcessBasicInformation = iota @@ -2614,6 +2732,203 @@ type PROCESS_BASIC_INFORMATION struct { InheritedFromUniqueProcessId uintptr } +// SystemInformationClasses for NtQuerySystemInformation and NtSetSystemInformation +const ( + SystemBasicInformation = iota + SystemProcessorInformation + SystemPerformanceInformation + SystemTimeOfDayInformation + SystemPathInformation + SystemProcessInformation + SystemCallCountInformation + SystemDeviceInformation + SystemProcessorPerformanceInformation + SystemFlagsInformation + SystemCallTimeInformation + SystemModuleInformation + SystemLocksInformation + SystemStackTraceInformation + SystemPagedPoolInformation + SystemNonPagedPoolInformation + SystemHandleInformation + SystemObjectInformation + SystemPageFileInformation + SystemVdmInstemulInformation + SystemVdmBopInformation + SystemFileCacheInformation + SystemPoolTagInformation + SystemInterruptInformation + SystemDpcBehaviorInformation + SystemFullMemoryInformation + SystemLoadGdiDriverInformation + SystemUnloadGdiDriverInformation + SystemTimeAdjustmentInformation + SystemSummaryMemoryInformation + SystemMirrorMemoryInformation + SystemPerformanceTraceInformation + systemObsolete0 + SystemExceptionInformation + SystemCrashDumpStateInformation + SystemKernelDebuggerInformation + SystemContextSwitchInformation + SystemRegistryQuotaInformation + SystemExtendServiceTableInformation + SystemPrioritySeperation + SystemVerifierAddDriverInformation + SystemVerifierRemoveDriverInformation + SystemProcessorIdleInformation + SystemLegacyDriverInformation + SystemCurrentTimeZoneInformation + SystemLookasideInformation + SystemTimeSlipNotification + SystemSessionCreate + SystemSessionDetach + SystemSessionInformation + SystemRangeStartInformation + SystemVerifierInformation + SystemVerifierThunkExtend + SystemSessionProcessInformation + SystemLoadGdiDriverInSystemSpace + SystemNumaProcessorMap + SystemPrefetcherInformation + SystemExtendedProcessInformation + SystemRecommendedSharedDataAlignment + SystemComPlusPackage + SystemNumaAvailableMemory + SystemProcessorPowerInformation + SystemEmulationBasicInformation + SystemEmulationProcessorInformation + SystemExtendedHandleInformation + SystemLostDelayedWriteInformation + SystemBigPoolInformation + SystemSessionPoolTagInformation + SystemSessionMappedViewInformation + SystemHotpatchInformation + SystemObjectSecurityMode + SystemWatchdogTimerHandler + SystemWatchdogTimerInformation + SystemLogicalProcessorInformation + SystemWow64SharedInformationObsolete + SystemRegisterFirmwareTableInformationHandler + SystemFirmwareTableInformation + SystemModuleInformationEx + SystemVerifierTriageInformation + SystemSuperfetchInformation + SystemMemoryListInformation + SystemFileCacheInformationEx + SystemThreadPriorityClientIdInformation + SystemProcessorIdleCycleTimeInformation + SystemVerifierCancellationInformation + SystemProcessorPowerInformationEx + SystemRefTraceInformation + SystemSpecialPoolInformation + SystemProcessIdInformation + SystemErrorPortInformation + SystemBootEnvironmentInformation + SystemHypervisorInformation + SystemVerifierInformationEx + SystemTimeZoneInformation + SystemImageFileExecutionOptionsInformation + SystemCoverageInformation + SystemPrefetchPatchInformation + SystemVerifierFaultsInformation + SystemSystemPartitionInformation + SystemSystemDiskInformation + SystemProcessorPerformanceDistribution + SystemNumaProximityNodeInformation + SystemDynamicTimeZoneInformation + SystemCodeIntegrityInformation + SystemProcessorMicrocodeUpdateInformation + SystemProcessorBrandString + SystemVirtualAddressInformation + SystemLogicalProcessorAndGroupInformation + SystemProcessorCycleTimeInformation + SystemStoreInformation + SystemRegistryAppendString + SystemAitSamplingValue + SystemVhdBootInformation + SystemCpuQuotaInformation + SystemNativeBasicInformation + systemSpare1 + SystemLowPriorityIoInformation + SystemTpmBootEntropyInformation + SystemVerifierCountersInformation + SystemPagedPoolInformationEx + SystemSystemPtesInformationEx + SystemNodeDistanceInformation + SystemAcpiAuditInformation + SystemBasicPerformanceInformation + SystemQueryPerformanceCounterInformation + SystemSessionBigPoolInformation + SystemBootGraphicsInformation + SystemScrubPhysicalMemoryInformation + SystemBadPageInformation + SystemProcessorProfileControlArea + SystemCombinePhysicalMemoryInformation + SystemEntropyInterruptTimingCallback + SystemConsoleInformation + SystemPlatformBinaryInformation + SystemThrottleNotificationInformation + SystemHypervisorProcessorCountInformation + SystemDeviceDataInformation + SystemDeviceDataEnumerationInformation + SystemMemoryTopologyInformation + SystemMemoryChannelInformation + SystemBootLogoInformation + SystemProcessorPerformanceInformationEx + systemSpare0 + SystemSecureBootPolicyInformation + SystemPageFileInformationEx + SystemSecureBootInformation + SystemEntropyInterruptTimingRawInformation + SystemPortableWorkspaceEfiLauncherInformation + SystemFullProcessInformation + SystemKernelDebuggerInformationEx + SystemBootMetadataInformation + SystemSoftRebootInformation + SystemElamCertificateInformation + SystemOfflineDumpConfigInformation + SystemProcessorFeaturesInformation + SystemRegistryReconciliationInformation + SystemEdidInformation + SystemManufacturingInformation + SystemEnergyEstimationConfigInformation + SystemHypervisorDetailInformation + SystemProcessorCycleStatsInformation + SystemVmGenerationCountInformation + SystemTrustedPlatformModuleInformation + SystemKernelDebuggerFlags + SystemCodeIntegrityPolicyInformation + SystemIsolatedUserModeInformation + SystemHardwareSecurityTestInterfaceResultsInformation + SystemSingleModuleInformation + SystemAllowedCpuSetsInformation + SystemDmaProtectionInformation + SystemInterruptCpuSetsInformation + SystemSecureBootPolicyFullInformation + SystemCodeIntegrityPolicyFullInformation + SystemAffinitizedInterruptProcessorInformation + SystemRootSiloInformation +) + +type RTL_PROCESS_MODULE_INFORMATION struct { + Section Handle + MappedBase uintptr + ImageBase uintptr + ImageSize uint32 + Flags uint32 + LoadOrderIndex uint16 + InitOrderIndex uint16 + LoadCount uint16 + OffsetToFileName uint16 + FullPathName [256]byte +} + +type RTL_PROCESS_MODULES struct { + NumberOfModules uint32 + Modules [1]RTL_PROCESS_MODULE_INFORMATION +} + // Constants for LocalAlloc flags. const ( LMEM_FIXED = 0x0 @@ -2708,6 +3023,22 @@ var ( RT_MANIFEST ResourceID = 24 ) +type VS_FIXEDFILEINFO struct { + Signature uint32 + StrucVersion uint32 + FileVersionMS uint32 + FileVersionLS uint32 + ProductVersionMS uint32 + ProductVersionLS uint32 + FileFlagsMask uint32 + FileFlags uint32 + FileOS uint32 + FileType uint32 + FileSubtype uint32 + FileDateMS uint32 + FileDateLS uint32 +} + type COAUTHIDENTITY struct { User *uint16 UserLength 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 4ea788e4c4..91817d6dcb 100644 --- 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") + modversion = NewLazySystemDLL("version.dll") modwintrust = NewLazySystemDLL("wintrust.dll") modws2_32 = NewLazySystemDLL("ws2_32.dll") modwtsapi32 = NewLazySystemDLL("wtsapi32.dll") @@ -114,6 +115,7 @@ var ( procOpenThreadToken = modadvapi32.NewProc("OpenThreadToken") procQueryServiceConfig2W = modadvapi32.NewProc("QueryServiceConfig2W") procQueryServiceConfigW = modadvapi32.NewProc("QueryServiceConfigW") + procQueryServiceDynamicInformation = modadvapi32.NewProc("QueryServiceDynamicInformation") procQueryServiceLockStatusW = modadvapi32.NewProc("QueryServiceLockStatusW") procQueryServiceStatus = modadvapi32.NewProc("QueryServiceStatus") procQueryServiceStatusEx = modadvapi32.NewProc("QueryServiceStatusEx") @@ -124,6 +126,7 @@ var ( procRegQueryInfoKeyW = modadvapi32.NewProc("RegQueryInfoKeyW") procRegQueryValueExW = modadvapi32.NewProc("RegQueryValueExW") procRegisterEventSourceW = modadvapi32.NewProc("RegisterEventSourceW") + procRegisterServiceCtrlHandlerExW = modadvapi32.NewProc("RegisterServiceCtrlHandlerExW") procReportEventW = modadvapi32.NewProc("ReportEventW") procRevertToSelf = modadvapi32.NewProc("RevertToSelf") procSetEntriesInAclW = modadvapi32.NewProc("SetEntriesInAclW") @@ -365,8 +368,13 @@ var ( procNtCreateFile = modntdll.NewProc("NtCreateFile") procNtCreateNamedPipeFile = modntdll.NewProc("NtCreateNamedPipeFile") procNtQueryInformationProcess = modntdll.NewProc("NtQueryInformationProcess") + procNtQuerySystemInformation = modntdll.NewProc("NtQuerySystemInformation") + procNtSetInformationFile = modntdll.NewProc("NtSetInformationFile") procNtSetInformationProcess = modntdll.NewProc("NtSetInformationProcess") + procNtSetSystemInformation = modntdll.NewProc("NtSetSystemInformation") + procRtlAddFunctionTable = modntdll.NewProc("RtlAddFunctionTable") procRtlDefaultNpAcl = modntdll.NewProc("RtlDefaultNpAcl") + procRtlDeleteFunctionTable = modntdll.NewProc("RtlDeleteFunctionTable") procRtlDosPathNameToNtPathName_U_WithStatus = modntdll.NewProc("RtlDosPathNameToNtPathName_U_WithStatus") procRtlDosPathNameToRelativeNtPathName_U_WithStatus = modntdll.NewProc("RtlDosPathNameToRelativeNtPathName_U_WithStatus") procRtlGetCurrentPeb = modntdll.NewProc("RtlGetCurrentPeb") @@ -402,6 +410,9 @@ var ( procCreateEnvironmentBlock = moduserenv.NewProc("CreateEnvironmentBlock") procDestroyEnvironmentBlock = moduserenv.NewProc("DestroyEnvironmentBlock") procGetUserProfileDirectoryW = moduserenv.NewProc("GetUserProfileDirectoryW") + procGetFileVersionInfoSizeW = modversion.NewProc("GetFileVersionInfoSizeW") + procGetFileVersionInfoW = modversion.NewProc("GetFileVersionInfoW") + procVerQueryValueW = modversion.NewProc("VerQueryValueW") procWinVerifyTrustEx = modwintrust.NewProc("WinVerifyTrustEx") procFreeAddrInfoW = modws2_32.NewProc("FreeAddrInfoW") procGetAddrInfoW = modws2_32.NewProc("GetAddrInfoW") @@ -966,6 +977,18 @@ func QueryServiceConfig(service Handle, serviceConfig *QUERY_SERVICE_CONFIG, buf return } +func QueryServiceDynamicInformation(service Handle, infoLevel uint32, dynamicInfo unsafe.Pointer) (err error) { + err = procQueryServiceDynamicInformation.Find() + if err != nil { + return + } + r1, _, e1 := syscall.Syscall(procQueryServiceDynamicInformation.Addr(), 3, uintptr(service), uintptr(infoLevel), uintptr(dynamicInfo)) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + func QueryServiceLockStatus(mgr Handle, lockStatus *QUERY_SERVICE_LOCK_STATUS, bufSize uint32, bytesNeeded *uint32) (err error) { r1, _, e1 := syscall.Syscall6(procQueryServiceLockStatusW.Addr(), 4, uintptr(mgr), uintptr(unsafe.Pointer(lockStatus)), uintptr(bufSize), uintptr(unsafe.Pointer(bytesNeeded)), 0, 0) if r1 == 0 { @@ -1055,6 +1078,15 @@ func RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Hand return } +func RegisterServiceCtrlHandlerEx(serviceName *uint16, handlerProc uintptr, context uintptr) (handle Handle, err error) { + r0, _, e1 := syscall.Syscall(procRegisterServiceCtrlHandlerExW.Addr(), 3, uintptr(unsafe.Pointer(serviceName)), uintptr(handlerProc), uintptr(context)) + handle = Handle(r0) + if handle == 0 { + err = errnoErr(e1) + } + return +} + func ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) { r1, _, e1 := syscall.Syscall9(procReportEventW.Addr(), 9, uintptr(log), uintptr(etype), uintptr(category), uintptr(eventId), uintptr(usrSId), uintptr(numStrings), uintptr(dataSize), uintptr(unsafe.Pointer(strings)), uintptr(unsafe.Pointer(rawData))) if r1 == 0 { @@ -3160,6 +3192,22 @@ func NtQueryInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe return } +func NtQuerySystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32, retLen *uint32) (ntstatus error) { + r0, _, _ := syscall.Syscall6(procNtQuerySystemInformation.Addr(), 4, uintptr(sysInfoClass), uintptr(sysInfo), uintptr(sysInfoLen), uintptr(unsafe.Pointer(retLen)), 0, 0) + if r0 != 0 { + ntstatus = NTStatus(r0) + } + return +} + +func NtSetInformationFile(handle Handle, iosb *IO_STATUS_BLOCK, inBuffer *byte, inBufferLen uint32, class uint32) (ntstatus error) { + r0, _, _ := syscall.Syscall6(procNtSetInformationFile.Addr(), 5, uintptr(handle), uintptr(unsafe.Pointer(iosb)), uintptr(unsafe.Pointer(inBuffer)), uintptr(inBufferLen), uintptr(class), 0) + if r0 != 0 { + ntstatus = NTStatus(r0) + } + return +} + func NtSetInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.Pointer, procInfoLen uint32) (ntstatus error) { r0, _, _ := syscall.Syscall6(procNtSetInformationProcess.Addr(), 4, uintptr(proc), uintptr(procInfoClass), uintptr(procInfo), uintptr(procInfoLen), 0, 0) if r0 != 0 { @@ -3168,6 +3216,20 @@ func NtSetInformationProcess(proc Handle, procInfoClass int32, procInfo unsafe.P return } +func NtSetSystemInformation(sysInfoClass int32, sysInfo unsafe.Pointer, sysInfoLen uint32) (ntstatus error) { + r0, _, _ := syscall.Syscall(procNtSetSystemInformation.Addr(), 3, uintptr(sysInfoClass), uintptr(sysInfo), uintptr(sysInfoLen)) + if r0 != 0 { + ntstatus = NTStatus(r0) + } + return +} + +func RtlAddFunctionTable(functionTable *RUNTIME_FUNCTION, entryCount uint32, baseAddress uintptr) (ret bool) { + r0, _, _ := syscall.Syscall(procRtlAddFunctionTable.Addr(), 3, uintptr(unsafe.Pointer(functionTable)), uintptr(entryCount), uintptr(baseAddress)) + ret = r0 != 0 + return +} + func RtlDefaultNpAcl(acl **ACL) (ntstatus error) { r0, _, _ := syscall.Syscall(procRtlDefaultNpAcl.Addr(), 1, uintptr(unsafe.Pointer(acl)), 0, 0) if r0 != 0 { @@ -3176,6 +3238,12 @@ func RtlDefaultNpAcl(acl **ACL) (ntstatus error) { return } +func RtlDeleteFunctionTable(functionTable *RUNTIME_FUNCTION) (ret bool) { + r0, _, _ := syscall.Syscall(procRtlDeleteFunctionTable.Addr(), 1, uintptr(unsafe.Pointer(functionTable)), 0, 0) + ret = r0 != 0 + return +} + func RtlDosPathNameToNtPathName(dosName *uint16, ntName *NTUnicodeString, ntFileNamePart *uint16, relativeName *RTL_RELATIVE_NAME) (ntstatus error) { r0, _, _ := syscall.Syscall6(procRtlDosPathNameToNtPathName_U_WithStatus.Addr(), 4, uintptr(unsafe.Pointer(dosName)), uintptr(unsafe.Pointer(ntName)), uintptr(unsafe.Pointer(ntFileNamePart)), uintptr(unsafe.Pointer(relativeName)), 0, 0) if r0 != 0 { @@ -3449,6 +3517,58 @@ func GetUserProfileDirectory(t Token, dir *uint16, dirLen *uint32) (err error) { return } +func GetFileVersionInfoSize(filename string, zeroHandle *Handle) (bufSize uint32, err error) { + var _p0 *uint16 + _p0, err = syscall.UTF16PtrFromString(filename) + if err != nil { + return + } + return _GetFileVersionInfoSize(_p0, zeroHandle) +} + +func _GetFileVersionInfoSize(filename *uint16, zeroHandle *Handle) (bufSize uint32, err error) { + r0, _, e1 := syscall.Syscall(procGetFileVersionInfoSizeW.Addr(), 2, uintptr(unsafe.Pointer(filename)), uintptr(unsafe.Pointer(zeroHandle)), 0) + bufSize = uint32(r0) + if bufSize == 0 { + err = errnoErr(e1) + } + return +} + +func GetFileVersionInfo(filename string, handle uint32, bufSize uint32, buffer unsafe.Pointer) (err error) { + var _p0 *uint16 + _p0, err = syscall.UTF16PtrFromString(filename) + if err != nil { + return + } + return _GetFileVersionInfo(_p0, handle, bufSize, buffer) +} + +func _GetFileVersionInfo(filename *uint16, handle uint32, bufSize uint32, buffer unsafe.Pointer) (err error) { + r1, _, e1 := syscall.Syscall6(procGetFileVersionInfoW.Addr(), 4, uintptr(unsafe.Pointer(filename)), uintptr(handle), uintptr(bufSize), uintptr(buffer), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func VerQueryValue(block unsafe.Pointer, subBlock string, pointerToBufferPointer unsafe.Pointer, bufSize *uint32) (err error) { + var _p0 *uint16 + _p0, err = syscall.UTF16PtrFromString(subBlock) + if err != nil { + return + } + return _VerQueryValue(block, _p0, pointerToBufferPointer, bufSize) +} + +func _VerQueryValue(block unsafe.Pointer, subBlock *uint16, pointerToBufferPointer unsafe.Pointer, bufSize *uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procVerQueryValueW.Addr(), 4, uintptr(block), uintptr(unsafe.Pointer(subBlock)), uintptr(pointerToBufferPointer), uintptr(unsafe.Pointer(bufSize)), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + 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 { diff --git a/src/cmd/vendor/golang.org/x/term/codereview.cfg b/src/cmd/vendor/golang.org/x/term/codereview.cfg new file mode 100644 index 0000000000..3f8b14b64e --- /dev/null +++ b/src/cmd/vendor/golang.org/x/term/codereview.cfg @@ -0,0 +1 @@ +issuerepo: golang/go diff --git a/src/cmd/vendor/golang.org/x/term/term.go b/src/cmd/vendor/golang.org/x/term/term.go index 1f6a38fad2..d592708808 100644 --- a/src/cmd/vendor/golang.org/x/term/term.go +++ b/src/cmd/vendor/golang.org/x/term/term.go @@ -12,6 +12,8 @@ // panic(err) // } // defer term.Restore(int(os.Stdin.Fd()), oldState) +// +// Note that on non-Unix systems os.Stdin.Fd() may not be 0. package term // State contains the state of a terminal. diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt index ad08e583fb..3a9b4f8736 100644 --- a/src/cmd/vendor/modules.txt +++ b/src/cmd/vendor/modules.txt @@ -18,7 +18,7 @@ github.com/google/pprof/third_party/svgpan # github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d ## explicit; go 1.12 github.com/ianlancetaylor/demangle -# golang.org/x/arch v0.0.0-20210901143047-ebb09ed340f1 +# golang.org/x/arch v0.0.0-20210923205945-b76863e36670 ## explicit; go 1.17 golang.org/x/arch/arm/armasm golang.org/x/arch/arm64/arm64asm @@ -42,13 +42,13 @@ golang.org/x/mod/zip # golang.org/x/sync v0.0.0-20210220032951-036812b2e83c ## explicit golang.org/x/sync/semaphore -# golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac +# golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e ## explicit; go 1.17 golang.org/x/sys/internal/unsafeheader golang.org/x/sys/plan9 golang.org/x/sys/unix golang.org/x/sys/windows -# golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b +# golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 ## explicit; go 1.17 golang.org/x/term # golang.org/x/tools v0.1.8-0.20211025211149-f916b54a1784 diff --git a/src/go.mod b/src/go.mod index 7d982c75aa..fca8e2c8db 100644 --- a/src/go.mod +++ b/src/go.mod @@ -8,6 +8,6 @@ require ( ) require ( - golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac // indirect + golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e // indirect golang.org/x/text v0.3.7 // indirect ) diff --git a/src/go.sum b/src/go.sum index ff1279697d..8262c737b5 100644 --- a/src/go.sum +++ b/src/go.sum @@ -2,7 +2,7 @@ golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s3 golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/net v0.0.0-20211005215030-d2e5035098b3 h1:G64nFNerDErBd2KdvHvIn3Ee6ccUQBTfhDZEO0DccfU= golang.org/x/net v0.0.0-20211005215030-d2e5035098b3/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac h1:oN6lz7iLW/YC7un8pq+9bOLyXrprv2+DKfkJY+2LJJw= -golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e h1:i6Vklmyu+fZMFYpum+sR4ZWABGW7MyIxfJZXYvcnbns= +golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_x86.go b/src/vendor/golang.org/x/sys/cpu/cpu_x86.go index 5ea287b7ec..f5aacfc825 100644 --- a/src/vendor/golang.org/x/sys/cpu/cpu_x86.go +++ b/src/vendor/golang.org/x/sys/cpu/cpu_x86.go @@ -90,9 +90,10 @@ func archInit() { osSupportsAVX = isSet(1, eax) && isSet(2, eax) if runtime.GOOS == "darwin" { - // Check darwin commpage for AVX512 support. Necessary because: - // https://github.com/apple/darwin-xnu/blob/0a798f6738bc1db01281fc08ae024145e84df927/osfmk/i386/fpu.c#L175-L201 - osSupportsAVX512 = osSupportsAVX && darwinSupportsAVX512() + // Darwin doesn't save/restore AVX-512 mask registers correctly across signal handlers. + // Since users can't rely on mask register contents, let's not advertise AVX-512 support. + // See issue 49233. + osSupportsAVX512 = false } else { // Check if OPMASK and ZMM registers have OS support. osSupportsAVX512 = osSupportsAVX && isSet(5, eax) && isSet(6, eax) && isSet(7, eax) diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_x86.s b/src/vendor/golang.org/x/sys/cpu/cpu_x86.s index b748ba52f7..39acab2ff5 100644 --- a/src/vendor/golang.org/x/sys/cpu/cpu_x86.s +++ b/src/vendor/golang.org/x/sys/cpu/cpu_x86.s @@ -26,27 +26,3 @@ TEXT ·xgetbv(SB),NOSPLIT,$0-8 MOVL AX, eax+0(FP) MOVL DX, edx+4(FP) RET - -// func darwinSupportsAVX512() bool -TEXT ·darwinSupportsAVX512(SB), NOSPLIT, $0-1 - MOVB $0, ret+0(FP) // default to false -#ifdef GOOS_darwin // return if not darwin -#ifdef GOARCH_amd64 // return if not amd64 -// These values from: -// https://github.com/apple/darwin-xnu/blob/xnu-4570.1.46/osfmk/i386/cpu_capabilities.h -#define commpage64_base_address 0x00007fffffe00000 -#define commpage64_cpu_capabilities64 (commpage64_base_address+0x010) -#define commpage64_version (commpage64_base_address+0x01E) -#define hasAVX512F 0x0000004000000000 - MOVQ $commpage64_version, BX - CMPW (BX), $13 // cpu_capabilities64 undefined in versions < 13 - JL no_avx512 - MOVQ $commpage64_cpu_capabilities64, BX - MOVQ $hasAVX512F, CX - TESTQ (BX), CX - JZ no_avx512 - MOVB $1, ret+0(FP) -no_avx512: -#endif -#endif - RET diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt index 770a08e1fb..f550e36d17 100644 --- a/src/vendor/modules.txt +++ b/src/vendor/modules.txt @@ -19,7 +19,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-20211007075335-d3039528d8ac +# golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e ## explicit; go 1.17 golang.org/x/sys/cpu # golang.org/x/text v0.3.7 From 77c473f4197b5ad4d90689d665534e598f3c0750 Mon Sep 17 00:00:00 2001 From: Dmitri Shuralyov Date: Tue, 9 Nov 2021 13:31:45 -0500 Subject: [PATCH 057/752] all: update vendored golang.org/x/{net,text} for Go 1.18 release The Go 1.18 code freeze has recently started. This is a time to update all golang.org/x/... module versions that contribute packages to the std and cmd modules in the standard library to latest master versions. This CL updates only the net, text modules. The next CL will update further ones. For #36905. Change-Id: I9a5ac3cca22da961cfd09f3202e01e1187d42bdd Reviewed-on: https://go-review.googlesource.com/c/go/+/362735 Trust: Dmitri Shuralyov Run-TryBot: Dmitri Shuralyov TryBot-Result: Go Bot Reviewed-by: Heschi Kreinick --- src/go.mod | 4 +- src/go.sum | 8 +- src/net/http/h2_bundle.go | 366 ++++++++++++------ .../golang.org/x/net/http/httpproxy/proxy.go | 4 +- .../golang.org/x/net/http2/hpack/huffman.go | 38 +- src/vendor/golang.org/x/net/idna/go118.go | 14 + .../golang.org/x/net/idna/idna10.0.0.go | 6 +- src/vendor/golang.org/x/net/idna/idna9.0.0.go | 4 +- src/vendor/golang.org/x/net/idna/pre_go118.go | 12 + src/vendor/golang.org/x/net/idna/punycode.go | 36 +- .../golang.org/x/net/nettest/nettest.go | 14 +- .../golang.org/x/text/unicode/bidi/core.go | 6 +- src/vendor/modules.txt | 4 +- 13 files changed, 346 insertions(+), 170 deletions(-) create mode 100644 src/vendor/golang.org/x/net/idna/go118.go create mode 100644 src/vendor/golang.org/x/net/idna/pre_go118.go diff --git a/src/go.mod b/src/go.mod index fca8e2c8db..3e7b86ee25 100644 --- a/src/go.mod +++ b/src/go.mod @@ -4,10 +4,10 @@ go 1.18 require ( golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 - golang.org/x/net v0.0.0-20211005215030-d2e5035098b3 + golang.org/x/net v0.0.0-20211108170745-6635138e15ea ) require ( golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e // indirect - golang.org/x/text v0.3.7 // indirect + golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2 // indirect ) diff --git a/src/go.sum b/src/go.sum index 8262c737b5..f9e5e7d4b8 100644 --- a/src/go.sum +++ b/src/go.sum @@ -1,8 +1,8 @@ golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ= golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/net v0.0.0-20211005215030-d2e5035098b3 h1:G64nFNerDErBd2KdvHvIn3Ee6ccUQBTfhDZEO0DccfU= -golang.org/x/net v0.0.0-20211005215030-d2e5035098b3/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211108170745-6635138e15ea h1:FosBMXtOc8Tp9Hbo4ltl1WJSrTVewZU8MPnTPY2HdH8= +golang.org/x/net v0.0.0-20211108170745-6635138e15ea/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e h1:i6Vklmyu+fZMFYpum+sR4ZWABGW7MyIxfJZXYvcnbns= golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= +golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2 h1:GLw7MR8AfAG2GmGcmVgObFOHXYypgGjnGno25RDwn3Y= +golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2/go.mod h1:EFNZuWvGYxIRUEX+K8UmCFwYmZjqcrnq15ZuVldZkZ0= diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go index 29226d4065..23a4d15326 100644 --- a/src/net/http/h2_bundle.go +++ b/src/net/http/h2_bundle.go @@ -6836,6 +6836,11 @@ type http2Transport struct { // Defaults to 15s. PingTimeout time.Duration + // WriteByteTimeout is the timeout after which the connection will be + // closed no data can be written to it. The timeout begins when data is + // available to write, and is extended whenever any bytes are written. + WriteByteTimeout time.Duration + // CountError, if non-nil, is called on HTTP/2 transport errors. // It's intended to increment a metric for monitoring, such // as an expvar or Prometheus metric. @@ -7006,12 +7011,17 @@ type http2ClientConn struct { // clientStream is the state for a single HTTP/2 stream. One of these // is created for each Transport.RoundTrip call. type http2clientStream struct { - cc *http2ClientConn - req *Request + cc *http2ClientConn + + // Fields of Request that we may access even after the response body is closed. + ctx context.Context + reqCancel <-chan struct{} + trace *httptrace.ClientTrace // or nil ID uint32 bufPipe http2pipe // buffered pipe with the flow-controlled response payload requestedGzip bool + isHead bool abortOnce sync.Once abort chan struct{} // closed to signal stream should end immediately @@ -7028,7 +7038,10 @@ type http2clientStream struct { inflow http2flow // guarded by cc.mu bytesRemain int64 // -1 means unknown; owned by transportResponseBody.Read readErr error // sticky read error; owned by transportResponseBody.Read - stopReqBody error // if non-nil, stop writing req body; guarded by cc.mu + + reqBody io.ReadCloser + reqBodyContentLength int64 // -1 means unknown + reqBodyClosed bool // body has been closed; guarded by cc.mu // owned by writeRequest: sentEndStream bool // sent an END_STREAM flag to the peer @@ -7068,6 +7081,10 @@ func (cs *http2clientStream) abortStreamLocked(err error) { cs.abortErr = err close(cs.abort) }) + if cs.reqBody != nil && !cs.reqBodyClosed { + cs.reqBody.Close() + cs.reqBodyClosed = true + } // TODO(dneil): Clean up tests where cs.cc.cond is nil. if cs.cc.cond != nil { // Wake up writeRequestBody if it is waiting on flow control. @@ -7075,31 +7092,43 @@ func (cs *http2clientStream) abortStreamLocked(err error) { } } -func (cs *http2clientStream) abortRequestBodyWrite(err error) { - if err == nil { - panic("nil error") - } +func (cs *http2clientStream) abortRequestBodyWrite() { cc := cs.cc cc.mu.Lock() - if cs.stopReqBody == nil { - cs.stopReqBody = err + defer cc.mu.Unlock() + if cs.reqBody != nil && !cs.reqBodyClosed { + cs.reqBody.Close() + cs.reqBodyClosed = true cc.cond.Broadcast() } - cc.mu.Unlock() } type http2stickyErrWriter struct { - w io.Writer - err *error + conn net.Conn + timeout time.Duration + err *error } func (sew http2stickyErrWriter) Write(p []byte) (n int, err error) { if *sew.err != nil { return 0, *sew.err } - n, err = sew.w.Write(p) - *sew.err = err - return + for { + if sew.timeout != 0 { + sew.conn.SetWriteDeadline(time.Now().Add(sew.timeout)) + } + nn, err := sew.conn.Write(p[n:]) + n += nn + if n < len(p) && nn > 0 && errors.Is(err, os.ErrDeadlineExceeded) { + // Keep extending the deadline so long as we're making progress. + continue + } + if sew.timeout != 0 { + sew.conn.SetWriteDeadline(time.Time{}) + } + *sew.err = err + return n, err + } } // noCachedConnError is the concrete type of ErrNoCachedConn, which @@ -7355,7 +7384,11 @@ func (t *http2Transport) newClientConn(c net.Conn, singleUse bool) (*http2Client // TODO: adjust this writer size to account for frame size + // MTU + crypto/tls record padding. - cc.bw = bufio.NewWriter(http2stickyErrWriter{c, &cc.werr}) + cc.bw = bufio.NewWriter(http2stickyErrWriter{ + conn: c, + timeout: t.WriteByteTimeout, + err: &cc.werr, + }) cc.br = bufio.NewReader(c) cc.fr = http2NewFramer(cc.bw, cc.br) if t.CountError != nil { @@ -7466,6 +7499,61 @@ func (cc *http2ClientConn) ReserveNewRequest() bool { return true } +// ClientConnState describes the state of a ClientConn. +type http2ClientConnState struct { + // Closed is whether the connection is closed. + Closed bool + + // Closing is whether the connection is in the process of + // closing. It may be closing due to shutdown, being a + // single-use connection, being marked as DoNotReuse, or + // having received a GOAWAY frame. + Closing bool + + // StreamsActive is how many streams are active. + StreamsActive int + + // StreamsReserved is how many streams have been reserved via + // ClientConn.ReserveNewRequest. + StreamsReserved int + + // StreamsPending is how many requests have been sent in excess + // of the peer's advertised MaxConcurrentStreams setting and + // are waiting for other streams to complete. + StreamsPending int + + // MaxConcurrentStreams is how many concurrent streams the + // peer advertised as acceptable. Zero means no SETTINGS + // frame has been received yet. + MaxConcurrentStreams uint32 + + // LastIdle, if non-zero, is when the connection last + // transitioned to idle state. + LastIdle time.Time +} + +// State returns a snapshot of cc's state. +func (cc *http2ClientConn) State() http2ClientConnState { + cc.wmu.Lock() + maxConcurrent := cc.maxConcurrentStreams + if !cc.seenSettings { + maxConcurrent = 0 + } + cc.wmu.Unlock() + + cc.mu.Lock() + defer cc.mu.Unlock() + return http2ClientConnState{ + Closed: cc.closed, + Closing: cc.closing || cc.singleUse || cc.doNotReuse || cc.goAway != nil, + StreamsActive: len(cc.streams), + StreamsReserved: cc.streamsReserved, + StreamsPending: cc.pendingRequests, + LastIdle: cc.lastIdle, + MaxConcurrentStreams: maxConcurrent, + } +} + // clientConnIdleState describes the suitability of a client // connection to initiate a new RoundTrip request. type http2clientConnIdleState struct { @@ -7717,15 +7805,19 @@ func (cc *http2ClientConn) decrStreamReservationsLocked() { func (cc *http2ClientConn) RoundTrip(req *Request) (*Response, error) { ctx := req.Context() cs := &http2clientStream{ - cc: cc, - req: req, - trace: httptrace.ContextClientTrace(req.Context()), - peerClosed: make(chan struct{}), - abort: make(chan struct{}), - respHeaderRecv: make(chan struct{}), - donec: make(chan struct{}), + cc: cc, + ctx: ctx, + reqCancel: req.Cancel, + isHead: req.Method == "HEAD", + reqBody: req.Body, + reqBodyContentLength: http2actualContentLength(req), + trace: httptrace.ContextClientTrace(ctx), + peerClosed: make(chan struct{}), + abort: make(chan struct{}), + respHeaderRecv: make(chan struct{}), + donec: make(chan struct{}), } - go cs.doRequest() + go cs.doRequest(req) waitDone := func() error { select { @@ -7733,7 +7825,7 @@ func (cc *http2ClientConn) RoundTrip(req *Request) (*Response, error) { return nil case <-ctx.Done(): return ctx.Err() - case <-req.Cancel: + case <-cs.reqCancel: return http2errRequestCanceled } } @@ -7752,7 +7844,7 @@ func (cc *http2ClientConn) RoundTrip(req *Request) (*Response, error) { // doesn't, they'll RST_STREAM us soon enough. This is a // heuristic to avoid adding knobs to Transport. Hopefully // we can keep it. - cs.abortRequestBodyWrite(http2errStopReqBodyWrite) + cs.abortRequestBodyWrite() } res.Request = req res.TLS = cc.tlsState @@ -7769,8 +7861,11 @@ func (cc *http2ClientConn) RoundTrip(req *Request) (*Response, error) { waitDone() return nil, cs.abortErr case <-ctx.Done(): - return nil, ctx.Err() - case <-req.Cancel: + err := ctx.Err() + cs.abortStream(err) + return nil, err + case <-cs.reqCancel: + cs.abortStream(http2errRequestCanceled) return nil, http2errRequestCanceled } } @@ -7779,8 +7874,8 @@ func (cc *http2ClientConn) RoundTrip(req *Request) (*Response, error) { // doRequest runs for the duration of the request lifetime. // // It sends the request and performs post-request cleanup (closing Request.Body, etc.). -func (cs *http2clientStream) doRequest() { - err := cs.writeRequest() +func (cs *http2clientStream) doRequest(req *Request) { + err := cs.writeRequest(req) cs.cleanupWriteRequest(err) } @@ -7791,12 +7886,11 @@ func (cs *http2clientStream) doRequest() { // // It returns non-nil if the request ends otherwise. // If the returned error is StreamError, the error Code may be used in resetting the stream. -func (cs *http2clientStream) writeRequest() (err error) { +func (cs *http2clientStream) writeRequest(req *Request) (err error) { cc := cs.cc - req := cs.req - ctx := req.Context() + ctx := cs.ctx - if err := http2checkConnHeaders(cs.req); err != nil { + if err := http2checkConnHeaders(req); err != nil { return err } @@ -7808,7 +7902,7 @@ func (cs *http2clientStream) writeRequest() (err error) { } select { case cc.reqHeaderMu <- struct{}{}: - case <-req.Cancel: + case <-cs.reqCancel: return http2errRequestCanceled case <-ctx.Done(): return ctx.Err() @@ -7831,7 +7925,7 @@ func (cs *http2clientStream) writeRequest() (err error) { if !cc.t.disableCompression() && req.Header.Get("Accept-Encoding") == "" && req.Header.Get("Range") == "" && - req.Method != "HEAD" { + !cs.isHead { // Request gzip only, not deflate. Deflate is ambiguous and // not as universally supported anyway. // See: https://zlib.net/zlib_faq.html#faq39 @@ -7850,19 +7944,23 @@ func (cs *http2clientStream) writeRequest() (err error) { continueTimeout := cc.t.expectContinueTimeout() if continueTimeout != 0 && !httpguts.HeaderValuesContainsToken( - cs.req.Header["Expect"], + req.Header["Expect"], "100-continue") { continueTimeout = 0 cs.on100 = make(chan struct{}, 1) } - err = cs.encodeAndWriteHeaders() + // Past this point (where we send request headers), it is possible for + // RoundTrip to return successfully. Since the RoundTrip contract permits + // the caller to "mutate or reuse" the Request after closing the Response's Body, + // we must take care when referencing the Request from here on. + err = cs.encodeAndWriteHeaders(req) <-cc.reqHeaderMu if err != nil { return err } - hasBody := http2actualContentLength(cs.req) != 0 + hasBody := cs.reqBodyContentLength != 0 if !hasBody { cs.sentEndStream = true } else { @@ -7878,7 +7976,7 @@ func (cs *http2clientStream) writeRequest() (err error) { err = cs.abortErr case <-ctx.Done(): err = ctx.Err() - case <-req.Cancel: + case <-cs.reqCancel: err = http2errRequestCanceled } timer.Stop() @@ -7888,7 +7986,7 @@ func (cs *http2clientStream) writeRequest() (err error) { } } - if err = cs.writeRequestBody(req.Body); err != nil { + if err = cs.writeRequestBody(req); err != nil { if err != http2errStopReqBodyWrite { http2traceWroteRequest(cs.trace, err) return err @@ -7923,16 +8021,15 @@ func (cs *http2clientStream) writeRequest() (err error) { return cs.abortErr case <-ctx.Done(): return ctx.Err() - case <-req.Cancel: + case <-cs.reqCancel: return http2errRequestCanceled } } } -func (cs *http2clientStream) encodeAndWriteHeaders() error { +func (cs *http2clientStream) encodeAndWriteHeaders(req *Request) error { cc := cs.cc - req := cs.req - ctx := req.Context() + ctx := cs.ctx cc.wmu.Lock() defer cc.wmu.Unlock() @@ -7943,7 +8040,7 @@ func (cs *http2clientStream) encodeAndWriteHeaders() error { return cs.abortErr case <-ctx.Done(): return ctx.Err() - case <-req.Cancel: + case <-cs.reqCancel: return http2errRequestCanceled default: } @@ -7953,14 +8050,14 @@ func (cs *http2clientStream) encodeAndWriteHeaders() error { // we send: HEADERS{1}, CONTINUATION{0,} + DATA{0,} (DATA is // sent by writeRequestBody below, along with any Trailers, // again in form HEADERS{1}, CONTINUATION{0,}) - trailers, err := http2commaSeparatedTrailers(cs.req) + trailers, err := http2commaSeparatedTrailers(req) if err != nil { return err } hasTrailers := trailers != "" - contentLen := http2actualContentLength(cs.req) + contentLen := http2actualContentLength(req) hasBody := contentLen != 0 - hdrs, err := cc.encodeHeaders(cs.req, cs.requestedGzip, trailers, contentLen) + hdrs, err := cc.encodeHeaders(req, cs.requestedGzip, trailers, contentLen) if err != nil { return err } @@ -7979,7 +8076,6 @@ func (cs *http2clientStream) encodeAndWriteHeaders() error { // cleanupWriteRequest will send a reset to the peer. func (cs *http2clientStream) cleanupWriteRequest(err error) { cc := cs.cc - req := cs.req if cs.ID == 0 { // We were canceled before creating the stream, so return our reservation. @@ -7990,10 +8086,12 @@ func (cs *http2clientStream) cleanupWriteRequest(err error) { // Request.Body is closed by the Transport, // and in multiple cases: server replies <=299 and >299 // while still writing request body - if req.Body != nil { - if e := req.Body.Close(); err == nil { - err = e - } + cc.mu.Lock() + bodyClosed := cs.reqBodyClosed + cs.reqBodyClosed = true + cc.mu.Unlock() + if !bodyClosed && cs.reqBody != nil { + cs.reqBody.Close() } if err != nil && cs.sentEndStream { @@ -8027,7 +8125,6 @@ func (cs *http2clientStream) cleanupWriteRequest(err error) { if cs.ID != 0 { cc.forgetStreamID(cs.ID) } - close(cs.donec) cc.wmu.Lock() werr := cc.werr @@ -8035,6 +8132,8 @@ func (cs *http2clientStream) cleanupWriteRequest(err error) { if werr != nil { cc.Close() } + + close(cs.donec) } // awaitOpenSlotForStream waits until len(streams) < maxConcurrentStreams. @@ -8108,7 +8207,7 @@ func (cs *http2clientStream) frameScratchBufferLen(maxFrameSize int) int { if n > max { n = max } - if cl := http2actualContentLength(cs.req); cl != -1 && cl+1 < n { + if cl := cs.reqBodyContentLength; cl != -1 && cl+1 < n { // Add an extra byte past the declared content-length to // give the caller's Request.Body io.Reader a chance to // give us more bytes than they declared, so we can catch it @@ -8123,13 +8222,13 @@ func (cs *http2clientStream) frameScratchBufferLen(maxFrameSize int) int { var http2bufPool sync.Pool // of *[]byte -func (cs *http2clientStream) writeRequestBody(body io.Reader) (err error) { +func (cs *http2clientStream) writeRequestBody(req *Request) (err error) { cc := cs.cc + body := cs.reqBody sentEnd := false // whether we sent the final DATA frame w/ END_STREAM - req := cs.req hasTrailers := req.Trailer != nil - remainLen := http2actualContentLength(req) + remainLen := cs.reqBodyContentLength hasContentLen := remainLen != -1 cc.mu.Lock() @@ -8170,23 +8269,26 @@ func (cs *http2clientStream) writeRequestBody(body io.Reader) (err error) { return err } } - if err == io.EOF { - sawEOF = true - err = nil - } else if err != nil { - return err + if err != nil { + cc.mu.Lock() + bodyClosed := cs.reqBodyClosed + cc.mu.Unlock() + switch { + case bodyClosed: + return http2errStopReqBodyWrite + case err == io.EOF: + sawEOF = true + err = nil + default: + return err + } } remain := buf[:n] for len(remain) > 0 && err == nil { var allowed int32 allowed, err = cs.awaitFlowControl(len(remain)) - switch { - case err == http2errStopReqBodyWrite: - return err - case err == http2errStopReqBodyWriteAndCancel: - return err - case err != nil: + if err != nil { return err } cc.wmu.Lock() @@ -8217,16 +8319,26 @@ func (cs *http2clientStream) writeRequestBody(body io.Reader) (err error) { return nil } + // Since the RoundTrip contract permits the caller to "mutate or reuse" + // a request after the Response's Body is closed, verify that this hasn't + // happened before accessing the trailers. + cc.mu.Lock() + trailer := req.Trailer + err = cs.abortErr + cc.mu.Unlock() + if err != nil { + return err + } + cc.wmu.Lock() + defer cc.wmu.Unlock() var trls []byte - if hasTrailers { - trls, err = cc.encodeTrailers(req) + if len(trailer) > 0 { + trls, err = cc.encodeTrailers(trailer) if err != nil { - cc.wmu.Unlock() return err } } - defer cc.wmu.Unlock() // Two ways to send END_STREAM: either with trailers, or // with an empty DATA frame. @@ -8247,23 +8359,22 @@ func (cs *http2clientStream) writeRequestBody(body io.Reader) (err error) { // if the stream is dead. func (cs *http2clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) { cc := cs.cc - req := cs.req - ctx := req.Context() + ctx := cs.ctx cc.mu.Lock() defer cc.mu.Unlock() for { if cc.closed { return 0, http2errClientConnClosed } - if cs.stopReqBody != nil { - return 0, cs.stopReqBody + if cs.reqBodyClosed { + return 0, http2errStopReqBodyWrite } select { case <-cs.abort: return 0, cs.abortErr case <-ctx.Done(): return 0, ctx.Err() - case <-req.Cancel: + case <-cs.reqCancel: return 0, http2errRequestCanceled default: } @@ -8477,11 +8588,11 @@ func http2shouldSendReqContentLength(method string, contentLength int64) bool { } // requires cc.wmu be held. -func (cc *http2ClientConn) encodeTrailers(req *Request) ([]byte, error) { +func (cc *http2ClientConn) encodeTrailers(trailer Header) ([]byte, error) { cc.hbuf.Reset() hlSize := uint64(0) - for k, vv := range req.Trailer { + for k, vv := range trailer { for _, v := range vv { hf := hpack.HeaderField{Name: k, Value: v} hlSize += uint64(hf.Size()) @@ -8491,7 +8602,7 @@ func (cc *http2ClientConn) encodeTrailers(req *Request) ([]byte, error) { return nil, http2errRequestHeaderListSize } - for k, vv := range req.Trailer { + for k, vv := range trailer { lowKey, ascii := http2asciiToLower(k) if !ascii { // Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header @@ -8627,7 +8738,13 @@ func (rl *http2clientConnReadLoop) cleanup() { } cc.closed = true for _, cs := range cc.streams { - cs.abortStreamLocked(err) + select { + case <-cs.peerClosed: + // The server closed the stream before closing the conn, + // so no need to interrupt it. + default: + cs.abortStreamLocked(err) + } } cc.cond.Broadcast() cc.mu.Unlock() @@ -8869,28 +8986,35 @@ func (rl *http2clientConnReadLoop) handleResponse(cs *http2clientStream, f *http return nil, nil } - streamEnded := f.StreamEnded() - isHead := cs.req.Method == "HEAD" - if !streamEnded || isHead { - res.ContentLength = -1 - if clens := res.Header["Content-Length"]; len(clens) == 1 { - if cl, err := strconv.ParseUint(clens[0], 10, 63); err == nil { - res.ContentLength = int64(cl) - } else { - // TODO: care? unlike http/1, it won't mess up our framing, so it's - // more safe smuggling-wise to ignore. - } - } else if len(clens) > 1 { + res.ContentLength = -1 + if clens := res.Header["Content-Length"]; len(clens) == 1 { + if cl, err := strconv.ParseUint(clens[0], 10, 63); err == nil { + res.ContentLength = int64(cl) + } else { // TODO: care? unlike http/1, it won't mess up our framing, so it's // more safe smuggling-wise to ignore. } + } else if len(clens) > 1 { + // TODO: care? unlike http/1, it won't mess up our framing, so it's + // more safe smuggling-wise to ignore. + } else if f.StreamEnded() && !cs.isHead { + res.ContentLength = 0 } - if streamEnded || isHead { + if cs.isHead { res.Body = http2noBody return res, nil } + if f.StreamEnded() { + if res.ContentLength > 0 { + res.Body = http2missingBody{} + } else { + res.Body = http2noBody + } + return res, nil + } + cs.bufPipe.setBuffer(&http2dataBuffer{expected: res.ContentLength}) cs.bytesRemain = res.ContentLength res.Body = http2transportResponseBody{cs} @@ -8934,8 +9058,7 @@ func (rl *http2clientConnReadLoop) processTrailers(cs *http2clientStream, f *htt } // transportResponseBody is the concrete type of Transport.RoundTrip's -// Response.Body. It is an io.ReadCloser. On Read, it reads from cs.body. -// On Close it sends RST_STREAM if EOF wasn't already seen. +// Response.Body. It is an io.ReadCloser. type http2transportResponseBody struct { cs *http2clientStream } @@ -9018,6 +9141,8 @@ func (b http2transportResponseBody) Close() error { } cc.mu.Unlock() + // TODO(dneil): Acquiring this mutex can block indefinitely. + // Move flow control return to a goroutine? cc.wmu.Lock() // Return connection-level flow control. if unread > 0 { @@ -9032,9 +9157,9 @@ func (b http2transportResponseBody) Close() error { select { case <-cs.donec: - case <-cs.req.Context().Done(): - return cs.req.Context().Err() - case <-cs.req.Cancel: + case <-cs.ctx.Done(): + return cs.ctx.Err() + case <-cs.reqCancel: return http2errRequestCanceled } return nil @@ -9088,7 +9213,7 @@ func (rl *http2clientConnReadLoop) processData(f *http2DataFrame) error { return nil } if f.Length > 0 { - if cs.req.Method == "HEAD" && len(data) > 0 { + if cs.isHead && len(data) > 0 { cc.logf("protocol error: received DATA on a HEAD request") rl.endStreamError(cs, http2StreamError{ StreamID: f.StreamID, @@ -9157,6 +9282,12 @@ func (rl *http2clientConnReadLoop) endStream(cs *http2clientStream) { // server.go's (*stream).endStream method. if !cs.readClosed { cs.readClosed = true + // Close cs.bufPipe and cs.peerClosed with cc.mu held to avoid a + // race condition: The caller can read io.EOF from Response.Body + // and close the body before we close cs.peerClosed, causing + // cleanupWriteRequest to send a RST_STREAM. + rl.cc.mu.Lock() + defer rl.cc.mu.Unlock() cs.bufPipe.closeWithErrorAndCode(io.EOF, cs.copyTrailers) close(cs.peerClosed) } @@ -9344,19 +9475,24 @@ func (cc *http2ClientConn) Ping(ctx context.Context) error { } cc.mu.Unlock() } - cc.wmu.Lock() - if err := cc.fr.WritePing(false, p); err != nil { - cc.wmu.Unlock() - return err - } - if err := cc.bw.Flush(); err != nil { - cc.wmu.Unlock() - return err - } - cc.wmu.Unlock() + errc := make(chan error, 1) + go func() { + cc.wmu.Lock() + defer cc.wmu.Unlock() + if err := cc.fr.WritePing(false, p); err != nil { + errc <- err + return + } + if err := cc.bw.Flush(); err != nil { + errc <- err + return + } + }() select { case <-c: return nil + case err := <-errc: + return err case <-ctx.Done(): return ctx.Err() case <-cc.readerDone: @@ -9433,6 +9569,12 @@ func (t *http2Transport) logf(format string, args ...interface{}) { var http2noBody io.ReadCloser = ioutil.NopCloser(bytes.NewReader(nil)) +type http2missingBody struct{} + +func (http2missingBody) Close() error { return nil } + +func (http2missingBody) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF } + func http2strSliceContains(ss []string, s string) bool { for _, v := range ss { if v == s { diff --git a/src/vendor/golang.org/x/net/http/httpproxy/proxy.go b/src/vendor/golang.org/x/net/http/httpproxy/proxy.go index 1415b07791..d2c8c87eab 100644 --- a/src/vendor/golang.org/x/net/http/httpproxy/proxy.go +++ b/src/vendor/golang.org/x/net/http/httpproxy/proxy.go @@ -113,8 +113,8 @@ func getEnvAny(names ...string) string { // environment, or a proxy should not be used for the given request, as // defined by NO_PROXY. // -// As a special case, if req.URL.Host is "localhost" (with or without a -// port number), then a nil URL and nil error will be returned. +// As a special case, if req.URL.Host is "localhost" or a loopback address +// (with or without a port number), then a nil URL and nil error will be returned. func (cfg *Config) ProxyFunc() func(reqURL *url.URL) (*url.URL, error) { // Preprocess the Config settings for more efficient evaluation. cfg1 := &config{ diff --git a/src/vendor/golang.org/x/net/http2/hpack/huffman.go b/src/vendor/golang.org/x/net/http2/hpack/huffman.go index a1ab2f0567..fe0b84ccd4 100644 --- a/src/vendor/golang.org/x/net/http2/hpack/huffman.go +++ b/src/vendor/golang.org/x/net/http2/hpack/huffman.go @@ -140,25 +140,29 @@ func buildRootHuffmanNode() { panic("unexpected size") } lazyRootHuffmanNode = newInternalNode() - for i, code := range huffmanCodes { - addDecoderNode(byte(i), code, huffmanCodeLen[i]) - } -} + // allocate a leaf node for each of the 256 symbols + leaves := new([256]node) -func addDecoderNode(sym byte, code uint32, codeLen uint8) { - cur := lazyRootHuffmanNode - for codeLen > 8 { - codeLen -= 8 - i := uint8(code >> codeLen) - if cur.children[i] == nil { - cur.children[i] = newInternalNode() + for sym, code := range huffmanCodes { + codeLen := huffmanCodeLen[sym] + + cur := lazyRootHuffmanNode + for codeLen > 8 { + codeLen -= 8 + i := uint8(code >> codeLen) + if cur.children[i] == nil { + cur.children[i] = newInternalNode() + } + cur = cur.children[i] + } + shift := 8 - codeLen + start, end := int(uint8(code< tmax { + } else if k >= bias+tmax { t = tmax } if digit < t { break } - w *= base - t - if w >= math.MaxInt32/base { + w, overflow = madd(0, w, base-t) + if overflow { return "", punyError(encoded) } } + if len(output) >= 1024 { + return "", punyError(encoded) + } x := int32(len(output) + 1) bias = adapt(i-oldI, x, oldI == 0) n += i / x i %= x - if n > utf8.MaxRune || len(output) >= 1024 { + if n < 0 || n > utf8.MaxRune { return "", punyError(encoded) } output = append(output, 0) @@ -115,6 +119,7 @@ func encode(prefix, s string) (string, error) { if b > 0 { output = append(output, '-') } + overflow := false for remaining != 0 { m := int32(0x7fffffff) for _, r := range s { @@ -122,8 +127,8 @@ func encode(prefix, s string) (string, error) { m = r } } - delta += (m - n) * (h + 1) - if delta < 0 { + delta, overflow = madd(delta, m-n, h+1) + if overflow { return "", punyError(s) } n = m @@ -141,9 +146,9 @@ func encode(prefix, s string) (string, error) { q := delta for k := base; ; k += base { t := k - bias - if t < tmin { + if k <= bias { t = tmin - } else if t > tmax { + } else if k >= bias+tmax { t = tmax } if q < t { @@ -164,6 +169,15 @@ func encode(prefix, s string) (string, error) { return string(output), nil } +// madd computes a + (b * c), detecting overflow. +func madd(a, b, c int32) (next int32, overflow bool) { + p := int64(b) * int64(c) + if p > math.MaxInt32-int64(a) { + return 0, true + } + return a + int32(p), false +} + func decodeDigit(x byte) (digit int32, ok bool) { switch { case '0' <= x && x <= '9': diff --git a/src/vendor/golang.org/x/net/nettest/nettest.go b/src/vendor/golang.org/x/net/nettest/nettest.go index 83ba858e24..ae5413b23d 100644 --- a/src/vendor/golang.org/x/net/nettest/nettest.go +++ b/src/vendor/golang.org/x/net/nettest/nettest.go @@ -95,13 +95,8 @@ func TestableNetwork(network string) bool { // This is an internal network name for testing on the // package net of the standard library. switch runtime.GOOS { - case "android", "fuchsia", "hurd", "js", "nacl", "plan9", "windows": + case "android", "fuchsia", "hurd", "ios", "js", "nacl", "plan9", "windows": return false - case "darwin", "ios": - // iOS doesn't support it. - if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" { - return false - } } case "ip", "ip4", "ip6": switch runtime.GOOS { @@ -114,15 +109,10 @@ func TestableNetwork(network string) bool { } case "unix", "unixgram": switch runtime.GOOS { - case "android", "fuchsia", "hurd", "js", "nacl", "plan9", "windows": + case "android", "fuchsia", "hurd", "ios", "js", "nacl", "plan9", "windows": return false case "aix": return unixStrmDgramEnabled() - case "darwin", "ios": - // iOS does not support unix, unixgram. - if runtime.GOARCH == "arm" || runtime.GOARCH == "arm64" { - return false - } } case "unixpacket": switch runtime.GOOS { diff --git a/src/vendor/golang.org/x/text/unicode/bidi/core.go b/src/vendor/golang.org/x/text/unicode/bidi/core.go index e4c0811016..fde188a33b 100644 --- a/src/vendor/golang.org/x/text/unicode/bidi/core.go +++ b/src/vendor/golang.org/x/text/unicode/bidi/core.go @@ -495,9 +495,9 @@ func (s *isolatingRunSequence) resolveWeakTypes() { if t == NSM { s.types[i] = precedingCharacterType } else { - if t.in(LRI, RLI, FSI, PDI) { - precedingCharacterType = ON - } + // if t.in(LRI, RLI, FSI, PDI) { + // precedingCharacterType = ON + // } precedingCharacterType = t } } diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt index f550e36d17..81aad95ad7 100644 --- a/src/vendor/modules.txt +++ b/src/vendor/modules.txt @@ -9,7 +9,7 @@ golang.org/x/crypto/curve25519/internal/field golang.org/x/crypto/hkdf golang.org/x/crypto/internal/subtle golang.org/x/crypto/poly1305 -# golang.org/x/net v0.0.0-20211005215030-d2e5035098b3 +# golang.org/x/net v0.0.0-20211108170745-6635138e15ea ## explicit; go 1.17 golang.org/x/net/dns/dnsmessage golang.org/x/net/http/httpguts @@ -22,7 +22,7 @@ golang.org/x/net/route # golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e ## explicit; go 1.17 golang.org/x/sys/cpu -# golang.org/x/text v0.3.7 +# golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2 ## explicit; go 1.17 golang.org/x/text/secure/bidirule golang.org/x/text/transform From 74b9939ec4a9f41bffb4dda47205d55c28e25728 Mon Sep 17 00:00:00 2001 From: Dmitri Shuralyov Date: Tue, 9 Nov 2021 13:49:45 -0500 Subject: [PATCH 058/752] all: update vendored golang.org/x/crypto for Go 1.18 release The Go 1.18 code freeze has recently started. This is a time to update all golang.org/x/... module versions that contribute packages to the std and cmd modules in the standard library to latest master versions. This CL updates only the crypto module, as well as the TestDependencies policy to accommodate the dependency order change done in CL 345649. The next CL will update further modules. For #36905. Change-Id: If93160d8d72ca86e9995aaf5bdfc3d2c20b4695d Reviewed-on: https://go-review.googlesource.com/c/go/+/362736 Trust: Dmitri Shuralyov Run-TryBot: Dmitri Shuralyov TryBot-Result: Go Bot Reviewed-by: Heschi Kreinick --- src/cmd/go.mod | 2 +- src/cmd/go.sum | 4 ++-- src/cmd/vendor/modules.txt | 2 +- src/go.mod | 2 +- src/go.sum | 4 ++-- src/go/build/deps_test.go | 2 +- .../x/crypto/chacha20poly1305/chacha20poly1305.go | 6 +++++- .../x/crypto/chacha20poly1305/chacha20poly1305_generic.go | 2 +- .../x/crypto/chacha20poly1305/xchacha20poly1305.go | 2 +- .../x/crypto/{ => internal}/poly1305/bits_compat.go | 0 .../x/crypto/{ => internal}/poly1305/bits_go1.13.go | 0 .../x/crypto/{ => internal}/poly1305/mac_noasm.go | 0 .../golang.org/x/crypto/{ => internal}/poly1305/poly1305.go | 2 +- .../x/crypto/{ => internal}/poly1305/sum_amd64.go | 0 .../golang.org/x/crypto/{ => internal}/poly1305/sum_amd64.s | 0 .../x/crypto/{ => internal}/poly1305/sum_generic.go | 0 .../x/crypto/{ => internal}/poly1305/sum_ppc64le.go | 0 .../x/crypto/{ => internal}/poly1305/sum_ppc64le.s | 0 .../x/crypto/{ => internal}/poly1305/sum_s390x.go | 0 .../golang.org/x/crypto/{ => internal}/poly1305/sum_s390x.s | 2 +- src/vendor/modules.txt | 4 ++-- 21 files changed, 19 insertions(+), 15 deletions(-) rename src/vendor/golang.org/x/crypto/{ => internal}/poly1305/bits_compat.go (100%) rename src/vendor/golang.org/x/crypto/{ => internal}/poly1305/bits_go1.13.go (100%) rename src/vendor/golang.org/x/crypto/{ => internal}/poly1305/mac_noasm.go (100%) rename src/vendor/golang.org/x/crypto/{ => internal}/poly1305/poly1305.go (98%) rename src/vendor/golang.org/x/crypto/{ => internal}/poly1305/sum_amd64.go (100%) rename src/vendor/golang.org/x/crypto/{ => internal}/poly1305/sum_amd64.s (100%) rename src/vendor/golang.org/x/crypto/{ => internal}/poly1305/sum_generic.go (100%) rename src/vendor/golang.org/x/crypto/{ => internal}/poly1305/sum_ppc64le.go (100%) rename src/vendor/golang.org/x/crypto/{ => internal}/poly1305/sum_ppc64le.s (100%) rename src/vendor/golang.org/x/crypto/{ => internal}/poly1305/sum_s390x.go (100%) rename src/vendor/golang.org/x/crypto/{ => internal}/poly1305/sum_s390x.s (99%) diff --git a/src/cmd/go.mod b/src/cmd/go.mod index ea4e8a3104..173679c7be 100644 --- a/src/cmd/go.mod +++ b/src/cmd/go.mod @@ -13,7 +13,7 @@ require ( require ( github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d // indirect - golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 // indirect + golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa // indirect golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e // indirect golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect ) diff --git a/src/cmd/go.sum b/src/cmd/go.sum index 01da0f686c..9188847173 100644 --- a/src/cmd/go.sum +++ b/src/cmd/go.sum @@ -7,8 +7,8 @@ github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d h1:uGg2frl github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d/go.mod h1:aYm2/VgdVmcIU8iMfdMvDMsRAQjcfZSKFby6HOFvi/w= golang.org/x/arch v0.0.0-20210923205945-b76863e36670 h1:18EFjUmQOcUvxNYSkA6jO9VAiXCnxFY6NyDX0bHDmkU= golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= -golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ= -golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa h1:idItI2DDfCokpg0N51B2VtiLdJ4vAuXC9fnCb2gACo4= +golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/mod v0.5.1-0.20210913215816-37dd6891021a h1:55PVa91KndtPGH2lus5l2gDZqoO/x+Oa5CV0lVf8Ij8= golang.org/x/mod v0.5.1-0.20210913215816-37dd6891021a/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ= diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt index 3a9b4f8736..2ac22b951b 100644 --- a/src/cmd/vendor/modules.txt +++ b/src/cmd/vendor/modules.txt @@ -24,7 +24,7 @@ golang.org/x/arch/arm/armasm golang.org/x/arch/arm64/arm64asm golang.org/x/arch/ppc64/ppc64asm golang.org/x/arch/x86/x86asm -# golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 +# golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa ## explicit; go 1.17 golang.org/x/crypto/ed25519 golang.org/x/crypto/ed25519/internal/edwards25519 diff --git a/src/go.mod b/src/go.mod index 3e7b86ee25..b8c4d5c16b 100644 --- a/src/go.mod +++ b/src/go.mod @@ -3,7 +3,7 @@ module std go 1.18 require ( - golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 + golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa golang.org/x/net v0.0.0-20211108170745-6635138e15ea ) diff --git a/src/go.sum b/src/go.sum index f9e5e7d4b8..ff1288f81d 100644 --- a/src/go.sum +++ b/src/go.sum @@ -1,5 +1,5 @@ -golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 h1:HWj/xjIHfjYU5nVXpTM0s39J9CbLn7Cc5a7IC5rwsMQ= -golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa h1:idItI2DDfCokpg0N51B2VtiLdJ4vAuXC9fnCb2gACo4= +golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/net v0.0.0-20211108170745-6635138e15ea h1:FosBMXtOc8Tp9Hbo4ltl1WJSrTVewZU8MPnTPY2HdH8= golang.org/x/net v0.0.0-20211108170745-6635138e15ea/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e h1:i6Vklmyu+fZMFYpum+sR4ZWABGW7MyIxfJZXYvcnbns= diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go index 1dd65d60d9..2f68cbcffc 100644 --- a/src/go/build/deps_test.go +++ b/src/go/build/deps_test.go @@ -436,7 +436,7 @@ var depsRules = ` CRYPTO-MATH, NET, container/list, encoding/hex, encoding/pem < golang.org/x/crypto/internal/subtle < golang.org/x/crypto/chacha20 - < golang.org/x/crypto/poly1305 + < golang.org/x/crypto/internal/poly1305 < golang.org/x/crypto/chacha20poly1305 < golang.org/x/crypto/hkdf < crypto/x509/internal/macos diff --git a/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305.go b/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305.go index 0d7bac3f7d..93da7322bc 100644 --- a/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305.go +++ b/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305.go @@ -26,6 +26,10 @@ const ( // NonceSizeX is the size of the nonce used with the XChaCha20-Poly1305 // variant of this AEAD, in bytes. NonceSizeX = 24 + + // Overhead is the size of the Poly1305 authentication tag, and the + // difference between a ciphertext length and its plaintext. + Overhead = 16 ) type chacha20poly1305 struct { @@ -47,7 +51,7 @@ func (c *chacha20poly1305) NonceSize() int { } func (c *chacha20poly1305) Overhead() int { - return 16 + return Overhead } func (c *chacha20poly1305) Seal(dst, nonce, plaintext, additionalData []byte) []byte { diff --git a/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_generic.go b/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_generic.go index fe191d395d..96b2fd898b 100644 --- a/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_generic.go +++ b/src/vendor/golang.org/x/crypto/chacha20poly1305/chacha20poly1305_generic.go @@ -8,8 +8,8 @@ import ( "encoding/binary" "golang.org/x/crypto/chacha20" + "golang.org/x/crypto/internal/poly1305" "golang.org/x/crypto/internal/subtle" - "golang.org/x/crypto/poly1305" ) func writeWithPadding(p *poly1305.MAC, b []byte) { diff --git a/src/vendor/golang.org/x/crypto/chacha20poly1305/xchacha20poly1305.go b/src/vendor/golang.org/x/crypto/chacha20poly1305/xchacha20poly1305.go index d9d46b9639..1cebfe946f 100644 --- a/src/vendor/golang.org/x/crypto/chacha20poly1305/xchacha20poly1305.go +++ b/src/vendor/golang.org/x/crypto/chacha20poly1305/xchacha20poly1305.go @@ -35,7 +35,7 @@ func (*xchacha20poly1305) NonceSize() int { } func (*xchacha20poly1305) Overhead() int { - return 16 + return Overhead } func (x *xchacha20poly1305) Seal(dst, nonce, plaintext, additionalData []byte) []byte { diff --git a/src/vendor/golang.org/x/crypto/poly1305/bits_compat.go b/src/vendor/golang.org/x/crypto/internal/poly1305/bits_compat.go similarity index 100% rename from src/vendor/golang.org/x/crypto/poly1305/bits_compat.go rename to src/vendor/golang.org/x/crypto/internal/poly1305/bits_compat.go diff --git a/src/vendor/golang.org/x/crypto/poly1305/bits_go1.13.go b/src/vendor/golang.org/x/crypto/internal/poly1305/bits_go1.13.go similarity index 100% rename from src/vendor/golang.org/x/crypto/poly1305/bits_go1.13.go rename to src/vendor/golang.org/x/crypto/internal/poly1305/bits_go1.13.go diff --git a/src/vendor/golang.org/x/crypto/poly1305/mac_noasm.go b/src/vendor/golang.org/x/crypto/internal/poly1305/mac_noasm.go similarity index 100% rename from src/vendor/golang.org/x/crypto/poly1305/mac_noasm.go rename to src/vendor/golang.org/x/crypto/internal/poly1305/mac_noasm.go diff --git a/src/vendor/golang.org/x/crypto/poly1305/poly1305.go b/src/vendor/golang.org/x/crypto/internal/poly1305/poly1305.go similarity index 98% rename from src/vendor/golang.org/x/crypto/poly1305/poly1305.go rename to src/vendor/golang.org/x/crypto/internal/poly1305/poly1305.go index 9d7a6af09f..4aaea810a2 100644 --- a/src/vendor/golang.org/x/crypto/poly1305/poly1305.go +++ b/src/vendor/golang.org/x/crypto/internal/poly1305/poly1305.go @@ -15,7 +15,7 @@ // used with a fixed key in order to generate one-time keys from an nonce. // However, in this package AES isn't used and the one-time key is specified // directly. -package poly1305 // import "golang.org/x/crypto/poly1305" +package poly1305 import "crypto/subtle" diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_amd64.go b/src/vendor/golang.org/x/crypto/internal/poly1305/sum_amd64.go similarity index 100% rename from src/vendor/golang.org/x/crypto/poly1305/sum_amd64.go rename to src/vendor/golang.org/x/crypto/internal/poly1305/sum_amd64.go diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_amd64.s b/src/vendor/golang.org/x/crypto/internal/poly1305/sum_amd64.s similarity index 100% rename from src/vendor/golang.org/x/crypto/poly1305/sum_amd64.s rename to src/vendor/golang.org/x/crypto/internal/poly1305/sum_amd64.s diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_generic.go b/src/vendor/golang.org/x/crypto/internal/poly1305/sum_generic.go similarity index 100% rename from src/vendor/golang.org/x/crypto/poly1305/sum_generic.go rename to src/vendor/golang.org/x/crypto/internal/poly1305/sum_generic.go diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.go b/src/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64le.go similarity index 100% rename from src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.go rename to src/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64le.go diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s b/src/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64le.s similarity index 100% rename from src/vendor/golang.org/x/crypto/poly1305/sum_ppc64le.s rename to src/vendor/golang.org/x/crypto/internal/poly1305/sum_ppc64le.s diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_s390x.go b/src/vendor/golang.org/x/crypto/internal/poly1305/sum_s390x.go similarity index 100% rename from src/vendor/golang.org/x/crypto/poly1305/sum_s390x.go rename to src/vendor/golang.org/x/crypto/internal/poly1305/sum_s390x.go diff --git a/src/vendor/golang.org/x/crypto/poly1305/sum_s390x.s b/src/vendor/golang.org/x/crypto/internal/poly1305/sum_s390x.s similarity index 99% rename from src/vendor/golang.org/x/crypto/poly1305/sum_s390x.s rename to src/vendor/golang.org/x/crypto/internal/poly1305/sum_s390x.s index 69c64f8421..aa9e0494c9 100644 --- a/src/vendor/golang.org/x/crypto/poly1305/sum_s390x.s +++ b/src/vendor/golang.org/x/crypto/internal/poly1305/sum_s390x.s @@ -18,7 +18,7 @@ // value. These limbs are, for the most part, zero extended and // placed into 64-bit vector register elements. Each vector // register is 128-bits wide and so holds 2 of these elements. -// Using 26-bit limbs allows us plenty of headroom to accomodate +// Using 26-bit limbs allows us plenty of headroom to accommodate // accumulations before and after multiplication without // overflowing either 32-bits (before multiplication) or 64-bits // (after multiplication). diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt index 81aad95ad7..004b599288 100644 --- a/src/vendor/modules.txt +++ b/src/vendor/modules.txt @@ -1,4 +1,4 @@ -# golang.org/x/crypto v0.0.0-20210817164053-32db794688a5 +# golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa ## explicit; go 1.17 golang.org/x/crypto/chacha20 golang.org/x/crypto/chacha20poly1305 @@ -7,8 +7,8 @@ golang.org/x/crypto/cryptobyte/asn1 golang.org/x/crypto/curve25519 golang.org/x/crypto/curve25519/internal/field golang.org/x/crypto/hkdf +golang.org/x/crypto/internal/poly1305 golang.org/x/crypto/internal/subtle -golang.org/x/crypto/poly1305 # golang.org/x/net v0.0.0-20211108170745-6635138e15ea ## explicit; go 1.17 golang.org/x/net/dns/dnsmessage From 5430203a1e7f3ba3af70b17bf2eeb61efda2ae58 Mon Sep 17 00:00:00 2001 From: Dmitri Shuralyov Date: Tue, 9 Nov 2021 13:54:57 -0500 Subject: [PATCH 059/752] all: update vendored golang.org/x/tools for Go 1.18 release The Go 1.18 code freeze has recently started. This is a time to update all golang.org/x/... module versions that contribute packages to the std and cmd modules in the standard library to latest master versions. This CL updates only the tools module, keeping mod unchanged because its lastest commit isn't ready to be vendored yet. For #36905. Updates #49350. Change-Id: Ib39713d28a55fc9ec79058aab9919eba912def5f Reviewed-on: https://go-review.googlesource.com/c/go/+/361094 Trust: Dmitri Shuralyov Run-TryBot: Dmitri Shuralyov Reviewed-by: Heschi Kreinick TryBot-Result: Go Bot --- src/cmd/go.mod | 4 +- src/cmd/go.sum | 8 +- .../go/analysis/internal/facts/imports.go | 33 ++- .../go/analysis/passes/copylock/copylock.go | 75 +++++- .../go/analysis/passes/ctrlflow/ctrlflow.go | 6 +- .../go/analysis/passes/nilfunc/nilfunc.go | 6 + .../tools/go/analysis/passes/printf/printf.go | 38 +++- .../tools/go/analysis/passes/printf/types.go | 215 +++++++++++------- .../x/tools/go/analysis/passes/shift/shift.go | 26 ++- .../analysis/passes/stringintconv/string.go | 136 ++++++++--- .../testinggoroutine/testinggoroutine.go | 23 +- .../x/tools/go/analysis/passes/tests/tests.go | 10 + .../passes/unusedresult/unusedresult.go | 6 + .../x/tools/go/types/typeutil/callee.go | 30 ++- src/cmd/vendor/modules.txt | 4 +- 15 files changed, 471 insertions(+), 149 deletions(-) diff --git a/src/cmd/go.mod b/src/cmd/go.mod index 173679c7be..facc54cee1 100644 --- a/src/cmd/go.mod +++ b/src/cmd/go.mod @@ -5,10 +5,10 @@ go 1.18 require ( github.com/google/pprof v0.0.0-20211104044539-f987b9c94b31 golang.org/x/arch v0.0.0-20210923205945-b76863e36670 - golang.org/x/mod v0.5.1-0.20210913215816-37dd6891021a + golang.org/x/mod v0.6.0-dev.0.20210913215816-37dd6891021a golang.org/x/sync v0.0.0-20210220032951-036812b2e83c golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 - golang.org/x/tools v0.1.8-0.20211025211149-f916b54a1784 + golang.org/x/tools v0.1.8-0.20211109164901-e9000123914f ) require ( diff --git a/src/cmd/go.sum b/src/cmd/go.sum index 9188847173..f248d84e24 100644 --- a/src/cmd/go.sum +++ b/src/cmd/go.sum @@ -9,8 +9,8 @@ golang.org/x/arch v0.0.0-20210923205945-b76863e36670 h1:18EFjUmQOcUvxNYSkA6jO9VA golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa h1:idItI2DDfCokpg0N51B2VtiLdJ4vAuXC9fnCb2gACo4= golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/mod v0.5.1-0.20210913215816-37dd6891021a h1:55PVa91KndtPGH2lus5l2gDZqoO/x+Oa5CV0lVf8Ij8= -golang.org/x/mod v0.5.1-0.20210913215816-37dd6891021a/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/mod v0.6.0-dev.0.20210913215816-37dd6891021a h1:gAiIC0JKDJwXAQFyqEYxROcAzeeh5ZTwWjKORCFuQxs= +golang.org/x/mod v0.6.0-dev.0.20210913215816-37dd6891021a/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -18,7 +18,7 @@ golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e h1:i6Vklmyu+fZMFYpum+sR4ZWAB golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/tools v0.1.8-0.20211025211149-f916b54a1784 h1:+xP+QoP2SEPgbn+07I/yJTzP+gavj0XKGS6+JU5tlck= -golang.org/x/tools v0.1.8-0.20211025211149-f916b54a1784/go.mod h1:LGqMHiF4EqQNHR1JncWGqT5BVaXmza+X+BDGol+dOxo= +golang.org/x/tools v0.1.8-0.20211109164901-e9000123914f h1:wwsTeyXackfHvwdCKtGcDlYwO78AwwW6OwUomSMB0aI= +golang.org/x/tools v0.1.8-0.20211109164901-e9000123914f/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/internal/facts/imports.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/internal/facts/imports.go index 34740f48e0..ade0cc6fab 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/internal/facts/imports.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/internal/facts/imports.go @@ -4,7 +4,11 @@ package facts -import "go/types" +import ( + "go/types" + + "golang.org/x/tools/internal/typeparams" +) // importMap computes the import map for a package by traversing the // entire exported API each of its imports. @@ -42,9 +46,20 @@ func importMap(imports []*types.Package) map[string]*types.Package { // nop case *types.Named: if addObj(T.Obj()) { + // TODO(taking): Investigate why the Underlying type is not added here. for i := 0; i < T.NumMethods(); i++ { addObj(T.Method(i)) } + if tparams := typeparams.ForNamed(T); tparams != nil { + for i := 0; i < tparams.Len(); i++ { + addType(tparams.At(i)) + } + } + if targs := typeparams.NamedTypeArgs(T); targs != nil { + for i := 0; i < targs.Len(); i++ { + addType(targs.At(i)) + } + } } case *types.Pointer: addType(T.Elem()) @@ -60,6 +75,11 @@ func importMap(imports []*types.Package) map[string]*types.Package { case *types.Signature: addType(T.Params()) addType(T.Results()) + if tparams := typeparams.ForSignature(T); tparams != nil { + for i := 0; i < tparams.Len(); i++ { + addType(tparams.At(i)) + } + } case *types.Struct: for i := 0; i < T.NumFields(); i++ { addObj(T.Field(i)) @@ -72,6 +92,17 @@ func importMap(imports []*types.Package) map[string]*types.Package { for i := 0; i < T.NumMethods(); i++ { addObj(T.Method(i)) } + for i := 0; i < T.NumEmbeddeds(); i++ { + addType(T.EmbeddedType(i)) // walk Embedded for implicits + } + case *typeparams.Union: + for i := 0; i < T.Len(); i++ { + addType(T.Term(i).Type()) + } + case *typeparams.TypeParam: + if addObj(T.Obj()) { + addType(T.Constraint()) + } } } diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/copylock/copylock.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/copylock/copylock.go index c4ebf78571..350dc4e0fe 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/copylock/copylock.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/copylock/copylock.go @@ -17,6 +17,7 @@ import ( "golang.org/x/tools/go/analysis/passes/inspect" "golang.org/x/tools/go/analysis/passes/internal/analysisutil" "golang.org/x/tools/go/ast/inspector" + "golang.org/x/tools/internal/typeparams" ) const Doc = `check for locks erroneously passed by value @@ -145,7 +146,7 @@ func checkCopyLocksCallExpr(pass *analysis.Pass, ce *ast.CallExpr) { func checkCopyLocksFunc(pass *analysis.Pass, name string, recv *ast.FieldList, typ *ast.FuncType) { if recv != nil && len(recv.List) > 0 { expr := recv.List[0].Type - if path := lockPath(pass.Pkg, pass.TypesInfo.Types[expr].Type); path != nil { + if path := lockPath(pass.Pkg, pass.TypesInfo.Types[expr].Type, nil); path != nil { pass.ReportRangef(expr, "%s passes lock by value: %v", name, path) } } @@ -153,7 +154,7 @@ func checkCopyLocksFunc(pass *analysis.Pass, name string, recv *ast.FieldList, t if typ.Params != nil { for _, field := range typ.Params.List { expr := field.Type - if path := lockPath(pass.Pkg, pass.TypesInfo.Types[expr].Type); path != nil { + if path := lockPath(pass.Pkg, pass.TypesInfo.Types[expr].Type, nil); path != nil { pass.ReportRangef(expr, "%s passes lock by value: %v", name, path) } } @@ -199,12 +200,12 @@ func checkCopyLocksRangeVar(pass *analysis.Pass, rtok token.Token, e ast.Expr) { if typ == nil { return } - if path := lockPath(pass.Pkg, typ); path != nil { + if path := lockPath(pass.Pkg, typ, nil); path != nil { pass.Reportf(e.Pos(), "range var %s copies lock: %v", analysisutil.Format(pass.Fset, e), path) } } -type typePath []types.Type +type typePath []string // String pretty-prints a typePath. func (path typePath) String() string { @@ -215,7 +216,7 @@ func (path typePath) String() string { fmt.Fprint(&buf, " contains ") } // The human-readable path is in reverse order, outermost to innermost. - fmt.Fprint(&buf, path[n-i-1].String()) + fmt.Fprint(&buf, path[n-i-1]) } return buf.String() } @@ -234,16 +235,57 @@ func lockPathRhs(pass *analysis.Pass, x ast.Expr) typePath { return nil } } - return lockPath(pass.Pkg, pass.TypesInfo.Types[x].Type) + return lockPath(pass.Pkg, pass.TypesInfo.Types[x].Type, nil) } // lockPath returns a typePath describing the location of a lock value // contained in typ. If there is no contained lock, it returns nil. -func lockPath(tpkg *types.Package, typ types.Type) typePath { +// +// The seenTParams map is used to short-circuit infinite recursion via type +// parameters. +func lockPath(tpkg *types.Package, typ types.Type, seenTParams map[*typeparams.TypeParam]bool) typePath { if typ == nil { return nil } + if tpar, ok := typ.(*typeparams.TypeParam); ok { + if seenTParams == nil { + // Lazily allocate seenTParams, since the common case will not involve + // any type parameters. + seenTParams = make(map[*typeparams.TypeParam]bool) + } + if seenTParams[tpar] { + return nil + } + seenTParams[tpar] = true + terms, err := typeparams.StructuralTerms(tpar) + if err != nil { + return nil // invalid type + } + for _, term := range terms { + subpath := lockPath(tpkg, term.Type(), seenTParams) + if len(subpath) > 0 { + if term.Tilde() { + // Prepend a tilde to our lock path entry to clarify the resulting + // diagnostic message. Consider the following example: + // + // func _[Mutex interface{ ~sync.Mutex; M() }](m Mutex) {} + // + // Here the naive error message will be something like "passes lock + // by value: Mutex contains sync.Mutex". This is misleading because + // the local type parameter doesn't actually contain sync.Mutex, + // which lacks the M method. + // + // With tilde, it is clearer that the containment is via an + // approximation element. + subpath[len(subpath)-1] = "~" + subpath[len(subpath)-1] + } + return append(subpath, typ.String()) + } + } + return nil + } + for { atyp, ok := typ.Underlying().(*types.Array) if !ok { @@ -252,6 +294,17 @@ func lockPath(tpkg *types.Package, typ types.Type) typePath { typ = atyp.Elem() } + ttyp, ok := typ.Underlying().(*types.Tuple) + if ok { + for i := 0; i < ttyp.Len(); i++ { + subpath := lockPath(tpkg, ttyp.At(i).Type(), seenTParams) + if subpath != nil { + return append(subpath, typ.String()) + } + } + return nil + } + // We're only interested in the case in which the underlying // type is a struct. (Interfaces and pointers are safe to copy.) styp, ok := typ.Underlying().(*types.Struct) @@ -263,7 +316,7 @@ func lockPath(tpkg *types.Package, typ types.Type) typePath { // is a sync.Locker, but a value is not. This differentiates // embedded interfaces from embedded values. if types.Implements(types.NewPointer(typ), lockerType) && !types.Implements(typ, lockerType) { - return []types.Type{typ} + return []string{typ.String()} } // In go1.10, sync.noCopy did not implement Locker. @@ -272,15 +325,15 @@ func lockPath(tpkg *types.Package, typ types.Type) typePath { if named, ok := typ.(*types.Named); ok && named.Obj().Name() == "noCopy" && named.Obj().Pkg().Path() == "sync" { - return []types.Type{typ} + return []string{typ.String()} } nfields := styp.NumFields() for i := 0; i < nfields; i++ { ftyp := styp.Field(i).Type() - subpath := lockPath(tpkg, ftyp) + subpath := lockPath(tpkg, ftyp, seenTParams) if subpath != nil { - return append(subpath, typ) + return append(subpath, typ.String()) } } diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ctrlflow/ctrlflow.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ctrlflow/ctrlflow.go index 51600ffc7e..73746d6f04 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ctrlflow/ctrlflow.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ctrlflow/ctrlflow.go @@ -187,7 +187,11 @@ func (c *CFGs) callMayReturn(call *ast.CallExpr) (r bool) { return false // panic never returns } - // Is this a static call? + // Is this a static call? Also includes static functions + // parameterized by a type. Such functions may or may not + // return depending on the parameter type, but in some + // cases the answer is definite. We let ctrlflow figure + // that out. fn := typeutil.StaticCallee(c.pass.TypesInfo, call) if fn == nil { return true // callee not statically known; be conservative diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/nilfunc/nilfunc.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/nilfunc/nilfunc.go index cd42c9897f..850f6f8fae 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/nilfunc/nilfunc.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/nilfunc/nilfunc.go @@ -14,6 +14,7 @@ import ( "golang.org/x/tools/go/analysis" "golang.org/x/tools/go/analysis/passes/inspect" "golang.org/x/tools/go/ast/inspector" + "golang.org/x/tools/internal/typeparams" ) const Doc = `check for useless comparisons between functions and nil @@ -59,6 +60,11 @@ func run(pass *analysis.Pass) (interface{}, error) { obj = pass.TypesInfo.Uses[v] case *ast.SelectorExpr: obj = pass.TypesInfo.Uses[v.Sel] + case *ast.IndexExpr, *typeparams.IndexListExpr: + // Check generic functions such as "f[T1,T2]". + if id, ok := typeparams.GetIndexExprData(v).X.(*ast.Ident); ok { + obj = pass.TypesInfo.Uses[id] + } default: return } diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go index 4169d30e4f..0206073578 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go @@ -452,8 +452,15 @@ func stringConstantArg(pass *analysis.Pass, call *ast.CallExpr, idx int) (string if idx >= len(call.Args) { return "", false } - arg := call.Args[idx] - lit := pass.TypesInfo.Types[arg].Value + return stringConstantExpr(pass, call.Args[idx]) +} + +// stringConstantExpr returns expression's string constant value. +// +// ("", false) is returned if expression isn't a string +// constant. +func stringConstantExpr(pass *analysis.Pass, expr ast.Expr) (string, bool) { + lit := pass.TypesInfo.Types[expr].Value if lit != nil && lit.Kind() == constant.String { return constant.StringVal(lit), true } @@ -872,8 +879,12 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, state *formatState) (o return } arg := call.Args[argNum] - if !matchArgType(pass, argInt, nil, arg) { - pass.ReportRangef(call, "%s format %s uses non-int %s as argument of *", state.name, state.format, analysisutil.Format(pass.Fset, arg)) + if reason, ok := matchArgType(pass, argInt, arg); !ok { + details := "" + if reason != "" { + details = " (" + reason + ")" + } + pass.ReportRangef(call, "%s format %s uses non-int %s%s as argument of *", state.name, state.format, analysisutil.Format(pass.Fset, arg), details) return false } } @@ -890,12 +901,16 @@ func okPrintfArg(pass *analysis.Pass, call *ast.CallExpr, state *formatState) (o pass.ReportRangef(call, "%s format %s arg %s is a func value, not called", state.name, state.format, analysisutil.Format(pass.Fset, arg)) return false } - if !matchArgType(pass, v.typ, nil, arg) { + if reason, ok := matchArgType(pass, v.typ, arg); !ok { typeString := "" if typ := pass.TypesInfo.Types[arg].Type; typ != nil { typeString = typ.String() } - pass.ReportRangef(call, "%s format %s has arg %s of wrong type %s", state.name, state.format, analysisutil.Format(pass.Fset, arg), typeString) + details := "" + if reason != "" { + details = " (" + reason + ")" + } + pass.ReportRangef(call, "%s format %s has arg %s of wrong type %s%s", state.name, state.format, analysisutil.Format(pass.Fset, arg), typeString, details) return false } if v.typ&argString != 0 && v.verb != 'T' && !bytes.Contains(state.flags, []byte{'#'}) { @@ -1053,10 +1068,10 @@ func checkPrint(pass *analysis.Pass, call *ast.CallExpr, fn *types.Func) { } arg := args[0] - if lit, ok := arg.(*ast.BasicLit); ok && lit.Kind == token.STRING { - // Ignore trailing % character in lit.Value. + if s, ok := stringConstantExpr(pass, arg); ok { + // Ignore trailing % character // The % in "abc 0.0%" couldn't be a formatting directive. - s := strings.TrimSuffix(lit.Value, `%"`) + s = strings.TrimSuffix(s, "%") if strings.Contains(s, "%") { m := printFormatRE.FindStringSubmatch(s) if m != nil { @@ -1067,9 +1082,8 @@ func checkPrint(pass *analysis.Pass, call *ast.CallExpr, fn *types.Func) { if strings.HasSuffix(fn.Name(), "ln") { // The last item, if a string, should not have a newline. arg = args[len(args)-1] - if lit, ok := arg.(*ast.BasicLit); ok && lit.Kind == token.STRING { - str, _ := strconv.Unquote(lit.Value) - if strings.HasSuffix(str, "\n") { + if s, ok := stringConstantExpr(pass, arg); ok { + if strings.HasSuffix(s, "\n") { pass.ReportRangef(call, "%s arg list ends with redundant newline", fn.FullName()) } } 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 6a5fae44f4..81bf36e1ee 100644 --- 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 @@ -5,45 +5,60 @@ package printf import ( + "fmt" "go/ast" "go/types" "golang.org/x/tools/go/analysis" - "golang.org/x/tools/go/analysis/passes/internal/analysisutil" + "golang.org/x/tools/internal/typeparams" ) var errorType = types.Universe.Lookup("error").Type().Underlying().(*types.Interface) -// matchArgType reports an error if printf verb t is not appropriate -// for operand arg. +// matchArgType reports an error if printf verb t is not appropriate for +// operand arg. // -// typ is used only for recursive calls; external callers must supply nil. -// -// (Recursion arises from the compound types {map,chan,slice} which -// may be printed with %d etc. if that is appropriate for their element -// types.) -func matchArgType(pass *analysis.Pass, t printfArgType, typ types.Type, arg ast.Expr) bool { - return matchArgTypeInternal(pass, t, typ, arg, make(map[types.Type]bool)) -} - -// matchArgTypeInternal is the internal version of matchArgType. It carries a map -// remembering what types are in progress so we don't recur when faced with recursive -// types or mutually recursive types. -func matchArgTypeInternal(pass *analysis.Pass, t printfArgType, typ types.Type, arg ast.Expr, inProgress map[types.Type]bool) bool { +// If arg is a type parameter, the verb t must be appropriate for every type in +// the type parameter type set. +func matchArgType(pass *analysis.Pass, t printfArgType, arg ast.Expr) (reason string, ok bool) { // %v, %T accept any argument type. if t == anyType { - return true - } - if typ == nil { - // external call - typ = pass.TypesInfo.Types[arg].Type - if typ == nil { - return true // probably a type check problem - } + return "", true } + typ := pass.TypesInfo.Types[arg].Type + if typ == nil { + return "", true // probably a type check problem + } + + m := &argMatcher{t: t, seen: make(map[types.Type]bool)} + ok = m.match(typ, true) + return m.reason, ok +} + +// argMatcher recursively matches types against the printfArgType t. +// +// To short-circuit recursion, it keeps track of types that have already been +// matched (or are in the process of being matched) via the seen map. Recursion +// arises from the compound types {map,chan,slice} which may be printed with %d +// etc. if that is appropriate for their element types, as well as from type +// parameters, which are expanded to the constituents of their type set. +// +// The reason field may be set to report the cause of the mismatch. +type argMatcher struct { + t printfArgType + seen map[types.Type]bool + reason string +} + +// match checks if typ matches m's printf arg type. If topLevel is true, typ is +// the actual type of the printf arg, for which special rules apply. As a +// special case, top level type parameters pass topLevel=true when checking for +// matches among the constituents of their type set, as type arguments will +// replace the type parameter at compile time. +func (m *argMatcher) match(typ types.Type, topLevel bool) bool { // %w accepts only errors. - if t == argError { + if m.t == argError { return types.ConvertibleTo(typ, errorType) } @@ -51,86 +66,153 @@ func matchArgTypeInternal(pass *analysis.Pass, t printfArgType, typ types.Type, if isFormatter(typ) { return true } + // If we can use a string, might arg (dynamically) implement the Stringer or Error interface? - if t&argString != 0 && isConvertibleToString(pass, typ) { + if m.t&argString != 0 && isConvertibleToString(typ) { + return true + } + + if typ, _ := typ.(*typeparams.TypeParam); typ != nil { + // Avoid infinite recursion through type parameters. + if m.seen[typ] { + return true + } + m.seen[typ] = true + terms, err := typeparams.StructuralTerms(typ) + if err != nil { + return true // invalid type (possibly an empty type set) + } + + if len(terms) == 0 { + // No restrictions on the underlying of typ. Type parameters implementing + // error, fmt.Formatter, or fmt.Stringer were handled above, and %v and + // %T was handled in matchType. We're about to check restrictions the + // underlying; if the underlying type is unrestricted there must be an + // element of the type set that violates one of the arg type checks + // below, so we can safely return false here. + + if m.t == anyType { // anyType must have already been handled. + panic("unexpected printfArgType") + } + return false + } + + // Only report a reason if typ is the argument type, otherwise it won't + // make sense. Note that it is not sufficient to check if topLevel == here, + // as type parameters can have a type set consisting of other type + // parameters. + reportReason := len(m.seen) == 1 + + for _, term := range terms { + if !m.match(term.Type(), topLevel) { + if reportReason { + if term.Tilde() { + m.reason = fmt.Sprintf("contains ~%s", term.Type()) + } else { + m.reason = fmt.Sprintf("contains %s", term.Type()) + } + } + return false + } + } return true } typ = typ.Underlying() - if inProgress[typ] { - // We're already looking at this type. The call that started it will take care of it. + if m.seen[typ] { + // We've already considered typ, or are in the process of considering it. + // In case we've already considered typ, it must have been valid (else we + // would have stopped matching). In case we're in the process of + // considering it, we must avoid infinite recursion. + // + // There are some pathological cases where returning true here is + // incorrect, for example `type R struct { F []R }`, but these are + // acceptable false negatives. return true } - inProgress[typ] = true + m.seen[typ] = true switch typ := typ.(type) { case *types.Signature: - return t == argPointer + return m.t == argPointer case *types.Map: - return t == argPointer || - // Recur: map[int]int matches %d. - (matchArgTypeInternal(pass, t, typ.Key(), arg, inProgress) && matchArgTypeInternal(pass, t, typ.Elem(), arg, inProgress)) + if m.t == argPointer { + return true + } + // Recur: map[int]int matches %d. + return m.match(typ.Key(), false) && m.match(typ.Elem(), false) case *types.Chan: - return t&argPointer != 0 + return m.t&argPointer != 0 case *types.Array: // Same as slice. - if types.Identical(typ.Elem().Underlying(), types.Typ[types.Byte]) && t&argString != 0 { + if types.Identical(typ.Elem().Underlying(), types.Typ[types.Byte]) && m.t&argString != 0 { return true // %s matches []byte } // Recur: []int matches %d. - return matchArgTypeInternal(pass, t, typ.Elem(), arg, inProgress) + return m.match(typ.Elem(), false) case *types.Slice: // Same as array. - if types.Identical(typ.Elem().Underlying(), types.Typ[types.Byte]) && t&argString != 0 { + if types.Identical(typ.Elem().Underlying(), types.Typ[types.Byte]) && m.t&argString != 0 { return true // %s matches []byte } - if t == argPointer { + if m.t == argPointer { return true // %p prints a slice's 0th element } // Recur: []int matches %d. But watch out for // type T []T // If the element is a pointer type (type T[]*T), it's handled fine by the Pointer case below. - return matchArgTypeInternal(pass, t, typ.Elem(), arg, inProgress) + return m.match(typ.Elem(), false) case *types.Pointer: // Ugly, but dealing with an edge case: a known pointer to an invalid type, // probably something from a failed import. - if typ.Elem().String() == "invalid type" { - if false { - pass.Reportf(arg.Pos(), "printf argument %v is pointer to invalid or unknown type", analysisutil.Format(pass.Fset, arg)) - } + if typ.Elem() == types.Typ[types.Invalid] { return true // special case } // If it's actually a pointer with %p, it prints as one. - if t == argPointer { + if m.t == argPointer { return true } under := typ.Elem().Underlying() switch under.(type) { + case *typeparams.TypeParam: + return true // We don't know whether the logic below applies. Give up. case *types.Struct: // see below case *types.Array: // see below case *types.Slice: // see below case *types.Map: // see below default: // Check whether the rest can print pointers. - return t&argPointer != 0 + return m.t&argPointer != 0 } - // If it's a top-level pointer to a struct, array, slice, or + // If it's a top-level pointer to a struct, array, slice, type param, or // map, that's equivalent in our analysis to whether we can // print the type being pointed to. Pointers in nested levels // are not supported to minimize fmt running into loops. - if len(inProgress) > 1 { + if !topLevel { return false } - return matchArgTypeInternal(pass, t, under, arg, inProgress) + return m.match(under, false) case *types.Struct: - return matchStructArgType(pass, t, typ, arg, inProgress) + // report whether all the elements of the struct match the expected type. For + // instance, with "%d" all the elements must be printable with the "%d" format. + for i := 0; i < typ.NumFields(); i++ { + typf := typ.Field(i) + if !m.match(typf.Type(), false) { + return false + } + if m.t&argString != 0 && !typf.Exported() && isConvertibleToString(typf.Type()) { + // Issue #17798: unexported Stringer or error cannot be properly formatted. + return false + } + } + return true case *types.Interface: // There's little we can do. @@ -142,7 +224,7 @@ func matchArgTypeInternal(pass *analysis.Pass, t printfArgType, typ types.Type, switch typ.Kind() { case types.UntypedBool, types.Bool: - return t&argBool != 0 + return m.t&argBool != 0 case types.UntypedInt, types.Int, @@ -156,35 +238,32 @@ func matchArgTypeInternal(pass *analysis.Pass, t printfArgType, typ types.Type, types.Uint32, types.Uint64, types.Uintptr: - return t&argInt != 0 + return m.t&argInt != 0 case types.UntypedFloat, types.Float32, types.Float64: - return t&argFloat != 0 + return m.t&argFloat != 0 case types.UntypedComplex, types.Complex64, types.Complex128: - return t&argComplex != 0 + return m.t&argComplex != 0 case types.UntypedString, types.String: - return t&argString != 0 + return m.t&argString != 0 case types.UnsafePointer: - return t&(argPointer|argInt) != 0 + return m.t&(argPointer|argInt) != 0 case types.UntypedRune: - return t&(argInt|argRune) != 0 + return m.t&(argInt|argRune) != 0 case types.UntypedNil: return false case types.Invalid: - if false { - pass.Reportf(arg.Pos(), "printf argument %v has invalid or unknown type", analysisutil.Format(pass.Fset, arg)) - } return true // Probably a type check problem. } panic("unreachable") @@ -193,7 +272,7 @@ func matchArgTypeInternal(pass *analysis.Pass, t printfArgType, typ types.Type, return false } -func isConvertibleToString(pass *analysis.Pass, typ types.Type) bool { +func isConvertibleToString(typ types.Type) bool { if bt, ok := typ.(*types.Basic); ok && bt.Kind() == types.UntypedNil { // We explicitly don't want untyped nil, which is // convertible to both of the interfaces below, as it @@ -228,19 +307,3 @@ func hasBasicType(pass *analysis.Pass, x ast.Expr, kind types.BasicKind) bool { b, ok := t.(*types.Basic) return ok && b.Kind() == kind } - -// matchStructArgType reports whether all the elements of the struct match the expected -// type. For instance, with "%d" all the elements must be printable with the "%d" format. -func matchStructArgType(pass *analysis.Pass, t printfArgType, typ *types.Struct, arg ast.Expr, inProgress map[types.Type]bool) bool { - for i := 0; i < typ.NumFields(); i++ { - typf := typ.Field(i) - if !matchArgTypeInternal(pass, t, typf.Type(), arg, inProgress) { - return false - } - if t&argString != 0 && !typf.Exported() && isConvertibleToString(pass, typf.Type()) { - // Issue #17798: unexported Stringer or error cannot be properly formatted. - return false - } - } - return true -} diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go index 1f3df07ccd..640de28e05 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go @@ -14,11 +14,13 @@ import ( "go/ast" "go/constant" "go/token" + "math" "golang.org/x/tools/go/analysis" "golang.org/x/tools/go/analysis/passes/inspect" "golang.org/x/tools/go/analysis/passes/internal/analysisutil" "golang.org/x/tools/go/ast/inspector" + "golang.org/x/tools/internal/typeparams" ) const Doc = "check for shifts that equal or exceed the width of the integer" @@ -93,9 +95,27 @@ func checkLongShift(pass *analysis.Pass, node ast.Node, x, y ast.Expr) { if t == nil { return } - size := 8 * pass.TypesSizes.Sizeof(t) - if amt >= size { + terms, err := typeparams.StructuralTerms(t) + if err != nil { + return // invalid type + } + sizes := make(map[int64]struct{}) + for _, term := range terms { + size := 8 * pass.TypesSizes.Sizeof(term.Type()) + sizes[size] = struct{}{} + } + minSize := int64(math.MaxInt64) + for size := range sizes { + if size < minSize { + minSize = size + } + } + if amt >= minSize { ident := analysisutil.Format(pass.Fset, x) - pass.ReportRangef(node, "%s (%d bits) too small for shift of %d", ident, size, amt) + qualifier := "" + if len(sizes) > 1 { + qualifier = "may be " + } + pass.ReportRangef(node, "%s (%s%d bits) too small for shift of %d", ident, qualifier, minSize, amt) } } diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go index 7a005901e8..92fd375f23 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go @@ -10,10 +10,12 @@ import ( "fmt" "go/ast" "go/types" + "strings" "golang.org/x/tools/go/analysis" "golang.org/x/tools/go/analysis/passes/inspect" "golang.org/x/tools/go/ast/inspector" + "golang.org/x/tools/internal/typeparams" ) const Doc = `check for string(int) conversions @@ -36,6 +38,35 @@ var Analyzer = &analysis.Analyzer{ Run: run, } +// describe returns a string describing the type typ contained within the type +// set of inType. If non-empty, inName is used as the name of inType (this is +// necessary so that we can use alias type names that may not be reachable from +// inType itself). +func describe(typ, inType types.Type, inName string) string { + name := inName + if typ != inType { + name = typeName(typ) + } + if name == "" { + return "" + } + + var parentheticals []string + if underName := typeName(typ.Underlying()); underName != "" && underName != name { + parentheticals = append(parentheticals, underName) + } + + if typ != inType && inName != "" && inName != name { + parentheticals = append(parentheticals, "in "+inName) + } + + if len(parentheticals) > 0 { + name += " (" + strings.Join(parentheticals, ", ") + ")" + } + + return name +} + func typeName(typ types.Type) string { if v, _ := typ.(interface{ Name() string }); v != nil { return v.Name() @@ -54,6 +85,11 @@ func run(pass *analysis.Pass) (interface{}, error) { inspect.Preorder(nodeFilter, func(n ast.Node) { call := n.(*ast.CallExpr) + if len(call.Args) != 1 { + return + } + arg := call.Args[0] + // Retrieve target type name. var tname *types.TypeName switch fun := call.Fun.(type) { @@ -65,60 +101,100 @@ func run(pass *analysis.Pass) (interface{}, error) { if tname == nil { return } - target := tname.Name() - // Check that target type T in T(v) has an underlying type of string. - T, _ := tname.Type().Underlying().(*types.Basic) - if T == nil || T.Kind() != types.String { - return - } - if s := T.Name(); target != s { - target += " (" + s + ")" + // In the conversion T(v) of a value v of type V to a target type T, we + // look for types T0 in the type set of T and V0 in the type set of V, such + // that V0->T0 is a problematic conversion. If T and V are not type + // parameters, this amounts to just checking if V->T is a problematic + // conversion. + + // First, find a type T0 in T that has an underlying type of string. + T := tname.Type() + tterms, err := typeparams.StructuralTerms(T) + if err != nil { + return // invalid type } - // Check that type V of v has an underlying integral type that is not byte or rune. - if len(call.Args) != 1 { - return + var T0 types.Type // string type in the type set of T + + for _, term := range tterms { + u, _ := term.Type().Underlying().(*types.Basic) + if u != nil && u.Kind() == types.String { + T0 = term.Type() + break + } } - v := call.Args[0] - vtyp := pass.TypesInfo.TypeOf(v) - V, _ := vtyp.Underlying().(*types.Basic) - if V == nil || V.Info()&types.IsInteger == 0 { - return - } - switch V.Kind() { - case types.Byte, types.Rune, types.UntypedRune: + + if T0 == nil { + // No target types have an underlying type of string. return } - // Retrieve source type name. - source := typeName(vtyp) - if source == "" { + // Next, find a type V0 in V that has an underlying integral type that is + // not byte or rune. + V := pass.TypesInfo.TypeOf(arg) + vterms, err := typeparams.StructuralTerms(V) + if err != nil { + return // invalid type + } + + var V0 types.Type // integral type in the type set of V + + for _, term := range vterms { + u, _ := term.Type().Underlying().(*types.Basic) + if u != nil && u.Info()&types.IsInteger != 0 { + switch u.Kind() { + case types.Byte, types.Rune, types.UntypedRune: + continue + } + V0 = term.Type() + break + } + } + + if V0 == nil { + // No source types are non-byte or rune integer types. return } - if s := V.Name(); source != s { - source += " (" + s + ")" + + convertibleToRune := true // if true, we can suggest a fix + for _, term := range vterms { + if !types.ConvertibleTo(term.Type(), types.Typ[types.Rune]) { + convertibleToRune = false + break + } } + + target := describe(T0, T, tname.Name()) + source := describe(V0, V, typeName(V)) + + if target == "" || source == "" { + return // something went wrong + } + diag := analysis.Diagnostic{ Pos: n.Pos(), Message: fmt.Sprintf("conversion from %s to %s yields a string of one rune, not a string of digits (did you mean fmt.Sprint(x)?)", source, target), - SuggestedFixes: []analysis.SuggestedFix{ + } + + if convertibleToRune { + diag.SuggestedFixes = []analysis.SuggestedFix{ { Message: "Did you mean to convert a rune to a string?", TextEdits: []analysis.TextEdit{ { - Pos: v.Pos(), - End: v.Pos(), + Pos: arg.Pos(), + End: arg.Pos(), NewText: []byte("rune("), }, { - Pos: v.End(), - End: v.End(), + Pos: arg.End(), + End: arg.End(), NewText: []byte(")"), }, }, }, - }, + } } pass.Report(diag) }) diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go index ce05a56cca..3d4bd49085 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go @@ -11,6 +11,7 @@ import ( "golang.org/x/tools/go/analysis/passes/inspect" "golang.org/x/tools/go/analysis/passes/internal/analysisutil" "golang.org/x/tools/go/ast/inspector" + "golang.org/x/tools/internal/typeparams" ) const Doc = `report calls to (*testing.T).Fatal from goroutines started by a test. @@ -124,16 +125,30 @@ func typeIsTestingDotTOrB(expr ast.Expr) (string, bool) { // function literals declared in the same function, and // static calls within the same package are supported. func goStmtFun(goStmt *ast.GoStmt) ast.Node { - switch goStmt.Call.Fun.(type) { - case *ast.Ident: - id := goStmt.Call.Fun.(*ast.Ident) - // TODO(cuonglm): improve this once golang/go#48141 resolved. + switch fun := goStmt.Call.Fun.(type) { + case *ast.IndexExpr, *typeparams.IndexListExpr: + ix := typeparams.GetIndexExprData(fun) + if ix == nil { + break + } + id, _ := ix.X.(*ast.Ident) + if id == nil { + break + } if id.Obj == nil { break } if funDecl, ok := id.Obj.Decl.(ast.Node); ok { return funDecl } + case *ast.Ident: + // TODO(cuonglm): improve this once golang/go#48141 resolved. + if fun.Obj == nil { + break + } + if funDecl, ok := fun.Obj.Decl.(ast.Node); ok { + return funDecl + } case *ast.FuncLit: return goStmt.Call.Fun } diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/tests/tests.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/tests/tests.go index 570ad5c209..2c87882496 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/tests/tests.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/tests/tests.go @@ -16,6 +16,7 @@ import ( "unicode/utf8" "golang.org/x/tools/go/analysis" + "golang.org/x/tools/internal/typeparams" ) const Doc = `check for common mistaken usages of tests and examples @@ -170,6 +171,9 @@ func checkExampleName(pass *analysis.Pass, fn *ast.FuncDecl) { if results := fn.Type.Results; results != nil && len(results.List) != 0 { pass.Reportf(fn.Pos(), "%s should return nothing", fnName) } + if tparams := typeparams.ForFuncType(fn.Type); tparams != nil && len(tparams.List) > 0 { + pass.Reportf(fn.Pos(), "%s should not have type params", fnName) + } if fnName == "Example" { // Nothing more to do. @@ -236,6 +240,12 @@ func checkTest(pass *analysis.Pass, fn *ast.FuncDecl, prefix string) { return } + if tparams := typeparams.ForFuncType(fn.Type); tparams != nil && len(tparams.List) > 0 { + // Note: cmd/go/internal/load also errors about TestXXX and BenchmarkXXX functions with type parameters. + // We have currently decided to also warn before compilation/package loading. This can help users in IDEs. + pass.Reportf(fn.Pos(), "%s has type parameters: it will not be run by go test as a %sXXX function", fn.Name.Name, prefix) + } + if !isTestSuffix(fn.Name.Name[len(prefix):]) { pass.Reportf(fn.Pos(), "%s has malformed name: first letter after '%s' must not be lowercase", fn.Name.Name, prefix) } diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go index bececee7e9..fd94508f88 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go @@ -17,6 +17,7 @@ import ( "golang.org/x/tools/go/analysis/passes/inspect" "golang.org/x/tools/go/analysis/passes/internal/analysisutil" "golang.org/x/tools/go/ast/inspector" + "golang.org/x/tools/internal/typeparams" ) // TODO(adonovan): make this analysis modular: export a mustUseResult @@ -70,6 +71,11 @@ func run(pass *analysis.Pass) (interface{}, error) { return // a conversion, not a call } + index := typeparams.GetIndexExprData(fun) + if index != nil { + fun = index.X // If this is generic function or method call, skip the instantiation arguments + } + selector, ok := fun.(*ast.SelectorExpr) if !ok { return // neither a method call nor a qualified ident diff --git a/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/callee.go b/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/callee.go index 38f596daf9..2b8960332d 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/callee.go +++ b/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/callee.go @@ -9,13 +9,30 @@ import ( "go/types" "golang.org/x/tools/go/ast/astutil" + "golang.org/x/tools/internal/typeparams" ) // Callee returns the named target of a function call, if any: // a function, method, builtin, or variable. +// +// Functions and methods may potentially have type parameters. func Callee(info *types.Info, call *ast.CallExpr) types.Object { + fun := astutil.Unparen(call.Fun) + + // Look through type instantiation if necessary. + isInstance := false + switch fun.(type) { + case *ast.IndexExpr, *typeparams.IndexListExpr: + // When extracting the callee from an *IndexExpr, we need to check that + // it is a *types.Func and not a *types.Var. + // Example: Don't match a slice m within the expression `m[0]()`. + isInstance = true + ix := typeparams.GetIndexExprData(fun) + fun = ix.X + } + var obj types.Object - switch fun := astutil.Unparen(call.Fun).(type) { + switch fun := fun.(type) { case *ast.Ident: obj = info.Uses[fun] // type, var, builtin, or declared func case *ast.SelectorExpr: @@ -28,11 +45,18 @@ func Callee(info *types.Info, call *ast.CallExpr) types.Object { if _, ok := obj.(*types.TypeName); ok { return nil // T(x) is a conversion, not a call } + // A Func is required to match instantiations. + if _, ok := obj.(*types.Func); isInstance && !ok { + return nil // Was not a Func. + } return obj } -// StaticCallee returns the target (function or method) of a static -// function call, if any. It returns nil for calls to builtins. +// StaticCallee returns the target (function or method) of a static function +// call, if any. It returns nil for calls to builtins. +// +// Note: for calls of instantiated functions and methods, StaticCallee returns +// the corresponding generic function or method on the generic type. func StaticCallee(info *types.Info, call *ast.CallExpr) *types.Func { if f, ok := Callee(info, call).(*types.Func); ok && !interfaceMethod(f) { return f diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt index 2ac22b951b..3806f7171c 100644 --- a/src/cmd/vendor/modules.txt +++ b/src/cmd/vendor/modules.txt @@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm ## explicit; go 1.17 golang.org/x/crypto/ed25519 golang.org/x/crypto/ed25519/internal/edwards25519 -# golang.org/x/mod v0.5.1-0.20210913215816-37dd6891021a +# golang.org/x/mod v0.6.0-dev.0.20210913215816-37dd6891021a ## explicit; go 1.17 golang.org/x/mod/internal/lazyregexp golang.org/x/mod/modfile @@ -51,7 +51,7 @@ golang.org/x/sys/windows # golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 ## explicit; go 1.17 golang.org/x/term -# golang.org/x/tools v0.1.8-0.20211025211149-f916b54a1784 +# golang.org/x/tools v0.1.8-0.20211109164901-e9000123914f ## explicit; go 1.17 golang.org/x/tools/cover golang.org/x/tools/go/analysis From a0963164e86356092074473049cca7bff52afbce Mon Sep 17 00:00:00 2001 From: David Chase Date: Tue, 9 Nov 2021 11:47:49 -0500 Subject: [PATCH 060/752] cmd/compile: add line number test for #49436 This enhances the existing line number test to allow a specific -gcflags (e.g., -G=3) and to permit ignoring duplicate line numbers (which is arguably a bug, but not THIS bug, and it lowers the risk of a flaky test). Limited to Linux/Darwin and amd64/arm64, also tests with "unified" mangling. And, using these new powers, adds a test. Updates #49436. Change-Id: I09c82e6a08d53edd5a752522a827e872d3e16e0b Reviewed-on: https://go-review.googlesource.com/c/go/+/362714 Trust: David Chase Run-TryBot: David Chase TryBot-Result: Go Bot Reviewed-by: Keith Randall --- .../compile/internal/ssa/debug_lines_test.go | 49 +++++++++++++++---- .../compile/internal/ssa/testdata/pushback.go | 30 ++++++++++++ 2 files changed, 70 insertions(+), 9 deletions(-) create mode 100644 src/cmd/compile/internal/ssa/testdata/pushback.go diff --git a/src/cmd/compile/internal/ssa/debug_lines_test.go b/src/cmd/compile/internal/ssa/debug_lines_test.go index da04e5b04e..0df56f5d4b 100644 --- a/src/cmd/compile/internal/ssa/debug_lines_test.go +++ b/src/cmd/compile/internal/ssa/debug_lines_test.go @@ -8,10 +8,10 @@ import ( "bufio" "bytes" "flag" + "internal/buildcfg" "runtime" "sort" - // "flag" "fmt" "internal/testenv" "io/ioutil" @@ -45,7 +45,7 @@ func testGoArch() string { return *testGoArchFlag } -func TestDebugLines(t *testing.T) { +func TestDebugLinesSayHi(t *testing.T) { // This test is potentially fragile, the goal is that debugging should step properly through "sayhi" // If the blocks are reordered in a way that changes the statement order but execution flows correctly, // then rearrange the expected numbers. Register abi and not-register-abi also have different sequences, @@ -53,16 +53,35 @@ func TestDebugLines(t *testing.T) { switch testGoArch() { case "arm64", "amd64": // register ABI - testDebugLines(t, "sayhi.go", "sayhi", []int{8, 9, 10, 11}) + testDebugLines(t, "-N -l", "sayhi.go", "sayhi", []int{8, 9, 10, 11}, false) case "arm", "386": // probably not register ABI for a while - testDebugLines(t, "sayhi.go", "sayhi", []int{9, 10, 11}) + testDebugLines(t, "-N -l", "sayhi.go", "sayhi", []int{9, 10, 11}, false) default: // expect ppc64le and riscv will pick up register ABI soonish, not sure about others t.Skip("skipped for many architectures, also changes w/ register ABI") } } +func TestDebugLinesPushback(t *testing.T) { + if runtime.GOOS != "linux" && runtime.GOOS != "darwin" { // in particular, it could be windows. + t.Skip("this test depends on creating a file with a wonky name, only works for sure on Linux and Darwin") + } + + switch testGoArch() { + default: + t.Skip("skipped for many architectures") + + case "arm64", "amd64": // register ABI + fn := "(*List[go.shape.int_0]).PushBack" + if buildcfg.Experiment.Unified { + // Unified mangles differently + fn = "(*List[int]).PushBack" + } + testDebugLines(t, "-N -l -G=3", "pushback.go", fn, []int{17, 18, 19, 20, 21, 22, 24}, true) + } +} + func TestInlineLines(t *testing.T) { if runtime.GOARCH != "amd64" && *testGoArchFlag == "" { // As of september 2021, works for everything except mips64, but still potentially fragile @@ -181,8 +200,8 @@ func testInlineStack(t *testing.T, file, function string, wantStacks [][]int) { // then verifies that the statement-marked lines in that file are the same as those in wantStmts // These files must all be short because this is super-fragile. // "go build" is run in a temporary directory that is normally deleted, unless -test.v -func testDebugLines(t *testing.T, file, function string, wantStmts []int) { - dumpBytes := compileAndDump(t, file, function, "-N -l") +func testDebugLines(t *testing.T, gcflags, file, function string, wantStmts []int, ignoreRepeats bool) { + dumpBytes := compileAndDump(t, file, function, gcflags) dump := bufio.NewScanner(bytes.NewReader(dumpBytes)) var gotStmts []int dumpLineNum := 0 @@ -201,8 +220,20 @@ func testDebugLines(t *testing.T, file, function string, wantStmts []int) { gotStmts = append(gotStmts, int(stmt)) } } - if !reflect.DeepEqual(wantStmts, gotStmts) { - t.Errorf("wanted stmts %v but got %v", wantStmts, gotStmts) - } + if ignoreRepeats { // remove repeats from gotStmts + newGotStmts := []int{gotStmts[0]} + for _, x := range gotStmts { + if x != newGotStmts[len(newGotStmts)-1] { + newGotStmts = append(newGotStmts, x) + } + } + if !reflect.DeepEqual(wantStmts, newGotStmts) { + t.Errorf("wanted stmts %v but got %v (with repeats still in: %v)", wantStmts, newGotStmts, gotStmts) + } + } else { + if !reflect.DeepEqual(wantStmts, gotStmts) { + t.Errorf("wanted stmts %v but got %v", wantStmts, gotStmts) + } + } } diff --git a/src/cmd/compile/internal/ssa/testdata/pushback.go b/src/cmd/compile/internal/ssa/testdata/pushback.go new file mode 100644 index 0000000000..754e6cbb23 --- /dev/null +++ b/src/cmd/compile/internal/ssa/testdata/pushback.go @@ -0,0 +1,30 @@ +package main + +type Node struct { + Circular bool +} + +type ExtNode[V any] struct { + v V + Node +} + +type List[V any] struct { + root *ExtNode[V] + len int +} + +func (list *List[V]) PushBack(arg V) { + if list.len == 0 { + list.root = &ExtNode[V]{v: arg} + list.root.Circular = true + list.len++ + return + } + list.len++ +} + +func main() { + var v List[int] + v.PushBack(1) +} From f981a9f7ded779749dca199e0893aa08529b52ec Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 9 Nov 2021 14:10:37 -0500 Subject: [PATCH 061/752] go/types: clearer object string for type parameters This is a port of CL 361401 to go/types. Change-Id: I5b1c7cf1d7a819b2902c304f884492ec02c7eaa1 Reviewed-on: https://go-review.googlesource.com/c/go/+/362737 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Go Bot --- src/go/types/object.go | 21 ++++++--- src/go/types/object_test.go | 78 +++++++++++++++++++++++++++++++++ src/go/types/typestring_test.go | 7 ++- 3 files changed, 98 insertions(+), 8 deletions(-) diff --git a/src/go/types/object.go b/src/go/types/object.go index a8bd62a04e..e7a4425643 100644 --- a/src/go/types/object.go +++ b/src/go/types/object.go @@ -412,6 +412,9 @@ func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) { case *TypeName: tname = obj buf.WriteString("type") + if isTypeParam(typ) { + buf.WriteString(" parameter") + } case *Var: if obj.isField { @@ -457,18 +460,22 @@ func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) { } if tname != nil { - // We have a type object: Don't print anything more for - // basic types since there's no more information (names - // are the same; see also comment in TypeName.IsAlias). - if _, ok := typ.(*Basic); ok { + switch t := typ.(type) { + case *Basic: + // Don't print anything more for basic types since there's + // no more information. return - } - if named, _ := typ.(*Named); named != nil && named.TypeParams().Len() > 0 { - newTypeWriter(buf, qf).tParamList(named.TypeParams().list()) + case *Named: + if t.TypeParams().Len() > 0 { + newTypeWriter(buf, qf).tParamList(t.TypeParams().list()) + } } if tname.IsAlias() { buf.WriteString(" =") + } else if t, _ := typ.(*TypeParam); t != nil { + typ = t.bound } else { + // TODO(gri) should this be fromRHS for *Named? typ = under(typ) } } diff --git a/src/go/types/object_test.go b/src/go/types/object_test.go index e9a4bd6dbf..46b92a4006 100644 --- a/src/go/types/object_test.go +++ b/src/go/types/object_test.go @@ -8,6 +8,8 @@ import ( "go/ast" "go/parser" "go/token" + "internal/testenv" + "strings" "testing" . "go/types" @@ -89,3 +91,79 @@ func TestEmbeddedMethod(t *testing.T) { t.Fatalf("%s (%p) != %s (%p)", orig, orig, embed, embed) } } + +var testObjects = []struct { + src string + obj string + want string +}{ + {"import \"io\"; var r io.Reader", "r", "var p.r io.Reader"}, + + {"const c = 1.2", "c", "const p.c untyped float"}, + {"const c float64 = 3.14", "c", "const p.c float64"}, + + {"type t struct{f int}", "t", "type p.t struct{f int}"}, + {"type t func(int)", "t", "type p.t func(int)"}, + {"type t[P any] struct{f P}", "t", "type p.t[P interface{}] struct{f P}"}, + {"type t[P any] struct{f P}", "t.P", "type parameter P interface{}"}, + {"type C interface{m()}; type t[P C] struct{}", "t.P", "type parameter P p.C"}, + + {"type t = struct{f int}", "t", "type p.t = struct{f int}"}, + {"type t = func(int)", "t", "type p.t = func(int)"}, + + {"var v int", "v", "var p.v int"}, + + {"func f(int) string", "f", "func p.f(int) string"}, + {"func g[P any](x P){}", "g", "func p.g[P interface{}](x P)"}, + {"func g[P interface{~int}](x P){}", "g.P", "type parameter P interface{~int}"}, +} + +func TestObjectString(t *testing.T) { + testenv.MustHaveGoBuild(t) + + for _, test := range testObjects { + src := "package p; " + test.src + pkg, err := makePkg(src) + if err != nil { + t.Errorf("%s: %s", src, err) + continue + } + + names := strings.Split(test.obj, ".") + if len(names) != 1 && len(names) != 2 { + t.Errorf("%s: invalid object path %s", test.src, test.obj) + continue + } + obj := pkg.Scope().Lookup(names[0]) + if obj == nil { + t.Errorf("%s: %s not found", test.src, names[0]) + continue + } + if len(names) == 2 { + if typ, ok := obj.Type().(interface{ TypeParams() *TypeParamList }); ok { + obj = lookupTypeParamObj(typ.TypeParams(), names[1]) + if obj == nil { + t.Errorf("%s: %s not found", test.src, test.obj) + continue + } + } else { + t.Errorf("%s: %s has no type parameters", test.src, names[0]) + continue + } + } + + if got := obj.String(); got != test.want { + t.Errorf("%s: got %s, want %s", test.src, got, test.want) + } + } +} + +func lookupTypeParamObj(list *TypeParamList, name string) Object { + for i := 0; i < list.Len(); i++ { + tpar := list.At(i) + if tpar.Obj().Name() == name { + return tpar.Obj() + } + } + return nil +} diff --git a/src/go/types/typestring_test.go b/src/go/types/typestring_test.go index 5718ffcc6c..14ab9b6002 100644 --- a/src/go/types/typestring_test.go +++ b/src/go/types/typestring_test.go @@ -133,7 +133,12 @@ func TestTypeString(t *testing.T) { t.Errorf("%s: %s", src, err) continue } - typ := pkg.Scope().Lookup("T").Type().Underlying() + obj := pkg.Scope().Lookup("T") + if obj == nil { + t.Errorf("%s: T not found", test.src) + continue + } + typ := obj.Type().Underlying() if got := typ.String(); got != test.str { t.Errorf("%s: got %s, want %s", test.src, got, test.str) } From b93220c9ca1935c56c01afc1d72d063f1e026f15 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 12 Oct 2021 16:50:35 -0700 Subject: [PATCH 062/752] encoding/xml: add generic encoding test Fixes #48521 Change-Id: Id8402bcff243c0ab19e4ec0b138b9af8c111f88d Reviewed-on: https://go-review.googlesource.com/c/go/+/355492 Trust: Keith Randall Trust: Dan Scales Run-TryBot: Keith Randall TryBot-Result: Go Bot Reviewed-by: Dan Scales --- src/encoding/xml/marshal_test.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/encoding/xml/marshal_test.go b/src/encoding/xml/marshal_test.go index d2e5137afd..cb95905f5b 100644 --- a/src/encoding/xml/marshal_test.go +++ b/src/encoding/xml/marshal_test.go @@ -524,6 +524,10 @@ type IfaceAny struct { T2 T2 } +type Generic[T any] struct { + X T +} + var ( nameAttr = "Sarah" ageAttr = uint(12) @@ -641,6 +645,7 @@ var marshalTests = []struct { {Value: &Particle{HasMass: true}, ExpectXML: `true`}, {Value: &Departure{When: ParseTime("2013-01-09T00:15:00-09:00")}, ExpectXML: `2013-01-09T00:15:00-09:00`}, {Value: atomValue, ExpectXML: atomXML}, + {Value: &Generic[int]{1}, ExpectXML: `1`}, { Value: &Ship{ Name: "Heart of Gold", From 805b4d56364ec40f29fc7efba5de537d14036c6a Mon Sep 17 00:00:00 2001 From: Manlio Perillo Date: Sun, 16 May 2021 19:52:37 +0200 Subject: [PATCH 063/752] cmd/dist: wait for exit in bgwait after a fatal error Currently, when a command scheduled by bgrun fails, bgwait returns to the caller even in case the fatal error was detected. In case of a syntax error in one of the standard packages, as an example, the runInstall function will try to read the generated archive file, only to fail since the file does not exist. Since the runInstall function is called in a goroutine, cmd/dist will continue to report errors until all background goroutines are done. Update the bgwait function to wait until program termination in case of a fatal error, since returning to the caller (with an error, as an example) will cause cmd/dist to report an additional error during the next build phase. Fixes #45410 Change-Id: If89976abad70f8d6ec79b2a5a1f2306e9c034c5a Reviewed-on: https://go-review.googlesource.com/c/go/+/320311 Run-TryBot: Ian Lance Taylor TryBot-Result: Go Bot Reviewed-by: Ian Lance Taylor Trust: Dmitri Shuralyov --- src/cmd/dist/util.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/cmd/dist/util.go b/src/cmd/dist/util.go index 28fe5e1d8d..8856f467d5 100644 --- a/src/cmd/dist/util.go +++ b/src/cmd/dist/util.go @@ -172,6 +172,9 @@ func bgwait(wg *sync.WaitGroup) { select { case <-done: case <-dying: + // Don't return to the caller, to avoid reporting additional errors + // to the user. + select {} } } From a65a095ca423c21bdd53a6a8300b501b88d60137 Mon Sep 17 00:00:00 2001 From: Manlio Perillo Date: Sat, 24 Apr 2021 16:19:07 +0200 Subject: [PATCH 064/752] cmd/go/internal/bug: remove duplicate code Change-Id: I8a14b2fbb44f7ed1ea126cf27adc447f33fdf6f2 Reviewed-on: https://go-review.googlesource.com/c/go/+/313170 Reviewed-by: Bryan C. Mills Run-TryBot: Bryan C. Mills TryBot-Result: Go Bot Trust: Cherry Mui --- src/cmd/go/internal/bug/bug.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/internal/bug/bug.go b/src/cmd/go/internal/bug/bug.go index a81ca7d8c3..702dc2a14a 100644 --- a/src/cmd/go/internal/bug/bug.go +++ b/src/cmd/go/internal/bug/bug.go @@ -106,8 +106,9 @@ func printGoEnv(w io.Writer) { } func printGoDetails(w io.Writer) { - printCmdOut(w, "GOROOT/bin/go version: ", filepath.Join(runtime.GOROOT(), "bin/go"), "version") - printCmdOut(w, "GOROOT/bin/go tool compile -V: ", filepath.Join(runtime.GOROOT(), "bin/go"), "tool", "compile", "-V") + gocmd := filepath.Join(runtime.GOROOT(), "bin/go") + printCmdOut(w, "GOROOT/bin/go version: ", gocmd, "version") + printCmdOut(w, "GOROOT/bin/go tool compile -V: ", gocmd, "tool", "compile", "-V") } func printOSDetails(w io.Writer) { From 4aa0746f6abae7dc112883e79f93993a430bd340 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Tue, 19 Oct 2021 14:05:29 -0400 Subject: [PATCH 065/752] cmd/go: add workspace pruning mode [ this is a roll-forward of golang.org/cl/357169 with minor changes to fix the cmd/go/internal/modload tests: because they don't run the go command, some initialization isn't run on the test and modroots is empty in cases it can't be when the full command setup is done. So directly check for workFilePath != "" instead of calling inWorkspaceMode which checks that Init is called first, and check that modRoots is non empty when calling mustGetSingleMainModule.] This change corrects a bug in the handling of module loading of workspaces. Namely, there is an assumption by the module pruning code that if a root module is selected then the packages of that module can be resolved without loading the whole module graph. This is not true in workspace mode because two workspace modules can require different versions of a dependency. Worse, one workspace module can directly require a depencency that is transitively required by another workspace module, changing the version of that module loaded in the fully expanded graph. To correct this, a new 'workspace' pruning mode is added where the roots are the workspace modules themselves, satisfying the assumption made by the module pruning logic. The rest of this change accounts for the new pruning mode where it's used and correctly sets the requirements in this pruning mode. Change-Id: I8bdf4b30f669c1ded0ed8a5dd202ac8d1939bbbd Reviewed-on: https://go-review.googlesource.com/c/go/+/362754 Trust: Michael Matloob Run-TryBot: Michael Matloob Reviewed-by: Bryan C. Mills TryBot-Result: Go Bot --- src/cmd/go/internal/modload/buildlist.go | 86 ++++++++++++++++------ src/cmd/go/internal/modload/import_test.go | 2 +- src/cmd/go/internal/modload/init.go | 44 +++++------ src/cmd/go/internal/modload/load.go | 24 +++++- src/cmd/go/internal/modload/modfile.go | 14 +++- src/cmd/go/testdata/script/work_prune.txt | 2 +- 6 files changed, 122 insertions(+), 50 deletions(-) diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go index 27cab0b9c8..0cb4a88fcb 100644 --- a/src/cmd/go/internal/modload/buildlist.go +++ b/src/cmd/go/internal/modload/buildlist.go @@ -38,11 +38,17 @@ type Requirements struct { // If pruned, the graph includes only the root modules, the explicit // requirements of those root modules, and the transitive requirements of only // the root modules that do not support pruning. + // + // If workspace, the graph includes only the workspace modules, the explicit + // requirements of the workspace modules, and the transitive requirements of + // the workspace modules that do not support pruning. pruning modPruning - // rootModules is the set of module versions explicitly required by the main - // modules, sorted and capped to length. It may contain duplicates, and may - // contain multiple versions for a given module path. + // rootModules is the set of root modules of the graph, sorted and capped to + // length. It may contain duplicates, and may contain multiple versions for a + // given module path. The root modules of the groph are the set of main + // modules in workspace mode, and the main module's direct requirements + // outside workspace mode. rootModules []module.Version maxRootVersion map[string]string @@ -99,6 +105,19 @@ var requirements *Requirements // If vendoring is in effect, the caller must invoke initVendor on the returned // *Requirements before any other method. func newRequirements(pruning modPruning, rootModules []module.Version, direct map[string]bool) *Requirements { + if pruning == workspace { + return &Requirements{ + pruning: pruning, + rootModules: capVersionSlice(rootModules), + maxRootVersion: nil, + direct: direct, + } + } + + if workFilePath != "" && pruning != workspace { + panic("in workspace mode, but pruning is not workspace in newRequirements") + } + for i, m := range rootModules { if m.Version == "" && MainModules.Contains(m.Path) { panic(fmt.Sprintf("newRequirements called with untrimmed build list: rootModules[%v] is a main module", i)) @@ -291,13 +310,11 @@ func readModGraph(ctx context.Context, pruning modPruning, roots []module.Versio g: mvs.NewGraph(cmpVersion, MainModules.Versions()), } ) - for _, m := range MainModules.Versions() { - // Require all roots from all main modules. - _ = TODOWorkspaces("This flattens a level of the module graph, adding the dependencies " + - "of all main modules to a single requirements struct, and losing the information of which " + - "main module required which requirement. Rework the requirements struct and change this" + - "to reflect the structure of the main modules.") - mg.g.Require(m, roots) + if pruning != workspace { + if inWorkspaceMode() { + panic("pruning is not workspace in workspace mode") + } + mg.g.Require(MainModules.mustGetSingleMainModule(), roots) } var ( @@ -352,9 +369,13 @@ func readModGraph(ctx context.Context, pruning modPruning, roots []module.Versio // are sufficient to build the packages it contains. We must load its full // transitive dependency graph to be sure that we see all relevant // dependencies. - if pruning == unpruned || summary.pruning == unpruned { + if pruning != pruned || summary.pruning == unpruned { + nextPruning := summary.pruning + if pruning == unpruned { + nextPruning = unpruned + } for _, r := range summary.require { - enqueue(r, unpruned) + enqueue(r, nextPruning) } } }) @@ -424,12 +445,15 @@ func (mg *ModuleGraph) findError() error { } func (mg *ModuleGraph) allRootsSelected() bool { - for _, mm := range MainModules.Versions() { - roots, _ := mg.g.RequiredBy(mm) - for _, m := range roots { - if mg.Selected(m.Path) != m.Version { - return false - } + var roots []module.Version + if inWorkspaceMode() { + roots = MainModules.Versions() + } else { + roots, _ = mg.g.RequiredBy(MainModules.mustGetSingleMainModule()) + } + for _, m := range roots { + if mg.Selected(m.Path) != m.Version { + return false } } return true @@ -576,10 +600,29 @@ func tidyRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Require } func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version, rootsImported bool) (*Requirements, error) { - if rs.pruning == unpruned { + switch rs.pruning { + case unpruned: return updateUnprunedRoots(ctx, direct, rs, add) + case pruned: + return updatePrunedRoots(ctx, direct, rs, pkgs, add, rootsImported) + case workspace: + return updateWorkspaceRoots(ctx, rs, add) + default: + panic(fmt.Sprintf("unsupported pruning mode: %v", rs.pruning)) } - return updatePrunedRoots(ctx, direct, rs, pkgs, add, rootsImported) +} + +func updateWorkspaceRoots(ctx context.Context, rs *Requirements, add []module.Version) (*Requirements, error) { + if len(add) != 0 { + // add should be empty in workspace mode because a non-empty add slice means + // that there are missing roots in the current pruning mode or that the + // pruning mode is being changed. But the pruning mode should always be + // 'workspace' in workspace mode and the set of roots in workspace mode is + // always complete because it's the set of workspace modules, which can't + // be edited by loading. + panic("add is not empty") + } + return rs, nil } // tidyPrunedRoots returns a minimal set of root requirements that maintains the @@ -1156,7 +1199,6 @@ func updateUnprunedRoots(ctx context.Context, direct map[string]bool, rs *Requir } } - // TODO(matloob): Make roots into a map. var roots []module.Version for _, mainModule := range MainModules.Versions() { min, err := mvs.Req(mainModule, rootPaths, &mvsReqs{roots: keep}) @@ -1182,6 +1224,8 @@ func updateUnprunedRoots(ctx context.Context, direct map[string]bool, rs *Requir func convertPruning(ctx context.Context, rs *Requirements, pruning modPruning) (*Requirements, error) { if rs.pruning == pruning { return rs, nil + } else if rs.pruning == workspace || pruning == workspace { + panic("attempthing to convert to/from workspace pruning and another pruning type") } if pruning == unpruned { diff --git a/src/cmd/go/internal/modload/import_test.go b/src/cmd/go/internal/modload/import_test.go index 11310489ad..65a889ec52 100644 --- a/src/cmd/go/internal/modload/import_test.go +++ b/src/cmd/go/internal/modload/import_test.go @@ -69,7 +69,7 @@ func TestQueryImport(t *testing.T) { RootMode = NoRoot ctx := context.Background() - rs := newRequirements(unpruned, nil, nil) + rs := LoadModFile(ctx) for _, tt := range importTests { t.Run(strings.ReplaceAll(tt.path, "/", "_"), func(t *testing.T) { diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go index 9aef5a7c33..512c9ebfbd 100644 --- a/src/cmd/go/internal/modload/init.go +++ b/src/cmd/go/internal/modload/init.go @@ -704,7 +704,7 @@ func LoadModFile(ctx context.Context) *Requirements { } } - if MainModules.Index(mainModule).goVersionV == "" { + if MainModules.Index(mainModule).goVersionV == "" && rs.pruning != workspace { // TODO(#45551): Do something more principled instead of checking // cfg.CmdName directly here. if cfg.BuildMod == "mod" && cfg.CmdName != "mod graph" && cfg.CmdName != "mod why" { @@ -987,29 +987,29 @@ func makeMainModules(ms []module.Version, rootDirs []string, modFiles []*modfile // requirementsFromModFiles returns the set of non-excluded requirements from // the global modFile. func requirementsFromModFiles(ctx context.Context, modFiles []*modfile.File) *Requirements { - rootCap := 0 - for i := range modFiles { - rootCap += len(modFiles[i].Require) - } - roots := make([]module.Version, 0, rootCap) - mPathCount := make(map[string]int) - for _, m := range MainModules.Versions() { - mPathCount[m.Path] = 1 - } + var roots []module.Version direct := map[string]bool{} - for _, modFile := range modFiles { - requirement: + var pruning modPruning + if inWorkspaceMode() { + pruning = workspace + roots = make([]module.Version, len(MainModules.Versions())) + copy(roots, MainModules.Versions()) + } else { + pruning = pruningForGoVersion(MainModules.GoVersion()) + if len(modFiles) != 1 { + panic(fmt.Errorf("requirementsFromModFiles called with %v modfiles outside workspace mode", len(modFiles))) + } + modFile := modFiles[0] + roots = make([]module.Version, 0, len(modFile.Require)) + mm := MainModules.mustGetSingleMainModule() for _, r := range modFile.Require { - // TODO(#45713): Maybe join - for _, mainModule := range MainModules.Versions() { - if index := MainModules.Index(mainModule); index != nil && index.exclude[r.Mod] { - if cfg.BuildMod == "mod" { - fmt.Fprintf(os.Stderr, "go: dropping requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) - } else { - fmt.Fprintf(os.Stderr, "go: ignoring requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) - } - continue requirement + if index := MainModules.Index(mm); index != nil && index.exclude[r.Mod] { + if cfg.BuildMod == "mod" { + fmt.Fprintf(os.Stderr, "go: dropping requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) + } else { + fmt.Fprintf(os.Stderr, "go: ignoring requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version) } + continue } roots = append(roots, r.Mod) @@ -1019,7 +1019,7 @@ func requirementsFromModFiles(ctx context.Context, modFiles []*modfile.File) *Re } } module.Sort(roots) - rs := newRequirements(pruningForGoVersion(MainModules.GoVersion()), roots, direct) + rs := newRequirements(pruning, roots, direct) return rs } diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go index 845bf2f8a2..83fcafead3 100644 --- a/src/cmd/go/internal/modload/load.go +++ b/src/cmd/go/internal/modload/load.go @@ -1004,7 +1004,11 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader { } var err error - ld.requirements, err = convertPruning(ctx, ld.requirements, pruningForGoVersion(ld.GoVersion)) + desiredPruning := pruningForGoVersion(ld.GoVersion) + if ld.requirements.pruning == workspace { + desiredPruning = workspace + } + ld.requirements, err = convertPruning(ctx, ld.requirements, desiredPruning) if err != nil { ld.errorf("go: %v\n", err) } @@ -1246,6 +1250,24 @@ func (ld *loader) updateRequirements(ctx context.Context) (changed bool, err err continue } + if inWorkspaceMode() { + // In workspace mode / workspace pruning mode, the roots are the main modules + // rather than the main module's direct dependencies. The check below on the selected + // roots does not apply. + if mg, err := rs.Graph(ctx); err != nil { + return false, err + } else if _, ok := mg.RequiredBy(dep.mod); !ok { + // dep.mod is not an explicit dependency, but needs to be. + // See comment on error returned below. + pkg.err = &DirectImportFromImplicitDependencyError{ + ImporterPath: pkg.path, + ImportedPath: dep.path, + Module: dep.mod, + } + } + continue + } + if pkg.err == nil && cfg.BuildMod != "mod" { if v, ok := rs.rootSelected(dep.mod.Path); !ok || v != dep.mod.Version { // dep.mod is not an explicit dependency, but needs to be. diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go index a7e92222a1..40e6ed787d 100644 --- a/src/cmd/go/internal/modload/modfile.go +++ b/src/cmd/go/internal/modload/modfile.go @@ -118,8 +118,9 @@ type requireMeta struct { type modPruning uint8 const ( - pruned modPruning = iota // transitive dependencies of modules at go 1.17 and higher are pruned out - unpruned // no transitive dependencies are pruned out + pruned modPruning = iota // transitive dependencies of modules at go 1.17 and higher are pruned out + unpruned // no transitive dependencies are pruned out + workspace // pruned to the union of modules in the workspace ) func pruningForGoVersion(goVersion string) modPruning { @@ -554,7 +555,7 @@ type retraction struct { // // The caller must not modify the returned summary. func goModSummary(m module.Version) (*modFileSummary, error) { - if m.Version == "" && MainModules.Contains(m.Path) { + if m.Version == "" && !inWorkspaceMode() && MainModules.Contains(m.Path) { panic("internal error: goModSummary called on a main module") } @@ -718,9 +719,14 @@ var rawGoModSummaryCache par.Cache // module.Version → rawGoModSummary result func rawGoModData(m module.Version) (name string, data []byte, err error) { if m.Version == "" { // m is a replacement module with only a file path. + dir := m.Path if !filepath.IsAbs(dir) { - dir = filepath.Join(replaceRelativeTo(), dir) + if inWorkspaceMode() && MainModules.Contains(m.Path) { + dir = MainModules.ModRoot(m) + } else { + dir = filepath.Join(replaceRelativeTo(), dir) + } } name = filepath.Join(dir, "go.mod") if gomodActual, ok := fsys.OverlayPath(name); ok { diff --git a/src/cmd/go/testdata/script/work_prune.txt b/src/cmd/go/testdata/script/work_prune.txt index f0fb073c4b..00c3e10663 100644 --- a/src/cmd/go/testdata/script/work_prune.txt +++ b/src/cmd/go/testdata/script/work_prune.txt @@ -14,7 +14,7 @@ # TODO(#48331): We currently load the wrong version of q. Fix this. go list -m -f '{{.Version}}' example.com/q -stdout '^v1.0.0$' # TODO(#48331): This should be 1.1.0. Fix this. +stdout '^v1.1.0$' -- go.work -- go 1.18 From cb908f1d4dd24dad17105022df7b0e96ac1d6988 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 9 Nov 2021 14:56:39 -0500 Subject: [PATCH 066/752] go/types: don't return an array type with invalid length In preparation for porting CL 361412, fix a discrepancy in go/types, where [-1]T is returned for an array type with invalid length. Change-Id: Ia32f5b66c9c561ccf0c32af1922fc4690c66dbc3 Reviewed-on: https://go-review.googlesource.com/c/go/+/362738 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/types/api_test.go | 2 +- src/go/types/typexpr.go | 12 +++++++----- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go index 807bffbff6..3e10be5985 100644 --- a/src/go/types/api_test.go +++ b/src/go/types/api_test.go @@ -342,7 +342,7 @@ func TestTypesInfo(t *testing.T) { {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{})`}, - {broken + `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]invalid type`}, // parameterized functions {genericPkg + `p0; func f[T any](T) {}; var _ = f[int]`, `f`, `func[T interface{}](T)`}, diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go index e1d942a5c6..cc2bd62209 100644 --- a/src/go/types/typexpr.go +++ b/src/go/types/typexpr.go @@ -271,18 +271,20 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) { return check.definedType(e.X, def) case *ast.ArrayType: - if e.Len != nil { - typ := new(Array) + if e.Len == nil { + typ := new(Slice) def.setUnderlying(typ) - typ.len = check.arrayLength(e.Len) typ.elem = check.varType(e.Elt) return typ } - typ := new(Slice) + typ := new(Array) def.setUnderlying(typ) + typ.len = check.arrayLength(e.Len) typ.elem = check.varType(e.Elt) - return typ + if typ.len >= 0 { + return typ + } case *ast.Ellipsis: // dots are handled explicitly where they are legal From 1c86beeadfc7a370048ad58f76b1b60b5bcd06ee Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 9 Nov 2021 14:20:11 -0500 Subject: [PATCH 067/752] go/types: report error for incomplete struct composite literal type This is a port of CL 361412 to go/types. Change-Id: Ie5bccc7faba7ca9230e712f867b27ca9dcddba79 Reviewed-on: https://go-review.googlesource.com/c/go/+/362739 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/types/expr.go | 6 +++ src/go/types/struct.go | 14 +++++- src/go/types/subst.go | 4 +- .../types/testdata/fixedbugs/issue49276.go2 | 46 +++++++++++++++++++ 4 files changed, 67 insertions(+), 3 deletions(-) create mode 100644 src/go/types/testdata/fixedbugs/issue49276.go2 diff --git a/src/go/types/expr.go b/src/go/types/expr.go index 83022ed660..224185b6a9 100644 --- a/src/go/types/expr.go +++ b/src/go/types/expr.go @@ -1230,6 +1230,12 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind { switch utyp := structure(base).(type) { case *Struct: + // Prevent crash if the struct referred to is not yet set up. + // See analogous comment for *Array. + if utyp.fields == nil { + check.error(e, _Todo, "illegal cycle in type declaration") + goto Error + } if len(e.Elts) == 0 { break } diff --git a/src/go/types/struct.go b/src/go/types/struct.go index 442c7a66e3..60640ac578 100644 --- a/src/go/types/struct.go +++ b/src/go/types/struct.go @@ -15,7 +15,7 @@ import ( // A Struct represents a struct type. type Struct struct { - fields []*Var + fields []*Var // fields != nil indicates the struct is set up (possibly with len(fields) == 0) tags []string // field tags; nil if there are no tags } @@ -33,7 +33,9 @@ func NewStruct(fields []*Var, tags []string) *Struct { if len(tags) > len(fields) { panic("more tags than fields") } - return &Struct{fields: fields, tags: tags} + s := &Struct{fields: fields, tags: tags} + s.markComplete() + return s } // NumFields returns the number of fields in the struct (including blank and embedded fields). @@ -56,9 +58,16 @@ func (t *Struct) String() string { return TypeString(t, nil) } // ---------------------------------------------------------------------------- // Implementation +func (s *Struct) markComplete() { + if s.fields == nil { + s.fields = make([]*Var, 0) + } +} + func (check *Checker) structType(styp *Struct, e *ast.StructType) { list := e.Fields if list == nil { + styp.markComplete() return } @@ -161,6 +170,7 @@ func (check *Checker) structType(styp *Struct, e *ast.StructType) { styp.fields = fields styp.tags = tags + styp.markComplete() } func embeddedFieldIdent(e ast.Expr) *ast.Ident { diff --git a/src/go/types/subst.go b/src/go/types/subst.go index f0b79f60c6..1fac82fe8a 100644 --- a/src/go/types/subst.go +++ b/src/go/types/subst.go @@ -91,7 +91,9 @@ func (subst *subster) typ(typ Type) Type { case *Struct: if fields, copied := subst.varList(t.fields); copied { - return &Struct{fields: fields, tags: t.tags} + s := &Struct{fields: fields, tags: t.tags} + s.markComplete() + return s } case *Pointer: diff --git a/src/go/types/testdata/fixedbugs/issue49276.go2 b/src/go/types/testdata/fixedbugs/issue49276.go2 new file mode 100644 index 0000000000..8839087b50 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue49276.go2 @@ -0,0 +1,46 @@ +// 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 "unsafe" + +type S /* ERROR illegal cycle in declaration of S */ struct { + _ [unsafe.Sizeof(s)]byte +} + +var s S + +// Since f is a pointer, this case could be valid. +// But it's pathological and not worth the expense. +type T struct { + f *[unsafe.Sizeof(T /* ERROR illegal cycle in type declaration */ {})]int +} + +// a mutually recursive case using unsafe.Sizeof +type ( + A1 struct { + _ [unsafe.Sizeof(B1{})]int + } + + B1 struct { + _ [unsafe.Sizeof(A1 /* ERROR illegal cycle in type declaration */ {})]int + } +) + +// a mutually recursive case using len +type ( + A2 struct { + f [len(B2{}.f)]int + } + + B2 struct { + f [len(A2 /* ERROR illegal cycle in type declaration */ {}.f)]int + } +) + +// test case from issue +type a struct { + _ [42 - unsafe.Sizeof(a /* ERROR illegal cycle in type declaration */ {})]byte +} From 795cb333d94ee7f5632500f3e2ae98012b8d73e6 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Mon, 25 Oct 2021 16:19:11 -0400 Subject: [PATCH 068/752] cmd/go: add go work sync command Change-Id: I09b22f05035700e1ed90bd066ee8f77c3913286a Reviewed-on: https://go-review.googlesource.com/c/go/+/358540 Trust: Michael Matloob Run-TryBot: Michael Matloob TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/cmd/go/alldocs.go | 10 ++ src/cmd/go/internal/modload/buildlist.go | 13 +- src/cmd/go/internal/modload/init.go | 12 +- src/cmd/go/internal/modload/load.go | 21 +++- src/cmd/go/internal/workcmd/sync.go | 101 +++++++++++++++ src/cmd/go/internal/workcmd/work.go | 1 + src/cmd/go/testdata/script/work_sync.txt | 119 ++++++++++++++++++ .../work_sync_irrelevant_dependency.txt | 119 ++++++++++++++++++ .../script/work_sync_relevant_dependency.txt | 106 ++++++++++++++++ 9 files changed, 490 insertions(+), 12 deletions(-) create mode 100644 src/cmd/go/internal/workcmd/sync.go create mode 100644 src/cmd/go/testdata/script/work_sync.txt create mode 100644 src/cmd/go/testdata/script/work_sync_irrelevant_dependency.txt create mode 100644 src/cmd/go/testdata/script/work_sync_relevant_dependency.txt diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index d8ebc8d61d..81d2f7021d 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -1382,6 +1382,7 @@ // // edit edit go.work from tools or scripts // init initialize workspace file +// sync sync workspace build list to modules // // Use "go help work " for more information about a command. // @@ -1473,6 +1474,15 @@ // more information. // // +// Sync workspace build list to modules +// +// Usage: +// +// go work sync [moddirs] +// +// go work sync +// +// // Compile and run Go program // // Usage: diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go index 0cb4a88fcb..f4c1311af5 100644 --- a/src/cmd/go/internal/modload/buildlist.go +++ b/src/cmd/go/internal/modload/buildlist.go @@ -614,12 +614,13 @@ func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements, func updateWorkspaceRoots(ctx context.Context, rs *Requirements, add []module.Version) (*Requirements, error) { if len(add) != 0 { - // add should be empty in workspace mode because a non-empty add slice means - // that there are missing roots in the current pruning mode or that the - // pruning mode is being changed. But the pruning mode should always be - // 'workspace' in workspace mode and the set of roots in workspace mode is - // always complete because it's the set of workspace modules, which can't - // be edited by loading. + // add should be empty in workspace mode because workspace mode implies + // -mod=readonly, which in turn implies no new requirements. The code path + // that would result in add being non-empty returns an error before it + // reaches this point: The set of modules to add comes from + // resolveMissingImports, which in turn resolves each package by calling + // queryImport. But queryImport explicitly checks for -mod=readonly, and + // return an error. panic("add is not empty") } return rs, nil diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go index 512c9ebfbd..a6e49c6c71 100644 --- a/src/cmd/go/internal/modload/init.go +++ b/src/cmd/go/internal/modload/init.go @@ -73,6 +73,16 @@ var ( gopath string ) +// EnterModule resets MainModules and requirements to refer to just this one module. +func EnterModule(ctx context.Context, enterModroot string) { + MainModules = nil // reset MainModules + requirements = nil + workFilePath = "" // Force module mode + + modRoots = []string{enterModroot} + LoadModFile(ctx) +} + // Variable set in InitWorkfile var ( // Set to the path to the go.work file, or "" if workspace mode is disabled. @@ -1040,7 +1050,7 @@ func setDefaultBuildMod() { // to modload functions instead of relying on an implicit setting // based on command name. switch cfg.CmdName { - case "get", "mod download", "mod init", "mod tidy": + case "get", "mod download", "mod init", "mod tidy", "work sync": // These commands are intended to update go.mod and go.sum. cfg.BuildMod = "mod" return diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go index 83fcafead3..27bbfb7832 100644 --- a/src/cmd/go/internal/modload/load.go +++ b/src/cmd/go/internal/modload/load.go @@ -231,6 +231,9 @@ type PackageOpts struct { // SilenceUnmatchedWarnings suppresses the warnings normally emitted for // patterns that did not match any packages. SilenceUnmatchedWarnings bool + + // Resolve the query against this module. + MainModule module.Version } // LoadPackages identifies the set of packages matching the given patterns and @@ -256,7 +259,11 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma case m.IsLocal(): // Evaluate list of file system directories on first iteration. if m.Dirs == nil { - matchLocalDirs(ctx, m, rs) + matchModRoots := modRoots + if opts.MainModule != (module.Version{}) { + matchModRoots = []string{MainModules.ModRoot(opts.MainModule)} + } + matchLocalDirs(ctx, matchModRoots, m, rs) } // Make a copy of the directory list and translate to import paths. @@ -309,7 +316,11 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma // The initial roots are the packages in the main module. // loadFromRoots will expand that to "all". m.Errs = m.Errs[:0] - matchPackages(ctx, m, opts.Tags, omitStd, MainModules.Versions()) + matchModules := MainModules.Versions() + if opts.MainModule != (module.Version{}) { + matchModules = []module.Version{opts.MainModule} + } + matchPackages(ctx, m, opts.Tags, omitStd, matchModules) } else { // Starting with the packages in the main module, // enumerate the full list of "all". @@ -441,7 +452,7 @@ func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (ma // matchLocalDirs is like m.MatchDirs, but tries to avoid scanning directories // outside of the standard library and active modules. -func matchLocalDirs(ctx context.Context, m *search.Match, rs *Requirements) { +func matchLocalDirs(ctx context.Context, modRoots []string, m *search.Match, rs *Requirements) { if !m.IsLocal() { panic(fmt.Sprintf("internal error: resolveLocalDirs on non-local pattern %s", m.Pattern())) } @@ -460,8 +471,8 @@ func matchLocalDirs(ctx context.Context, m *search.Match, rs *Requirements) { modRoot := findModuleRoot(absDir) found := false - for _, mod := range MainModules.Versions() { - if MainModules.ModRoot(mod) == modRoot { + for _, mainModuleRoot := range modRoots { + if mainModuleRoot == modRoot { found = true break } diff --git a/src/cmd/go/internal/workcmd/sync.go b/src/cmd/go/internal/workcmd/sync.go new file mode 100644 index 0000000000..2723013bf8 --- /dev/null +++ b/src/cmd/go/internal/workcmd/sync.go @@ -0,0 +1,101 @@ +// 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. + +// go work sync + +package workcmd + +import ( + "cmd/go/internal/base" + "cmd/go/internal/imports" + "cmd/go/internal/modload" + "context" + + "golang.org/x/mod/module" +) + +var _ = modload.TODOWorkspaces("Add more documentation below. Though this is" + + "enough for those trying workspaces out, there should be more through" + + "documentation if the proposal is accepted and released.") + +var cmdSync = &base.Command{ + UsageLine: "go work sync [moddirs]", + Short: "sync workspace build list to modules", + Long: `go work sync`, + Run: runSync, +} + +func init() { + base.AddModCommonFlags(&cmdSync.Flag) + base.AddWorkfileFlag(&cmdSync.Flag) +} + +func runSync(ctx context.Context, cmd *base.Command, args []string) { + modload.InitWorkfile() + + modload.ForceUseModules = true + + workGraph := modload.LoadModGraph(ctx, "") + _ = workGraph + mustSelectFor := map[module.Version][]module.Version{} + + mms := modload.MainModules + + opts := modload.PackageOpts{ + Tags: imports.AnyTags(), + VendorModulesInGOROOTSrc: true, + ResolveMissingImports: false, + LoadTests: true, + AllowErrors: true, + SilencePackageErrors: true, + SilenceUnmatchedWarnings: true, + } + for _, m := range mms.Versions() { + opts.MainModule = m + _, pkgs := modload.LoadPackages(ctx, opts, "all") + opts.MainModule = module.Version{} // reset + + var ( + mustSelect []module.Version + inMustSelect = map[module.Version]bool{} + ) + for _, pkg := range pkgs { + if r := modload.PackageModule(pkg); r.Version != "" && !inMustSelect[r] { + // r has a known version, so force that version. + mustSelect = append(mustSelect, r) + inMustSelect[r] = true + } + } + module.Sort(mustSelect) // ensure determinism + mustSelectFor[m] = mustSelect + } + + for _, m := range mms.Versions() { + // Use EnterModule to reset the global state in modload to be in + // single-module mode using the modroot of m. + modload.EnterModule(ctx, mms.ModRoot(m)) + + // Edit the build list in the same way that 'go get' would if we + // requested the relevant module versions explicitly. + changed, err := modload.EditBuildList(ctx, nil, mustSelectFor[m]) + if err != nil { + base.Errorf("go: %v", err) + } + if !changed { + continue + } + + modload.LoadPackages(ctx, modload.PackageOpts{ + Tags: imports.AnyTags(), + VendorModulesInGOROOTSrc: true, + ResolveMissingImports: false, + LoadTests: true, + AllowErrors: true, + SilencePackageErrors: true, + Tidy: true, + SilenceUnmatchedWarnings: true, + }, "all") + modload.WriteGoMod(ctx) + } +} diff --git a/src/cmd/go/internal/workcmd/work.go b/src/cmd/go/internal/workcmd/work.go index 2e7f68b675..dc1164fb77 100644 --- a/src/cmd/go/internal/workcmd/work.go +++ b/src/cmd/go/internal/workcmd/work.go @@ -24,5 +24,6 @@ which workspaces are a part. Commands: []*base.Command{ cmdEdit, cmdInit, + cmdSync, }, } diff --git a/src/cmd/go/testdata/script/work_sync.txt b/src/cmd/go/testdata/script/work_sync.txt new file mode 100644 index 0000000000..16ad8c8cfa --- /dev/null +++ b/src/cmd/go/testdata/script/work_sync.txt @@ -0,0 +1,119 @@ +go work sync +cmp a/go.mod a/want_go.mod +cmp b/go.mod b/want_go.mod + +-- go.work -- +go 1.18 + +directory ( + ./a + ./b +) + +-- a/go.mod -- +go 1.18 + +module example.com/a + +require ( + example.com/p v1.0.0 + example.com/q v1.1.0 + example.com/r v1.0.0 +) + +replace ( + example.com/p => ../p + example.com/q => ../q + example.com/r => ../r +) +-- a/want_go.mod -- +go 1.18 + +module example.com/a + +require ( + example.com/p v1.1.0 + example.com/q v1.1.0 +) + +replace ( + example.com/p => ../p + example.com/q => ../q + example.com/r => ../r +) +-- a/a.go -- +package a + +import ( + "example.com/p" + "example.com/q" +) + +func Foo() { + p.P() + q.Q() +} +-- b/go.mod -- +go 1.18 + +module example.com/b + +require ( + example.com/p v1.1.0 + example.com/q v1.0.0 +) + +replace ( + example.com/p => ../p + example.com/q => ../q +) +-- b/want_go.mod -- +go 1.18 + +module example.com/b + +require ( + example.com/p v1.1.0 + example.com/q v1.1.0 +) + +replace ( + example.com/p => ../p + example.com/q => ../q +) +-- b/b.go -- +package b + +import ( + "example.com/p" + "example.com/q" +) + +func Foo() { + p.P() + q.Q() +} +-- p/go.mod -- +go 1.18 + +module example.com/p +-- p/p.go -- +package p + +func P() {} +-- q/go.mod -- +go 1.18 + +module example.com/q +-- q/q.go -- +package q + +func Q() {} +-- r/go.mod -- +go 1.18 + +module example.com/r +-- r/q.go -- +package r + +func R() {} \ No newline at end of file diff --git a/src/cmd/go/testdata/script/work_sync_irrelevant_dependency.txt b/src/cmd/go/testdata/script/work_sync_irrelevant_dependency.txt new file mode 100644 index 0000000000..bbb8579b4f --- /dev/null +++ b/src/cmd/go/testdata/script/work_sync_irrelevant_dependency.txt @@ -0,0 +1,119 @@ +# Test of go work sync in a workspace in which some dependency needed by `a` +# appears at a lower version in the build list of `b`, but is not needed at all +# by `b` (so it should not be upgraded within b). +# +# a -> p 1.1 +# b -> q 1.0 -(through a test dependency)-> p 1.0 +go work sync +cmp a/go.mod a/want_go.mod +cmp b/go.mod b/want_go.mod + +-- go.work -- +go 1.18 + +directory ( + ./a + ./b +) + +-- a/go.mod -- +go 1.18 + +module example.com/a + +require ( + example.com/p v1.1.0 +) + +replace ( + example.com/p => ../p +) +-- a/want_go.mod -- +go 1.18 + +module example.com/a + +require ( + example.com/p v1.1.0 +) + +replace ( + example.com/p => ../p +) +-- a/a.go -- +package a + +import ( + "example.com/p" +) + +func Foo() { + p.P() +} +-- b/go.mod -- +go 1.18 + +module example.com/b + +require ( + example.com/q v1.0.0 +) + +replace ( + example.com/q => ../q +) +-- b/want_go.mod -- +go 1.18 + +module example.com/b + +require ( + example.com/q v1.0.0 +) + +replace ( + example.com/q => ../q +) +-- b/b.go -- +package b + +import ( + "example.com/q" +) + +func Foo() { + q.Q() +} +-- p/go.mod -- +go 1.18 + +module example.com/p +-- p/p.go -- +package p + +func P() {} +-- q/go.mod -- +go 1.18 + +module example.com/q + +require ( + example.com/p v1.0.0 +) + +replace ( + example.com/p => ../p +) +-- q/q.go -- +package q + +func Q() { +} +-- q/q_test.go -- +package q + +import example.com/p + +func TestQ(t *testing.T) { + p.P() +} \ No newline at end of file diff --git a/src/cmd/go/testdata/script/work_sync_relevant_dependency.txt b/src/cmd/go/testdata/script/work_sync_relevant_dependency.txt new file mode 100644 index 0000000000..e95ac26707 --- /dev/null +++ b/src/cmd/go/testdata/script/work_sync_relevant_dependency.txt @@ -0,0 +1,106 @@ +# Test of go work sync in a workspace in which some dependency in the build +# list of 'b' (but not otherwise needed by `b`, so not seen when lazy loading +# occurs) actually is relevant to `a`. +# +# a -> p 1.0 +# b -> q 1.1 -> p 1.1 +go work sync +cmp a/go.mod a/want_go.mod +cmp b/go.mod b/want_go.mod + +-- go.work -- +go 1.18 + +directory ( + ./a + ./b +) + +-- a/go.mod -- +go 1.18 + +module example.com/a + +require ( + example.com/p v1.0.0 +) + +replace ( + example.com/p => ../p +) +-- a/want_go.mod -- +go 1.18 + +module example.com/a + +require example.com/p v1.1.0 + +replace example.com/p => ../p +-- a/a.go -- +package a + +import ( + "example.com/p" +) + +func Foo() { + p.P() +} +-- b/go.mod -- +go 1.18 + +module example.com/b + +require ( + example.com/q v1.1.0 +) + +replace ( + example.com/q => ../q +) +-- b/want_go.mod -- +go 1.18 + +module example.com/b + +require ( + example.com/q v1.1.0 +) + +replace ( + example.com/q => ../q +) +-- b/b.go -- +package b + +import ( + "example.com/q" +) + +func Foo() { + q.Q() +} +-- p/go.mod -- +go 1.18 + +module example.com/p +-- p/p.go -- +package p + +func P() {} +-- q/go.mod -- +go 1.18 + +module example.com/q + +require example.com/p v1.1.0 + +replace example.com/p => ../p +-- q/q.go -- +package q + +import example.com/p + +func Q() { + p.P() +} From 578ada410de8065dbca46bca08a5993d1307f423 Mon Sep 17 00:00:00 2001 From: Illirgway Date: Mon, 5 Jul 2021 11:22:03 +0000 Subject: [PATCH 069/752] mime: keep parsing after trailing semicolon Fixes #46323 Change-Id: Ibd624b1aaa15f907b7eb965b4eaec61018a45486 GitHub-Last-Rev: 7ad670b088144a2a09860dd990c53dea75c0d40f GitHub-Pull-Request: golang/go#47029 Reviewed-on: https://go-review.googlesource.com/c/go/+/332509 Trust: Ian Lance Taylor Trust: Damien Neil Reviewed-by: Damien Neil --- src/mime/mediatype.go | 2 +- src/mime/mediatype_test.go | 17 ++++++++++++++--- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/src/mime/mediatype.go b/src/mime/mediatype.go index 9456570cf1..6c1b095065 100644 --- a/src/mime/mediatype.go +++ b/src/mime/mediatype.go @@ -163,7 +163,7 @@ func ParseMediaType(v string) (mediatype string, params map[string]string, err e if strings.TrimSpace(rest) == ";" { // Ignore trailing semicolons. // Not an error. - return + break } // Parse error. return mediatype, nil, ErrInvalidMediaParameter diff --git a/src/mime/mediatype_test.go b/src/mime/mediatype_test.go index e91ff38d68..079c080db7 100644 --- a/src/mime/mediatype_test.go +++ b/src/mime/mediatype_test.go @@ -42,7 +42,7 @@ func TestConsumeValue(t *testing.T) { {`"My \" value"end`, "My \" value", "end"}, {`"\" rest`, "", `"\" rest`}, {`"C:\dev\go\robots.txt"`, `C:\dev\go\robots.txt`, ""}, - {`"C:\新建文件件\中文第二次测试.mp4"`, `C:\新建文件件\中文第二次测试.mp4`, ""}, + {`"C:\新建文件夹\中文第二次测试.mp4"`, `C:\新建文件夹\中文第二次测试.mp4`, ""}, } for _, test := range tests { value, rest := consumeValue(test[0]) @@ -394,10 +394,21 @@ func TestParseMediaType(t *testing.T) { // Empty string used to be mishandled. {`foo; bar=""`, "foo", m("bar", "")}, - // Microsoft browers in intranet mode do not think they need to escape \ in file name. + // Microsoft browsers in intranet mode do not think they need to escape \ in file name. {`form-data; name="file"; filename="C:\dev\go\robots.txt"`, "form-data", m("name", "file", "filename", `C:\dev\go\robots.txt`)}, - {`form-data; name="file"; filename="C:\新建文件件\中文第二次测试.mp4"`, "form-data", m("name", "file", "filename", `C:\新建文件件\中文第二次测试.mp4`)}, + {`form-data; name="file"; filename="C:\新建文件夹\中文第二次测试.mp4"`, "form-data", m("name", "file", "filename", `C:\新建文件夹\中文第二次测试.mp4`)}, + + // issue #46323 (https://github.com/golang/go/issues/46323) + { + // example from rfc2231-p.3 (https://datatracker.ietf.org/doc/html/rfc2231) + `message/external-body; access-type=URL; + URL*0="ftp://"; + URL*1="cs.utk.edu/pub/moore/bulk-mailer/bulk-mailer.tar";`, // <-- trailing semicolon + `message/external-body`, + m("access-type", "URL", "url", "ftp://cs.utk.edu/pub/moore/bulk-mailer/bulk-mailer.tar"), + }, } + for _, test := range tests { mt, params, err := ParseMediaType(test.in) if err != nil { From f5f94340910421baea624ca08e5f51343515cae8 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 9 Nov 2021 16:41:01 -0500 Subject: [PATCH 070/752] go/types: remove most asX converters (cleanup) This is a port of CL 362118 to go/types, which is itself a roll-forward of CL 362254, containing a bugfix. Change-Id: I20067c7adf56bf64fe9ad080d998a7aefbdc1053 Reviewed-on: https://go-review.googlesource.com/c/go/+/362617 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/types/assignments.go | 2 +- src/go/types/builtins.go | 8 ++++---- src/go/types/call.go | 2 +- src/go/types/context.go | 3 +++ src/go/types/conversions.go | 21 ++++++++++---------- src/go/types/expr.go | 6 +++--- src/go/types/index.go | 8 ++++---- src/go/types/lookup.go | 9 ++++----- src/go/types/predicates.go | 5 +++-- src/go/types/sizes.go | 2 +- src/go/types/type.go | 39 +------------------------------------ src/go/types/typestring.go | 2 +- src/go/types/typexpr.go | 2 +- 13 files changed, 38 insertions(+), 71 deletions(-) diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go index 2810133a1f..923bd43b49 100644 --- a/src/go/types/assignments.go +++ b/src/go/types/assignments.go @@ -71,7 +71,7 @@ func (check *Checker) assignment(x *operand, T Type, context string) { } // A generic (non-instantiated) function value cannot be assigned to a variable. - if sig := asSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 { + if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 { check.errorf(x, _Todo, "cannot use generic function %s without instantiation in %s", x, context) } diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go index 577a71fd60..4d3ff26b14 100644 --- a/src/go/types/builtins.go +++ b/src/go/types/builtins.go @@ -299,7 +299,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b // (applyTypeFunc never calls f with a type parameter) f := func(typ Type) Type { assert(asTypeParam(typ) == nil) - if t := asBasic(typ); t != nil { + if t, _ := under(typ).(*Basic); t != nil { switch t.kind { case Float32: return Typ[Complex64] @@ -423,7 +423,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b // (applyTypeFunc never calls f with a type parameter) f := func(typ Type) Type { assert(asTypeParam(typ) == nil) - if t := asBasic(typ); t != nil { + if t, _ := under(typ).(*Basic); t != nil { switch t.kind { case Complex64: return Typ[Float32] @@ -713,7 +713,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b return } - typ := asPointer(x.typ) + typ, _ := under(x.typ).(*Pointer) if typ == nil { check.invalidArg(x, _InvalidUnsafeSlice, "%s is not a pointer", x) return @@ -893,7 +893,7 @@ func makeSig(res Type, args ...Type) *Signature { // otherwise it returns typ. func arrayPtrDeref(typ Type) Type { if p, ok := typ.(*Pointer); ok { - if a := asArray(p.base); a != nil { + if a, _ := under(p.base).(*Array); a != nil { return a } } diff --git a/src/go/types/call.go b/src/go/types/call.go index a7024f5f9c..890a2c7c5a 100644 --- a/src/go/types/call.go +++ b/src/go/types/call.go @@ -141,7 +141,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind { check.errorf(call.Args[0], _BadDotDotDotSyntax, "invalid use of ... in conversion to %s", T) break } - if t := asInterface(T); t != nil { + if t, _ := under(T).(*Interface); t != nil { if !t.IsMethodSet() { check.errorf(call, _Todo, "cannot use interface %s in conversion (contains specific type constraints or is comparable)", T) break diff --git a/src/go/types/context.go b/src/go/types/context.go index 99baad8d0f..7caf631b57 100644 --- a/src/go/types/context.go +++ b/src/go/types/context.go @@ -40,6 +40,9 @@ func (ctxt *Context) typeHash(typ Type, targs []Type) string { var buf bytes.Buffer h := newTypeHasher(&buf, ctxt) + // Caution: don't use asNamed here. TypeHash may be called for unexpanded + // types. We don't need anything other than name and type arguments below, + // which do not require expansion. if named, _ := typ.(*Named); named != nil && len(targs) > 0 { // Don't use WriteType because we need to use the provided targs // and not any targs that might already be with the *Named type. diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go index f73e6a0964..26bebd4ade 100644 --- a/src/go/types/conversions.go +++ b/src/go/types/conversions.go @@ -17,7 +17,7 @@ func (check *Checker) conversion(x *operand, T Type) { constArg := x.mode == constant_ constConvertibleTo := func(T Type, val *constant.Value) bool { - switch t := asBasic(T); { + switch t, _ := under(T).(*Basic); { case t == nil: // nothing to do case representableConst(x.val, check, t, val): @@ -170,9 +170,9 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { // "V is a slice, T is a pointer-to-array type, // and the slice and array types have identical element types." - if s := asSlice(V); s != nil { - if p := asPointer(T); p != nil { - if a := asArray(p.Elem()); a != nil { + if s, _ := under(V).(*Slice); s != nil { + if p, _ := under(T).(*Pointer); p != nil { + if a, _ := under(p.Elem()).(*Array); a != nil { if Identical(s.Elem(), a.Elem()) { if check == nil || check.allowVersion(check.pkg, 1, 17) { return true @@ -254,26 +254,27 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { // use the toT convenience converters in the predicates below. func isUintptr(typ Type) bool { - t := asBasic(typ) + t, _ := under(typ).(*Basic) return t != nil && t.kind == Uintptr } func isUnsafePointer(typ Type) bool { - // TODO(gri): Is this asBasic(typ) instead of typ.(*Basic) correct? + // TODO(gri): Is this under(typ).(*Basic) instead of typ.(*Basic) correct? // (The former calls under(), while the latter doesn't.) // The spec does not say so, but gc claims it is. See also // issue 6326. - t := asBasic(typ) + t, _ := under(typ).(*Basic) return t != nil && t.kind == UnsafePointer } func isPointer(typ Type) bool { - return asPointer(typ) != nil + _, ok := under(typ).(*Pointer) + return ok } func isBytesOrRunes(typ Type) bool { - if s := asSlice(typ); s != nil { - t := asBasic(s.elem) + if s, _ := under(typ).(*Slice); s != nil { + t, _ := under(s.elem).(*Basic) return t != nil && (t.kind == Byte || t.kind == Rune) } return false diff --git a/src/go/types/expr.go b/src/go/types/expr.go index 224185b6a9..138eb2f521 100644 --- a/src/go/types/expr.go +++ b/src/go/types/expr.go @@ -103,7 +103,7 @@ func (check *Checker) overflow(x *operand, op token.Token, opPos token.Pos) { // x.typ cannot be a type parameter (type // parameters cannot be constant types). if isTyped(x.typ) { - check.representable(x, asBasic(x.typ)) + check.representable(x, under(x.typ).(*Basic)) return } @@ -556,7 +556,7 @@ func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) { // If the new type is not final and still untyped, just // update the recorded type. if !final && isUntyped(typ) { - old.typ = asBasic(typ) + old.typ = under(typ).(*Basic) check.untyped[x] = old return } @@ -1362,7 +1362,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind { duplicate := false // if the key is of interface type, the type is also significant when checking for duplicates xkey := keyVal(x.val) - if asInterface(utyp.key) != nil { + if IsInterface(utyp.key) { for _, vtyp := range visited[xkey] { if Identical(vtyp, x.typ) { duplicate = true diff --git a/src/go/types/index.go b/src/go/types/index.go index 7ef8231f0b..cd19f50627 100644 --- a/src/go/types/index.go +++ b/src/go/types/index.go @@ -35,7 +35,7 @@ func (check *Checker) indexExpr(x *operand, e *typeparams.IndexExpr) (isFuncInst return false case value: - if sig := asSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 { + if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 { // function instantiation return true } @@ -73,7 +73,7 @@ func (check *Checker) indexExpr(x *operand, e *typeparams.IndexExpr) (isFuncInst x.typ = typ.elem case *Pointer: - if typ := asArray(typ.base); typ != nil { + if typ, _ := under(typ.base).(*Array); typ != nil { valid = true length = typ.len x.mode = variable @@ -121,7 +121,7 @@ func (check *Checker) indexExpr(x *operand, e *typeparams.IndexExpr) (isFuncInst mode = value } case *Pointer: - if t := asArray(t.base); t != nil { + if t, _ := under(t.base).(*Array); t != nil { l = t.len e = t.elem } @@ -246,7 +246,7 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) { x.typ = &Slice{elem: u.elem} case *Pointer: - if u := asArray(u.base); u != nil { + if u, _ := under(u.base).(*Array); u != nil { valid = true length = u.len x.typ = &Slice{elem: u.elem} diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go index afb1215af2..aae6fa206d 100644 --- a/src/go/types/lookup.go +++ b/src/go/types/lookup.go @@ -122,7 +122,6 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o seen[named] = true // look for a matching attached method - named.resolve(nil) if i, m := lookupMethod(named.methods, pkg, name); m != nil { // potential match // caution: method may not have a proper signature yet @@ -302,7 +301,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, return } - if ityp := asInterface(V); ityp != nil { + if ityp, _ := under(V).(*Interface); ityp != nil { // TODO(gri) the methods are sorted - could do this more efficiently for _, m := range T.typeSet().methods { _, f := ityp.typeSet().LookupMethod(m.pkg, m.name) @@ -400,7 +399,7 @@ func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Fun // no static check is required if T is an interface // spec: "If T is an interface type, x.(T) asserts that the // dynamic type of x implements the interface T." - if asInterface(T) != nil && !forceStrict { + if IsInterface(T) && !forceStrict { return } return check.missingMethod(T, V, false) @@ -418,8 +417,8 @@ func deref(typ Type) (Type, bool) { // derefStructPtr dereferences typ if it is a (named or unnamed) pointer to a // (named or unnamed) struct and returns its base. Otherwise it returns typ. func derefStructPtr(typ Type) Type { - if p := asPointer(typ); p != nil { - if asStruct(p.base) != nil { + if p, _ := under(typ).(*Pointer); p != nil { + if _, ok := under(p.base).(*Struct); ok { return p.base } } diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go index 622c773126..e8689a12cc 100644 --- a/src/go/types/predicates.go +++ b/src/go/types/predicates.go @@ -74,7 +74,7 @@ func hasName(t Type) bool { // are not fully set up. func isTyped(t Type) bool { // isTyped is called with types that are not fully - // set up. Must not call asBasic()! + // set up. Must not call under()! b, _ := t.(*Basic) return b == nil || b.info&IsUntyped == 0 } @@ -86,7 +86,8 @@ func isUntyped(t Type) bool { // IsInterface reports whether t is an interface type. func IsInterface(t Type) bool { - return asInterface(t) != nil + _, ok := under(t).(*Interface) + return ok } // isTypeParam reports whether t is a type parameter. diff --git a/src/go/types/sizes.go b/src/go/types/sizes.go index 4c85bfe057..9a119138dd 100644 --- a/src/go/types/sizes.go +++ b/src/go/types/sizes.go @@ -243,7 +243,7 @@ func (conf *Config) offsetsof(T *Struct) []int64 { func (conf *Config) offsetof(typ Type, index []int) int64 { var o int64 for _, i := range index { - s := asStruct(typ) + s := under(typ).(*Struct) o += conf.offsetsof(s)[i] typ = s.fields[i].typ } diff --git a/src/go/types/type.go b/src/go/types/type.go index 4247f52c31..b1e2bda4cd 100644 --- a/src/go/types/type.go +++ b/src/go/types/type.go @@ -27,45 +27,8 @@ func under(t Type) Type { return t } -// Convenience converters - -func asBasic(t Type) *Basic { - op, _ := under(t).(*Basic) - return op -} - -func asArray(t Type) *Array { - op, _ := under(t).(*Array) - return op -} - -func asSlice(t Type) *Slice { - op, _ := under(t).(*Slice) - return op -} - -func asStruct(t Type) *Struct { - op, _ := under(t).(*Struct) - return op -} - -func asPointer(t Type) *Pointer { - op, _ := under(t).(*Pointer) - return op -} - -func asSignature(t Type) *Signature { - op, _ := under(t).(*Signature) - return op -} - -func asInterface(t Type) *Interface { - op, _ := under(t).(*Interface) - return op -} - // If the argument to asNamed, or asTypeParam is of the respective type -// (possibly after expanding resolving a *Named type), these methods return that type. +// (possibly after resolving a *Named type), these methods return that type. // Otherwise the result is nil. func asNamed(t Type) *Named { diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go index e138af6488..c448d25458 100644 --- a/src/go/types/typestring.go +++ b/src/go/types/typestring.go @@ -362,7 +362,7 @@ func (w *typeWriter) tuple(tup *Tuple, variadic bool) { } else { // special case: // append(s, "foo"...) leads to signature func([]byte, string...) - if t := asBasic(typ); t == nil || t.kind != String { + if t, _ := under(typ).(*Basic); t == nil || t.kind != String { w.error("expected string type") continue } diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go index cc2bd62209..12e0f968c2 100644 --- a/src/go/types/typexpr.go +++ b/src/go/types/typexpr.go @@ -145,7 +145,7 @@ func (check *Checker) varType(e ast.Expr) Type { // are in the middle of type-checking parameter declarations that might belong to // interface methods. Delay this check to the end of type-checking. check.later(func() { - if t := asInterface(typ); t != nil { + if t, _ := under(typ).(*Interface); t != nil { tset := computeInterfaceTypeSet(check, e.Pos(), t) // TODO(gri) is this the correct position? if !tset.IsMethodSet() { if tset.comparable { From ec86bb52ba88ff18a88719ee0f9244315fa81154 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 9 Nov 2021 18:40:38 -0500 Subject: [PATCH 071/752] go/types: rename Checker.cycle to Checker.validCycle This is a clean port of CL 362336 to go/types. Change-Id: Iafeae7024fbb2872b07748affcea9676324ea59e Reviewed-on: https://go-review.googlesource.com/c/go/+/362755 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/types/decl.go | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/src/go/types/decl.go b/src/go/types/decl.go index 8d255dcf3d..eccdec9a03 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -123,7 +123,7 @@ func (check *Checker) objDecl(obj Object, def *Named) { fallthrough case grey: - // We have a cycle. + // We have a (possibly invalid) cycle. // In the existing code, this is marked by a non-nil type // for the object except for constants and variables whose // type may be non-nil (known), or nil if it depends on the @@ -135,17 +135,17 @@ func (check *Checker) objDecl(obj Object, def *Named) { // order code. switch obj := obj.(type) { case *Const: - if check.cycle(obj) || obj.typ == nil { + if !check.validCycle(obj) || obj.typ == nil { obj.typ = Typ[Invalid] } case *Var: - if check.cycle(obj) || obj.typ == nil { + if !check.validCycle(obj) || obj.typ == nil { obj.typ = Typ[Invalid] } case *TypeName: - if check.cycle(obj) { + if !check.validCycle(obj) { // break cycle // (without this, calling underlying() // below may lead to an endless loop @@ -155,7 +155,7 @@ func (check *Checker) objDecl(obj Object, def *Named) { } case *Func: - if check.cycle(obj) { + if !check.validCycle(obj) { // Don't set obj.typ to Typ[Invalid] here // because plenty of code type-asserts that // functions have a *Signature type. Grey @@ -209,9 +209,9 @@ func (check *Checker) objDecl(obj Object, def *Named) { } } -// cycle checks if the cycle starting with obj is valid and +// validCycle checks if the cycle starting with obj is valid and // reports an error if it is not. -func (check *Checker) cycle(obj Object) (isCycle bool) { +func (check *Checker) validCycle(obj Object) (valid bool) { // The object map contains the package scope objects and the non-interface methods. if debug { info := check.objMap[obj] @@ -263,7 +263,7 @@ func (check *Checker) cycle(obj Object) (isCycle bool) { check.trace(obj.Pos(), "## cycle detected: objPath = %s->%s (len = %d)", pathString(cycle), obj.Name(), len(cycle)) check.trace(obj.Pos(), "## cycle contains: %d values, %d type definitions", nval, ndef) defer func() { - if isCycle { + if !valid { check.trace(obj.Pos(), "=> error: cycle is invalid") } }() @@ -273,19 +273,18 @@ func (check *Checker) cycle(obj Object) (isCycle bool) { // ignore them here because they are reported via the initialization // cycle check. if nval == len(cycle) { - return false + return true } // A cycle involving only types (and possibly functions) must have at least // one type definition to be permitted: If there is no type definition, we // have a sequence of alias type names which will expand ad infinitum. if nval == 0 && ndef > 0 { - return false // cycle is permitted + return true } check.cycleError(cycle) - - return true + return false } type typeInfo uint From 318c024b498621932ace08736c38a51fe5519a63 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 8 Nov 2021 20:17:22 -0800 Subject: [PATCH 072/752] cmd/compile/internal/types2: rename Checker.cycle to Checker.validCycle Also, invert the boolean result. This matches Checker.validType; it's also easier to understand. Preparation for the next CL which detects cycles through type parameter lists. Change-Id: I00a75d2359ca20827c9bf406945508716c826fc4 Reviewed-on: https://go-review.googlesource.com/c/go/+/362336 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/decl.go | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-) diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index 5219f7e7c5..94cbdd2b90 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -124,7 +124,7 @@ func (check *Checker) objDecl(obj Object, def *Named) { fallthrough case grey: - // We have a cycle. + // We have a (possibly invalid) cycle. // In the existing code, this is marked by a non-nil type // for the object except for constants and variables whose // type may be non-nil (known), or nil if it depends on the @@ -136,17 +136,17 @@ func (check *Checker) objDecl(obj Object, def *Named) { // order code. switch obj := obj.(type) { case *Const: - if check.cycle(obj) || obj.typ == nil { + if !check.validCycle(obj) || obj.typ == nil { obj.typ = Typ[Invalid] } case *Var: - if check.cycle(obj) || obj.typ == nil { + if !check.validCycle(obj) || obj.typ == nil { obj.typ = Typ[Invalid] } case *TypeName: - if check.cycle(obj) { + if !check.validCycle(obj) { // break cycle // (without this, calling underlying() // below may lead to an endless loop @@ -156,7 +156,7 @@ func (check *Checker) objDecl(obj Object, def *Named) { } case *Func: - if check.cycle(obj) { + if !check.validCycle(obj) { // Don't set obj.typ to Typ[Invalid] here // because plenty of code type-asserts that // functions have a *Signature type. Grey @@ -210,9 +210,9 @@ func (check *Checker) objDecl(obj Object, def *Named) { } } -// cycle checks if the cycle starting with obj is valid and +// validCycle reports whether the cycle starting with obj is valid and // reports an error if it is not. -func (check *Checker) cycle(obj Object) (isCycle bool) { +func (check *Checker) validCycle(obj Object) (valid bool) { // The object map contains the package scope objects and the non-interface methods. if debug { info := check.objMap[obj] @@ -264,7 +264,7 @@ func (check *Checker) cycle(obj Object) (isCycle bool) { check.trace(obj.Pos(), "## cycle detected: objPath = %s->%s (len = %d)", pathString(cycle), obj.Name(), len(cycle)) check.trace(obj.Pos(), "## cycle contains: %d values, %d type definitions", nval, ndef) defer func() { - if isCycle { + if !valid { check.trace(obj.Pos(), "=> error: cycle is invalid") } }() @@ -274,19 +274,18 @@ func (check *Checker) cycle(obj Object) (isCycle bool) { // ignore them here because they are reported via the initialization // cycle check. if nval == len(cycle) { - return false + return true } // A cycle involving only types (and possibly functions) must have at least // one type definition to be permitted: If there is no type definition, we // have a sequence of alias type names which will expand ad infinitum. if nval == 0 && ndef > 0 { - return false // cycle is permitted + return true } check.cycleError(cycle) - - return true + return false } type typeInfo uint From cc14fcac2bc1d452841336b9aeee3b1d47880f37 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 8 Nov 2021 16:09:11 -0800 Subject: [PATCH 073/752] cmd/compile/internal/types2: disallow type cycles through type parameter lists If we reach a generic type that is part of a cycle and we are in a type parameter list, we have a cycle through a type parameter list, which is invalid. Fixes #49439. Change-Id: Ia6cf97e1748ca0c0e61c02841202050091365b0b Reviewed-on: https://go-review.googlesource.com/c/go/+/361922 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/check.go | 1 + src/cmd/compile/internal/types2/decl.go | 57 ++++++++++++++----- .../types2/testdata/fixedbugs/issue45550.go2 | 4 +- .../types2/testdata/fixedbugs/issue46461.go2 | 6 +- .../types2/testdata/fixedbugs/issue47796.go2 | 14 ++--- .../types2/testdata/fixedbugs/issue48529.go2 | 2 +- .../types2/testdata/fixedbugs/issue49439.go2 | 26 +++++++++ test/typeparam/issue46461.go | 4 +- test/typeparam/issue46461b.dir/a.go | 2 +- test/typeparam/issue46461b.dir/b.go | 4 +- test/typeparam/issue48280.dir/a.go | 2 +- test/typeparam/issue48306.dir/a.go | 2 +- 12 files changed, 91 insertions(+), 33 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue49439.go2 diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go index b9a76a8990..247bb5a649 100644 --- a/src/cmd/compile/internal/types2/check.go +++ b/src/cmd/compile/internal/types2/check.go @@ -46,6 +46,7 @@ type context struct { pos syntax.Pos // if valid, identifiers are looked up as if at position pos (used by Eval) iota constant.Value // value of iota in a constant declaration; nil otherwise errpos syntax.Pos // if valid, identifier position of a constant with inherited initializer + inTParamList bool // set if inside a type parameter list sig *Signature // function signature if inside a function; nil otherwise isPanic map[*syntax.CallExpr]bool // set of panic call expressions (used for termination check) hasLabel bool // set if a function makes use of labels (only ~1% of functions); unused outside functions diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index 94cbdd2b90..9b643fac99 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -228,13 +228,23 @@ func (check *Checker) validCycle(obj Object) (valid bool) { assert(obj.color() >= grey) start := obj.color() - grey // index of obj in objPath cycle := check.objPath[start:] - nval := 0 // number of (constant or variable) values in the cycle - ndef := 0 // number of type definitions in the cycle + tparCycle := false // if set, the cycle is through a type parameter list + nval := 0 // number of (constant or variable) values in the cycle; valid if !generic + ndef := 0 // number of type definitions in the cycle; valid if !generic +loop: for _, obj := range cycle { switch obj := obj.(type) { case *Const, *Var: nval++ case *TypeName: + // If we reach a generic type that is part of a cycle + // and we are in a type parameter list, we have a cycle + // through a type parameter list, which is invalid. + if check.inTParamList && isGeneric(obj.typ) { + tparCycle = true + break loop + } + // Determine if the type name is an alias or not. For // package-level objects, use the object map which // provides syntactic information (which doesn't rely @@ -262,7 +272,11 @@ func (check *Checker) validCycle(obj Object) (valid bool) { if check.conf.Trace { check.trace(obj.Pos(), "## cycle detected: objPath = %s->%s (len = %d)", pathString(cycle), obj.Name(), len(cycle)) - check.trace(obj.Pos(), "## cycle contains: %d values, %d type definitions", nval, ndef) + if tparCycle { + check.trace(obj.Pos(), "## cycle contains: generic type in a type parameter list") + } else { + check.trace(obj.Pos(), "## cycle contains: %d values, %d type definitions", nval, ndef) + } defer func() { if !valid { check.trace(obj.Pos(), "=> error: cycle is invalid") @@ -270,18 +284,20 @@ func (check *Checker) validCycle(obj Object) (valid bool) { }() } - // A cycle involving only constants and variables is invalid but we - // ignore them here because they are reported via the initialization - // cycle check. - if nval == len(cycle) { - return true - } + if !tparCycle { + // A cycle involving only constants and variables is invalid but we + // ignore them here because they are reported via the initialization + // cycle check. + if nval == len(cycle) { + return true + } - // A cycle involving only types (and possibly functions) must have at least - // one type definition to be permitted: If there is no type definition, we - // have a sequence of alias type names which will expand ad infinitum. - if nval == 0 && ndef > 0 { - return true + // A cycle involving only types (and possibly functions) must have at least + // one type definition to be permitted: If there is no type definition, we + // have a sequence of alias type names which will expand ad infinitum. + if nval == 0 && ndef > 0 { + return true + } } check.cycleError(cycle) @@ -624,6 +640,19 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list []*syntax.Fiel // Example: type T[P T[P]] interface{} *dst = bindTParams(tparams) + // Signal to cycle detection that we are in a type parameter list. + // We can only be inside one type parameter list at any given time: + // function closures may appear inside a type parameter list but they + // cannot be generic, and their bodies are processed in delayed and + // sequential fashion. Note that with each new declaration, we save + // the existing context and restore it when done; thus inTParamList + // is true exactly only when we are in a specific type parameter list. + assert(!check.inTParamList) + check.inTParamList = true + defer func() { + check.inTParamList = false + }() + // Keep track of bounds for later validation. var bound Type var bounds []Type diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45550.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45550.go2 index c3e9e34b87..3eeaca0957 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45550.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45550.go2 @@ -4,7 +4,7 @@ package p -type Builder[T interface{ struct{ Builder[T] } }] struct{} +type Builder /* ERROR illegal cycle */ [T interface{ struct{ Builder[T] } }] struct{} type myBuilder struct { - Builder[myBuilder /* ERROR myBuilder does not satisfy */] + Builder[myBuilder] } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue46461.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue46461.go2 index 8bf31090b8..4432402a30 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue46461.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue46461.go2 @@ -5,16 +5,16 @@ package p // test case 1 -type T[U interface{ M() T[U] }] int +type T /* ERROR illegal cycle */ [U interface{ M() T[U] }] int type X int func (X) M() T[X] { return 0 } // test case 2 -type A[T interface{ A[T] }] interface{} +type A /* ERROR illegal cycle */ [T interface{ A[T] }] interface{} // test case 3 -type A2[U interface{ A2[U] }] interface{ M() A2[U] } +type A2 /* ERROR illegal cycle */ [U interface{ A2[U] }] interface{ M() A2[U] } type I interface{ A2[I]; M() A2[I] } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47796.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47796.go2 index 9c10683e22..6667ba4fec 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47796.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47796.go2 @@ -6,16 +6,16 @@ package p // parameterized types with self-recursive constraints type ( - T1[P T1[P]] interface{} - T2[P, Q T2[P, Q]] interface{} + T1 /* ERROR illegal cycle */ [P T1[P]] interface{} + T2 /* ERROR illegal cycle */ [P, Q T2[P, Q]] interface{} T3[P T2[P, Q], Q interface{ ~string }] interface{} - T4a[P T4a[P]] interface{ ~int } - T4b[P T4b[int]] interface{ ~int } - T4c[P T4c[string /* ERROR string does not satisfy T4c\[string\] */]] interface{ ~int } + T4a /* ERROR illegal cycle */ [P T4a[P]] interface{ ~int } + T4b /* ERROR illegal cycle */ [P T4b[int]] interface{ ~int } + T4c /* ERROR illegal cycle */ [P T4c[string]] interface{ ~int } // mutually recursive constraints - T5[P T6[P]] interface{ int } + T5 /* ERROR illegal cycle */ [P T6[P]] interface{ int } T6[P T5[P]] interface{ int } ) @@ -28,6 +28,6 @@ var ( // test case from issue -type Eq[a Eq[a]] interface { +type Eq /* ERROR illegal cycle */ [a Eq[a]] interface { Equal(that a) bool } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48529.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48529.go2 index 4f92dec7fe..a3653fa19c 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48529.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48529.go2 @@ -4,7 +4,7 @@ package p -type T[U interface{ M() T /* ERROR "got 2 arguments but 1 type parameters" */ [U, int] }] int +type T /* ERROR illegal cycle */ [U interface{ M() T[U, int] }] int type X int diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49439.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49439.go2 new file mode 100644 index 0000000000..6cc838b3b3 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49439.go2 @@ -0,0 +1,26 @@ +// 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 "unsafe" + +type T0 /* ERROR illegal cycle */ [P T0[P]] struct{} + +type T1 /* ERROR illegal cycle */ [P T2[P]] struct{} +type T2[P T1[P]] struct{} + +type T3 /* ERROR illegal cycle */ [P interface{ ~struct{ f T3[int] } }] struct{} + +// valid cycle in M +type N[P M[P]] struct{} +type M[Q any] struct { F *M[Q] } + +// "crazy" case +type TC[P [unsafe.Sizeof(func() { + type T [P [unsafe.Sizeof(func(){})]byte] struct{} +})]byte] struct{} + +// test case from issue +type X /* ERROR illegal cycle */ [T any, PT X[T]] interface{} diff --git a/test/typeparam/issue46461.go b/test/typeparam/issue46461.go index 2c54a6ba28..8fdec1c073 100644 --- a/test/typeparam/issue46461.go +++ b/test/typeparam/issue46461.go @@ -1,4 +1,4 @@ -// compile -G=3 +// errorcheck -G=3 // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style @@ -6,7 +6,7 @@ package p -type T[U interface{ M() T[U] }] int +type T[U interface{ M() T[U] }] int // ERROR "invalid recursive type T" type X int diff --git a/test/typeparam/issue46461b.dir/a.go b/test/typeparam/issue46461b.dir/a.go index 0d53b3e204..fcb414266d 100644 --- a/test/typeparam/issue46461b.dir/a.go +++ b/test/typeparam/issue46461b.dir/a.go @@ -4,4 +4,4 @@ package a -type T[U interface{ M() T[U] }] int +type T[U interface{ M() int }] int diff --git a/test/typeparam/issue46461b.dir/b.go b/test/typeparam/issue46461b.dir/b.go index 3393a375c2..a4583257ff 100644 --- a/test/typeparam/issue46461b.dir/b.go +++ b/test/typeparam/issue46461b.dir/b.go @@ -8,4 +8,6 @@ import "./a" type X int -func (X) M() a.T[X] { return 0 } +func (X) M() int { return 0 } + +type _ a.T[X] diff --git a/test/typeparam/issue48280.dir/a.go b/test/typeparam/issue48280.dir/a.go index 17859e6aa9..f66fd30e34 100644 --- a/test/typeparam/issue48280.dir/a.go +++ b/test/typeparam/issue48280.dir/a.go @@ -4,7 +4,7 @@ package a -type I[T I[T]] interface { +type I[T any] interface { F() T } diff --git a/test/typeparam/issue48306.dir/a.go b/test/typeparam/issue48306.dir/a.go index 739750b20b..fdfd86cb6d 100644 --- a/test/typeparam/issue48306.dir/a.go +++ b/test/typeparam/issue48306.dir/a.go @@ -4,6 +4,6 @@ package a -type I[T I[T]] interface { +type I[T any] interface { F() T } From 57dc6e247538301fb312e8ee35d3385f5d5efc28 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 9 Nov 2021 18:48:16 -0500 Subject: [PATCH 074/752] go/types: disallow type cycles through type parameter lists This is a port of CL 361922 to go/types. Change-Id: I790c8121a640c25fb655c926fb434d667dd59f76 Reviewed-on: https://go-review.googlesource.com/c/go/+/362756 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/types/check.go | 1 + src/go/types/decl.go | 57 ++++++++++++++----- .../types/testdata/fixedbugs/issue45550.go2 | 4 +- .../types/testdata/fixedbugs/issue46461.go2 | 6 +- .../types/testdata/fixedbugs/issue47796.go2 | 14 ++--- .../types/testdata/fixedbugs/issue48529.go2 | 2 +- .../types/testdata/fixedbugs/issue49439.go2 | 26 +++++++++ 7 files changed, 83 insertions(+), 27 deletions(-) create mode 100644 src/go/types/testdata/fixedbugs/issue49439.go2 diff --git a/src/go/types/check.go b/src/go/types/check.go index 1d55fb4342..93e6ffa761 100644 --- a/src/go/types/check.go +++ b/src/go/types/check.go @@ -48,6 +48,7 @@ type context struct { pos token.Pos // if valid, identifiers are looked up as if at position pos (used by Eval) iota constant.Value // value of iota in a constant declaration; nil otherwise errpos positioner // if set, identifier position of a constant with inherited initializer + inTParamList bool // set if inside a type parameter list sig *Signature // function signature if inside a function; nil otherwise isPanic map[*ast.CallExpr]bool // set of panic call expressions (used for termination check) hasLabel bool // set if a function makes use of labels (only ~1% of functions); unused outside functions diff --git a/src/go/types/decl.go b/src/go/types/decl.go index eccdec9a03..0188bdaaf9 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -227,13 +227,23 @@ func (check *Checker) validCycle(obj Object) (valid bool) { assert(obj.color() >= grey) start := obj.color() - grey // index of obj in objPath cycle := check.objPath[start:] - nval := 0 // number of (constant or variable) values in the cycle - ndef := 0 // number of type definitions in the cycle + tparCycle := false // if set, the cycle is through a type parameter list + nval := 0 // number of (constant or variable) values in the cycle; valid if !generic + ndef := 0 // number of type definitions in the cycle; valid if !generic +loop: for _, obj := range cycle { switch obj := obj.(type) { case *Const, *Var: nval++ case *TypeName: + // If we reach a generic type that is part of a cycle + // and we are in a type parameter list, we have a cycle + // through a type parameter list, which is invalid. + if check.context.inTParamList && isGeneric(obj.typ) { + tparCycle = true + break loop + } + // Determine if the type name is an alias or not. For // package-level objects, use the object map which // provides syntactic information (which doesn't rely @@ -261,7 +271,11 @@ func (check *Checker) validCycle(obj Object) (valid bool) { if trace { check.trace(obj.Pos(), "## cycle detected: objPath = %s->%s (len = %d)", pathString(cycle), obj.Name(), len(cycle)) - check.trace(obj.Pos(), "## cycle contains: %d values, %d type definitions", nval, ndef) + if tparCycle { + check.trace(obj.Pos(), "## cycle contains: generic type in a type parameter list") + } else { + check.trace(obj.Pos(), "## cycle contains: %d values, %d type definitions", nval, ndef) + } defer func() { if !valid { check.trace(obj.Pos(), "=> error: cycle is invalid") @@ -269,18 +283,20 @@ func (check *Checker) validCycle(obj Object) (valid bool) { }() } - // A cycle involving only constants and variables is invalid but we - // ignore them here because they are reported via the initialization - // cycle check. - if nval == len(cycle) { - return true - } + if !tparCycle { + // A cycle involving only constants and variables is invalid but we + // ignore them here because they are reported via the initialization + // cycle check. + if nval == len(cycle) { + return true + } - // A cycle involving only types (and possibly functions) must have at least - // one type definition to be permitted: If there is no type definition, we - // have a sequence of alias type names which will expand ad infinitum. - if nval == 0 && ndef > 0 { - return true + // A cycle involving only types (and possibly functions) must have at least + // one type definition to be permitted: If there is no type definition, we + // have a sequence of alias type names which will expand ad infinitum. + if nval == 0 && ndef > 0 { + return true + } } check.cycleError(cycle) @@ -676,6 +692,19 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list *ast.FieldList // Example: type T[P T[P]] interface{} *dst = bindTParams(tparams) + // Signal to cycle detection that we are in a type parameter list. + // We can only be inside one type parameter list at any given time: + // function closures may appear inside a type parameter list but they + // cannot be generic, and their bodies are processed in delayed and + // sequential fashion. Note that with each new declaration, we save + // the existing context and restore it when done; thus inTPList is + // true exactly only when we are in a specific type parameter list. + assert(!check.inTParamList) + check.inTParamList = true + defer func() { + check.inTParamList = false + }() + index := 0 var bounds []Type var posns []positioner // bound positions diff --git a/src/go/types/testdata/fixedbugs/issue45550.go2 b/src/go/types/testdata/fixedbugs/issue45550.go2 index c3e9e34b87..3eeaca0957 100644 --- a/src/go/types/testdata/fixedbugs/issue45550.go2 +++ b/src/go/types/testdata/fixedbugs/issue45550.go2 @@ -4,7 +4,7 @@ package p -type Builder[T interface{ struct{ Builder[T] } }] struct{} +type Builder /* ERROR illegal cycle */ [T interface{ struct{ Builder[T] } }] struct{} type myBuilder struct { - Builder[myBuilder /* ERROR myBuilder does not satisfy */] + Builder[myBuilder] } diff --git a/src/go/types/testdata/fixedbugs/issue46461.go2 b/src/go/types/testdata/fixedbugs/issue46461.go2 index 8bf31090b8..4432402a30 100644 --- a/src/go/types/testdata/fixedbugs/issue46461.go2 +++ b/src/go/types/testdata/fixedbugs/issue46461.go2 @@ -5,16 +5,16 @@ package p // test case 1 -type T[U interface{ M() T[U] }] int +type T /* ERROR illegal cycle */ [U interface{ M() T[U] }] int type X int func (X) M() T[X] { return 0 } // test case 2 -type A[T interface{ A[T] }] interface{} +type A /* ERROR illegal cycle */ [T interface{ A[T] }] interface{} // test case 3 -type A2[U interface{ A2[U] }] interface{ M() A2[U] } +type A2 /* ERROR illegal cycle */ [U interface{ A2[U] }] interface{ M() A2[U] } type I interface{ A2[I]; M() A2[I] } diff --git a/src/go/types/testdata/fixedbugs/issue47796.go2 b/src/go/types/testdata/fixedbugs/issue47796.go2 index 9c10683e22..6667ba4fec 100644 --- a/src/go/types/testdata/fixedbugs/issue47796.go2 +++ b/src/go/types/testdata/fixedbugs/issue47796.go2 @@ -6,16 +6,16 @@ package p // parameterized types with self-recursive constraints type ( - T1[P T1[P]] interface{} - T2[P, Q T2[P, Q]] interface{} + T1 /* ERROR illegal cycle */ [P T1[P]] interface{} + T2 /* ERROR illegal cycle */ [P, Q T2[P, Q]] interface{} T3[P T2[P, Q], Q interface{ ~string }] interface{} - T4a[P T4a[P]] interface{ ~int } - T4b[P T4b[int]] interface{ ~int } - T4c[P T4c[string /* ERROR string does not satisfy T4c\[string\] */]] interface{ ~int } + T4a /* ERROR illegal cycle */ [P T4a[P]] interface{ ~int } + T4b /* ERROR illegal cycle */ [P T4b[int]] interface{ ~int } + T4c /* ERROR illegal cycle */ [P T4c[string]] interface{ ~int } // mutually recursive constraints - T5[P T6[P]] interface{ int } + T5 /* ERROR illegal cycle */ [P T6[P]] interface{ int } T6[P T5[P]] interface{ int } ) @@ -28,6 +28,6 @@ var ( // test case from issue -type Eq[a Eq[a]] interface { +type Eq /* ERROR illegal cycle */ [a Eq[a]] interface { Equal(that a) bool } diff --git a/src/go/types/testdata/fixedbugs/issue48529.go2 b/src/go/types/testdata/fixedbugs/issue48529.go2 index 4f92dec7fe..a3653fa19c 100644 --- a/src/go/types/testdata/fixedbugs/issue48529.go2 +++ b/src/go/types/testdata/fixedbugs/issue48529.go2 @@ -4,7 +4,7 @@ package p -type T[U interface{ M() T /* ERROR "got 2 arguments but 1 type parameters" */ [U, int] }] int +type T /* ERROR illegal cycle */ [U interface{ M() T[U, int] }] int type X int diff --git a/src/go/types/testdata/fixedbugs/issue49439.go2 b/src/go/types/testdata/fixedbugs/issue49439.go2 new file mode 100644 index 0000000000..6cc838b3b3 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue49439.go2 @@ -0,0 +1,26 @@ +// 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 "unsafe" + +type T0 /* ERROR illegal cycle */ [P T0[P]] struct{} + +type T1 /* ERROR illegal cycle */ [P T2[P]] struct{} +type T2[P T1[P]] struct{} + +type T3 /* ERROR illegal cycle */ [P interface{ ~struct{ f T3[int] } }] struct{} + +// valid cycle in M +type N[P M[P]] struct{} +type M[Q any] struct { F *M[Q] } + +// "crazy" case +type TC[P [unsafe.Sizeof(func() { + type T [P [unsafe.Sizeof(func(){})]byte] struct{} +})]byte] struct{} + +// test case from issue +type X /* ERROR illegal cycle */ [T any, PT X[T]] interface{} From 02d7eab52796574b44717d45d5def42c9068b56a Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Sun, 31 Oct 2021 11:33:00 -0400 Subject: [PATCH 075/752] go/parser: allow parsing aliases with type parameters We already guard against this in the type checker, and it will eventually be allowed per the accepted proposal. Add a placeholder error code for the corresponding type checker error. Change-Id: I5cc2f1413ecc89ec2094f7178fdb156fb8cc2e43 Reviewed-on: https://go-review.googlesource.com/c/go/+/360235 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Go Bot Reviewed-by: Robert Griesemer --- src/go/parser/parser.go | 6 ++++-- src/go/parser/short_test.go | 2 +- src/go/types/decl.go | 2 +- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go index 8952a2bc29..7c1a8be2fa 100644 --- a/src/go/parser/parser.go +++ b/src/go/parser/parser.go @@ -2539,9 +2539,11 @@ func (p *parser) parseGenericType(spec *ast.TypeSpec, openPos token.Pos, name0 * list := p.parseParameterList(name0, token.RBRACK) closePos := p.expect(token.RBRACK) spec.TypeParams = &ast.FieldList{Opening: openPos, List: list, Closing: closePos} - // Type alias cannot have type parameters. Accept them for robustness but complain. + // Let the type checker decide whether to accept type parameters on aliases: + // see issue #46477. if p.tok == token.ASSIGN { - p.error(p.pos, "generic type cannot be alias") + // type alias + spec.Assign = p.pos p.next() } spec.Type = p.parseType() diff --git a/src/go/parser/short_test.go b/src/go/parser/short_test.go index 20450bfe8e..90a4ec9ecd 100644 --- a/src/go/parser/short_test.go +++ b/src/go/parser/short_test.go @@ -123,6 +123,7 @@ var validWithTParamsOnly = []string{ `package p; type I1[T any /* ERROR "expected ']', found any" */ ] interface{}; type I2 interface{ I1[int] }`, `package p; type I1[T any /* ERROR "expected ']', found any" */ ] interface{}; type I2[T any] interface{ I1[T] }`, `package p; type _ interface { f[ /* ERROR "expected ';', found '\['" */ T any]() }`, + `package p; type T[P any /* ERROR "expected ']'" */ ] = T0`, } func TestValid(t *testing.T) { @@ -240,7 +241,6 @@ var invalidNoTParamErrs = []string{ // error messages produced when ParseTypeParams is set. var invalidTParamErrs = []string{ `package p; type _[_ any] int; var _ = T[] /* ERROR "expected operand" */ {}`, - `package p; type T[P any] = /* ERROR "cannot be alias" */ T0`, `package p; var _ func[ /* ERROR "cannot have type parameters" */ T any](T)`, `package p; func _[]/* ERROR "empty type parameter list" */()`, diff --git a/src/go/types/decl.go b/src/go/types/decl.go index 0188bdaaf9..64d5bd195e 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -631,7 +631,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) { if alias && tdecl.TypeParams.NumFields() != 0 { // The parser will ensure this but we may still get an invalid AST. // Complain and continue as regular type definition. - check.error(atPos(tdecl.Assign), 0, "generic type cannot be alias") + check.error(atPos(tdecl.Assign), _Todo, "generic type cannot be alias") alias = false } From e984240d310302764c66bb4bf84b5747e05cf8ef Mon Sep 17 00:00:00 2001 From: Hajime Hoshi Date: Fri, 5 Nov 2021 23:50:55 +0900 Subject: [PATCH 076/752] runtime: fix unworkable comments for go:nosplit Change-Id: I71c29a2dc7e5b2b6bc35093535228d2907b16b47 Reviewed-on: https://go-review.googlesource.com/c/go/+/361595 Run-TryBot: Ian Lance Taylor TryBot-Result: Go Bot Reviewed-by: Ian Lance Taylor Trust: Hajime Hoshi --- src/runtime/sys_darwin.go | 2 +- src/runtime/sys_openbsd2.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/runtime/sys_darwin.go b/src/runtime/sys_darwin.go index 0f91685d6c..9af4cf18f8 100644 --- a/src/runtime/sys_darwin.go +++ b/src/runtime/sys_darwin.go @@ -156,7 +156,7 @@ func pthread_kill_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 +//go:nosplit func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (unsafe.Pointer, int) { args := struct { addr unsafe.Pointer diff --git a/src/runtime/sys_openbsd2.go b/src/runtime/sys_openbsd2.go index 7024cfa86d..c936fbb494 100644 --- a/src/runtime/sys_openbsd2.go +++ b/src/runtime/sys_openbsd2.go @@ -45,7 +45,7 @@ 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 +//go:nosplit func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (unsafe.Pointer, int) { args := struct { addr unsafe.Pointer From 17980dff368256a0763cf042376d3fb36d06c109 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 9 Nov 2021 20:22:26 -0800 Subject: [PATCH 077/752] doc: make a copy of the latest Go 1.17 spec This will allow us to compare the changes made for Go 1.18. Change-Id: I1456270b201967f5cb05e66cec556939e6e33265 Reviewed-on: https://go-review.googlesource.com/c/go/+/362894 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go1.17_spec.html | 6858 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 6858 insertions(+) create mode 100644 doc/go1.17_spec.html diff --git a/doc/go1.17_spec.html b/doc/go1.17_spec.html new file mode 100644 index 0000000000..46eebb5713 --- /dev/null +++ b/doc/go1.17_spec.html @@ -0,0 +1,6858 @@ + + +

Introduction

+ +

+This is a reference manual for the Go programming language. For +more information and other documents, see golang.org. +

+ +

+Go is a general-purpose language designed with systems programming +in mind. It is strongly typed and garbage-collected and has explicit +support for concurrent programming. Programs are constructed from +packages, whose properties allow efficient management of +dependencies. +

+ +

+The grammar is compact and simple to parse, allowing for easy analysis +by automatic tools such as integrated development environments. +

+ +

Notation

+

+The syntax is specified using Extended Backus-Naur Form (EBNF): +

+ +
+Production  = production_name "=" [ Expression ] "." .
+Expression  = Alternative { "|" Alternative } .
+Alternative = Term { Term } .
+Term        = production_name | token [ "…" token ] | Group | Option | Repetition .
+Group       = "(" Expression ")" .
+Option      = "[" Expression "]" .
+Repetition  = "{" Expression "}" .
+
+ +

+Productions are expressions constructed from terms and the following +operators, in increasing precedence: +

+
+|   alternation
+()  grouping
+[]  option (0 or 1 times)
+{}  repetition (0 to n times)
+
+ +

+Lower-case production names are used to identify lexical tokens. +Non-terminals are in CamelCase. Lexical tokens are enclosed in +double quotes "" or back quotes ``. +

+ +

+The form a … b represents the set of characters from +a through b as alternatives. The horizontal +ellipsis … is also used elsewhere in the spec to informally denote various +enumerations or code snippets that are not further specified. The character … +(as opposed to the three characters ...) is not a token of the Go +language. +

+ +

Source code representation

+ +

+Source code is Unicode text encoded in +UTF-8. The text is not +canonicalized, so a single accented code point is distinct from the +same character constructed from combining an accent and a letter; +those are treated as two code points. For simplicity, this document +will use the unqualified term character to refer to a Unicode code point +in the source text. +

+

+Each code point is distinct; for instance, upper and lower case letters +are different characters. +

+

+Implementation restriction: For compatibility with other tools, a +compiler may disallow the NUL character (U+0000) in the source text. +

+

+Implementation restriction: For compatibility with other tools, a +compiler may ignore a UTF-8-encoded byte order mark +(U+FEFF) if it is the first Unicode code point in the source text. +A byte order mark may be disallowed anywhere else in the source. +

+ +

Characters

+ +

+The following terms are used to denote specific Unicode character classes: +

+
+newline        = /* the Unicode code point U+000A */ .
+unicode_char   = /* an arbitrary Unicode code point except newline */ .
+unicode_letter = /* a Unicode code point classified as "Letter" */ .
+unicode_digit  = /* a Unicode code point classified as "Number, decimal digit" */ .
+
+ +

+In The Unicode Standard 8.0, +Section 4.5 "General Category" defines a set of character categories. +Go treats all characters in any of the Letter categories Lu, Ll, Lt, Lm, or Lo +as Unicode letters, and those in the Number category Nd as Unicode digits. +

+ +

Letters and digits

+ +

+The underscore character _ (U+005F) is considered a letter. +

+
+letter        = unicode_letter | "_" .
+decimal_digit = "0" … "9" .
+binary_digit  = "0" | "1" .
+octal_digit   = "0" … "7" .
+hex_digit     = "0" … "9" | "A" … "F" | "a" … "f" .
+
+ +

Lexical elements

+ +

Comments

+ +

+Comments serve as program documentation. There are two forms: +

+ +
    +
  1. +Line comments start with the character sequence // +and stop at the end of the line. +
    2. +
  2. +General comments start with the character sequence /* +and stop with the first subsequent character sequence */. +
    3. +
+ +

+A comment cannot start inside a rune or +string literal, or inside a comment. +A general comment containing no newlines acts like a space. +Any other comment acts like a newline. +

+ +

Tokens

+ +

+Tokens form the vocabulary of the Go language. +There are four classes: identifiers, keywords, operators +and punctuation, and literals. White space, formed from +spaces (U+0020), horizontal tabs (U+0009), +carriage returns (U+000D), and newlines (U+000A), +is ignored except as it separates tokens +that would otherwise combine into a single token. Also, a newline or end of file +may trigger the insertion of a semicolon. +While breaking the input into tokens, +the next token is the longest sequence of characters that form a +valid token. +

+ +

Semicolons

+ +

+The formal grammar uses semicolons ";" as terminators in +a number of productions. Go programs may omit most of these semicolons +using the following two rules: +

+ +
    +
  1. +When the input is broken into tokens, a semicolon is automatically inserted +into the token stream immediately after a line's final token if that token is + +
    2. + +
  2. +To allow complex statements to occupy a single line, a semicolon +may be omitted before a closing ")" or "}". +
    3. +
+ +

+To reflect idiomatic use, code examples in this document elide semicolons +using these rules. +

+ + +

Identifiers

+ +

+Identifiers name program entities such as variables and types. +An identifier is a sequence of one or more letters and digits. +The first character in an identifier must be a letter. +

+
+identifier = letter { letter | unicode_digit } .
+
+
+a
+_x9
+ThisVariableIsExported
+αβ
+
+ +

+Some identifiers are predeclared. +

+ + +

Keywords

+ +

+The following keywords are reserved and may not be used as identifiers. +

+
+break        default      func         interface    select
+case         defer        go           map          struct
+chan         else         goto         package      switch
+const        fallthrough  if           range        type
+continue     for          import       return       var
+
+ +

Operators and punctuation

+ +

+The following character sequences represent operators +(including assignment operators) and punctuation: +

+
++    &     +=    &=     &&    ==    !=    (    )
+-    |     -=    |=     ||    <     <=    [    ]
+*    ^     *=    ^=     <-    >     >=    {    }
+/    <<    /=    <<=    ++    =     :=    ,    ;
+%    >>    %=    >>=    --    !     ...   .    :
+     &^          &^=
+
+ +

Integer literals

+ +

+An integer literal is a sequence of digits representing an +integer constant. +An optional prefix sets a non-decimal base: 0b or 0B +for binary, 0, 0o, or 0O for octal, +and 0x or 0X for hexadecimal. +A single 0 is considered a decimal zero. +In hexadecimal literals, letters a through f +and A through F represent values 10 through 15. +

+ +

+For readability, an underscore character _ may appear after +a base prefix or between successive digits; such underscores do not change +the literal's value. +

+
+int_lit        = decimal_lit | binary_lit | octal_lit | hex_lit .
+decimal_lit    = "0" | ( "1" … "9" ) [ [ "_" ] decimal_digits ] .
+binary_lit     = "0" ( "b" | "B" ) [ "_" ] binary_digits .
+octal_lit      = "0" [ "o" | "O" ] [ "_" ] octal_digits .
+hex_lit        = "0" ( "x" | "X" ) [ "_" ] hex_digits .
+
+decimal_digits = decimal_digit { [ "_" ] decimal_digit } .
+binary_digits  = binary_digit { [ "_" ] binary_digit } .
+octal_digits   = octal_digit { [ "_" ] octal_digit } .
+hex_digits     = hex_digit { [ "_" ] hex_digit } .
+
+ +
+42
+4_2
+0600
+0_600
+0o600
+0O600       // second character is capital letter 'O'
+0xBadFace
+0xBad_Face
+0x_67_7a_2f_cc_40_c6
+170141183460469231731687303715884105727
+170_141183_460469_231731_687303_715884_105727
+
+_42         // an identifier, not an integer literal
+42_         // invalid: _ must separate successive digits
+4__2        // invalid: only one _ at a time
+0_xBadFace  // invalid: _ must separate successive digits
+
+ + +

Floating-point literals

+ +

+A floating-point literal is a decimal or hexadecimal representation of a +floating-point constant. +

+ +

+A decimal floating-point literal consists of an integer part (decimal digits), +a decimal point, a fractional part (decimal digits), and an exponent part +(e or E followed by an optional sign and decimal digits). +One of the integer part or the fractional part may be elided; one of the decimal point +or the exponent part may be elided. +An exponent value exp scales the mantissa (integer and fractional part) by 10exp. +

+ +

+A hexadecimal floating-point literal consists of a 0x or 0X +prefix, an integer part (hexadecimal digits), a radix point, a fractional part (hexadecimal digits), +and an exponent part (p or P followed by an optional sign and decimal digits). +One of the integer part or the fractional part may be elided; the radix point may be elided as well, +but the exponent part is required. (This syntax matches the one given in IEEE 754-2008 §5.12.3.) +An exponent value exp scales the mantissa (integer and fractional part) by 2exp. +

+ +

+For readability, an underscore character _ may appear after +a base prefix or between successive digits; such underscores do not change +the literal value. +

+ +
+float_lit         = decimal_float_lit | hex_float_lit .
+
+decimal_float_lit = decimal_digits "." [ decimal_digits ] [ decimal_exponent ] |
+                    decimal_digits decimal_exponent |
+                    "." decimal_digits [ decimal_exponent ] .
+decimal_exponent  = ( "e" | "E" ) [ "+" | "-" ] decimal_digits .
+
+hex_float_lit     = "0" ( "x" | "X" ) hex_mantissa hex_exponent .
+hex_mantissa      = [ "_" ] hex_digits "." [ hex_digits ] |
+                    [ "_" ] hex_digits |
+                    "." hex_digits .
+hex_exponent      = ( "p" | "P" ) [ "+" | "-" ] decimal_digits .
+
+ +
+0.
+72.40
+072.40       // == 72.40
+2.71828
+1.e+0
+6.67428e-11
+1E6
+.25
+.12345E+5
+1_5.         // == 15.0
+0.15e+0_2    // == 15.0
+
+0x1p-2       // == 0.25
+0x2.p10      // == 2048.0
+0x1.Fp+0     // == 1.9375
+0X.8p-0      // == 0.5
+0X_1FFFP-16  // == 0.1249847412109375
+0x15e-2      // == 0x15e - 2 (integer subtraction)
+
+0x.p1        // invalid: mantissa has no digits
+1p-2         // invalid: p exponent requires hexadecimal mantissa
+0x1.5e-2     // invalid: hexadecimal mantissa requires p exponent
+1_.5         // invalid: _ must separate successive digits
+1._5         // invalid: _ must separate successive digits
+1.5_e1       // invalid: _ must separate successive digits
+1.5e_1       // invalid: _ must separate successive digits
+1.5e1_       // invalid: _ must separate successive digits
+
+ + +

Imaginary literals

+ +

+An imaginary literal represents the imaginary part of a +complex constant. +It consists of an integer or +floating-point literal +followed by the lower-case letter i. +The value of an imaginary literal is the value of the respective +integer or floating-point literal multiplied by the imaginary unit i. +

+ +
+imaginary_lit = (decimal_digits | int_lit | float_lit) "i" .
+
+ +

+For backward compatibility, an imaginary literal's integer part consisting +entirely of decimal digits (and possibly underscores) is considered a decimal +integer, even if it starts with a leading 0. +

+ +
+0i
+0123i         // == 123i for backward-compatibility
+0o123i        // == 0o123 * 1i == 83i
+0xabci        // == 0xabc * 1i == 2748i
+0.i
+2.71828i
+1.e+0i
+6.67428e-11i
+1E6i
+.25i
+.12345E+5i
+0x1p-2i       // == 0x1p-2 * 1i == 0.25i
+
+ + +

Rune literals

+ +

+A rune literal represents a rune constant, +an integer value identifying a Unicode code point. +A rune literal is expressed as one or more characters enclosed in single quotes, +as in 'x' or '\n'. +Within the quotes, any character may appear except newline and unescaped single +quote. A single quoted character represents the Unicode value +of the character itself, +while multi-character sequences beginning with a backslash encode +values in various formats. +

+ +

+The simplest form represents the single character within the quotes; +since Go source text is Unicode characters encoded in UTF-8, multiple +UTF-8-encoded bytes may represent a single integer value. For +instance, the literal 'a' holds a single byte representing +a literal a, Unicode U+0061, value 0x61, while +'ä' holds two bytes (0xc3 0xa4) representing +a literal a-dieresis, U+00E4, value 0xe4. +

+ +

+Several backslash escapes allow arbitrary values to be encoded as +ASCII text. There are four ways to represent the integer value +as a numeric constant: \x followed by exactly two hexadecimal +digits; \u followed by exactly four hexadecimal digits; +\U followed by exactly eight hexadecimal digits, and a +plain backslash \ followed by exactly three octal digits. +In each case the value of the literal is the value represented by +the digits in the corresponding base. +

+ +

+Although these representations all result in an integer, they have +different valid ranges. Octal escapes must represent a value between +0 and 255 inclusive. Hexadecimal escapes satisfy this condition +by construction. The escapes \u and \U +represent Unicode code points so within them some values are illegal, +in particular those above 0x10FFFF and surrogate halves. +

+ +

+After a backslash, certain single-character escapes represent special values: +

+ +
+\a   U+0007 alert or bell
+\b   U+0008 backspace
+\f   U+000C form feed
+\n   U+000A line feed or newline
+\r   U+000D carriage return
+\t   U+0009 horizontal tab
+\v   U+000B vertical tab
+\\   U+005C backslash
+\'   U+0027 single quote  (valid escape only within rune literals)
+\"   U+0022 double quote  (valid escape only within string literals)
+
+ +

+All other sequences starting with a backslash are illegal inside rune literals. +

+
+rune_lit         = "'" ( unicode_value | byte_value ) "'" .
+unicode_value    = unicode_char | little_u_value | big_u_value | escaped_char .
+byte_value       = octal_byte_value | hex_byte_value .
+octal_byte_value = `\` octal_digit octal_digit octal_digit .
+hex_byte_value   = `\` "x" hex_digit hex_digit .
+little_u_value   = `\` "u" hex_digit hex_digit hex_digit hex_digit .
+big_u_value      = `\` "U" hex_digit hex_digit hex_digit hex_digit
+                           hex_digit hex_digit hex_digit hex_digit .
+escaped_char     = `\` ( "a" | "b" | "f" | "n" | "r" | "t" | "v" | `\` | "'" | `"` ) .
+
+ +
+'a'
+'ä'
+'本'
+'\t'
+'\000'
+'\007'
+'\377'
+'\x07'
+'\xff'
+'\u12e4'
+'\U00101234'
+'\''         // rune literal containing single quote character
+'aa'         // illegal: too many characters
+'\xa'        // illegal: too few hexadecimal digits
+'\0'         // illegal: too few octal digits
+'\uDFFF'     // illegal: surrogate half
+'\U00110000' // illegal: invalid Unicode code point
+
+ + +

String literals

+ +

+A string literal represents a string constant +obtained from concatenating a sequence of characters. There are two forms: +raw string literals and interpreted string literals. +

+ +

+Raw string literals are character sequences between back quotes, as in +`foo`. Within the quotes, any character may appear except +back quote. The value of a raw string literal is the +string composed of the uninterpreted (implicitly UTF-8-encoded) characters +between the quotes; +in particular, backslashes have no special meaning and the string may +contain newlines. +Carriage return characters ('\r') inside raw string literals +are discarded from the raw string value. +

+ +

+Interpreted string literals are character sequences between double +quotes, as in "bar". +Within the quotes, any character may appear except newline and unescaped double quote. +The text between the quotes forms the +value of the literal, with backslash escapes interpreted as they +are in rune literals (except that \' is illegal and +\" is legal), with the same restrictions. +The three-digit octal (\nnn) +and two-digit hexadecimal (\xnn) escapes represent individual +bytes of the resulting string; all other escapes represent +the (possibly multi-byte) UTF-8 encoding of individual characters. +Thus inside a string literal \377 and \xFF represent +a single byte of value 0xFF=255, while ÿ, +\u00FF, \U000000FF and \xc3\xbf represent +the two bytes 0xc3 0xbf of the UTF-8 encoding of character +U+00FF. +

+ +
+string_lit             = raw_string_lit | interpreted_string_lit .
+raw_string_lit         = "`" { unicode_char | newline } "`" .
+interpreted_string_lit = `"` { unicode_value | byte_value } `"` .
+
+ +
+`abc`                // same as "abc"
+`\n
+\n`                  // same as "\\n\n\\n"
+"\n"
+"\""                 // same as `"`
+"Hello, world!\n"
+"日本語"
+"\u65e5本\U00008a9e"
+"\xff\u00FF"
+"\uD800"             // illegal: surrogate half
+"\U00110000"         // illegal: invalid Unicode code point
+
+ +

+These examples all represent the same string: +

+ +
+"日本語"                                 // UTF-8 input text
+`日本語`                                 // UTF-8 input text as a raw literal
+"\u65e5\u672c\u8a9e"                    // the explicit Unicode code points
+"\U000065e5\U0000672c\U00008a9e"        // the explicit Unicode code points
+"\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"  // the explicit UTF-8 bytes
+
+ +

+If the source code represents a character as two code points, such as +a combining form involving an accent and a letter, the result will be +an error if placed in a rune literal (it is not a single code +point), and will appear as two code points if placed in a string +literal. +

+ + +

Constants

+ +

There are boolean constants, +rune constants, +integer constants, +floating-point constants, complex constants, +and string constants. Rune, integer, floating-point, +and complex constants are +collectively called numeric constants. +

+ +

+A constant value is represented by a +rune, +integer, +floating-point, +imaginary, +or +string literal, +an identifier denoting a constant, +a constant expression, +a conversion with a result that is a constant, or +the result value of some built-in functions such as +unsafe.Sizeof applied to any value, +cap or len applied to +some expressions, +real and imag applied to a complex constant +and complex applied to numeric constants. +The boolean truth values are represented by the predeclared constants +true and false. The predeclared identifier +iota denotes an integer constant. +

+ +

+In general, complex constants are a form of +constant expression +and are discussed in that section. +

+ +

+Numeric constants represent exact values of arbitrary precision and do not overflow. +Consequently, there are no constants denoting the IEEE-754 negative zero, infinity, +and not-a-number values. +

+ +

+Constants may be typed or untyped. +Literal constants, true, false, iota, +and certain constant expressions +containing only untyped constant operands are untyped. +

+ +

+A constant may be given a type explicitly by a constant declaration +or conversion, or implicitly when used in a +variable declaration or an +assignment or as an +operand in an expression. +It is an error if the constant value +cannot be represented as a value of the respective type. +

+ +

+An untyped constant has a default type which is the type to which the +constant is implicitly converted in contexts where a typed value is required, +for instance, in a short variable declaration +such as i := 0 where there is no explicit type. +The default type of an untyped constant is bool, rune, +int, float64, complex128 or string +respectively, depending on whether it is a boolean, rune, integer, floating-point, +complex, or string constant. +

+ +

+Implementation restriction: Although numeric constants have arbitrary +precision in the language, a compiler may implement them using an +internal representation with limited precision. That said, every +implementation must: +

+ +
    +
  • Represent integer constants with at least 256 bits.
    • + +
  • Represent floating-point constants, including the parts of + a complex constant, with a mantissa of at least 256 bits + and a signed binary exponent of at least 16 bits.
    • + +
  • Give an error if unable to represent an integer constant + precisely.
    • + +
  • Give an error if unable to represent a floating-point or + complex constant due to overflow.
    • + +
  • Round to the nearest representable constant if unable to + represent a floating-point or complex constant due to limits + on precision.
    • +
+ +

+These requirements apply both to literal constants and to the result +of evaluating constant +expressions. +

+ + +

Variables

+ +

+A variable is a storage location for holding a value. +The set of permissible values is determined by the +variable's type. +

+ +

+A variable declaration +or, for function parameters and results, the signature +of a function declaration +or function literal reserves +storage for a named variable. + +Calling the built-in function new +or taking the address of a composite literal +allocates storage for a variable at run time. +Such an anonymous variable is referred to via a (possibly implicit) +pointer indirection. +

+ +

+Structured variables of array, slice, +and struct types have elements and fields that may +be addressed individually. Each such element +acts like a variable. +

+ +

+The static type (or just type) of a variable is the +type given in its declaration, the type provided in the +new call or composite literal, or the type of +an element of a structured variable. +Variables of interface type also have a distinct dynamic type, +which is the concrete type of the value assigned to the variable at run time +(unless the value is the predeclared identifier nil, +which has no type). +The dynamic type may vary during execution but values stored in interface +variables are always assignable +to the static type of the variable. +

+ +
+var x interface{}  // x is nil and has static type interface{}
+var v *T           // v has value nil, static type *T
+x = 42             // x has value 42 and dynamic type int
+x = v              // x has value (*T)(nil) and dynamic type *T
+
+ +

+A variable's value is retrieved by referring to the variable in an +expression; it is the most recent value +assigned to the variable. +If a variable has not yet been assigned a value, its value is the +zero value for its type. +

+ + +

Types

+ +

+A type determines a set of values together with operations and methods specific +to those values. A type may be denoted by a type name, if it has one, +or specified using a type literal, which composes a type from existing types. +

+ +
+Type      = TypeName | TypeLit | "(" Type ")" .
+TypeName  = identifier | QualifiedIdent .
+TypeLit   = ArrayType | StructType | PointerType | FunctionType | InterfaceType |
+	    SliceType | MapType | ChannelType .
+
+ +

+The language predeclares certain type names. +Others are introduced with type declarations. +Composite types—array, struct, pointer, function, +interface, slice, map, and channel types—may be constructed using +type literals. +

+ +

+Each type T has an underlying type: If T +is one of the predeclared boolean, numeric, or string types, or a type literal, +the corresponding underlying +type is T itself. Otherwise, T's underlying type +is the underlying type of the type to which T refers in its +type declaration. +

+ +
+type (
+	A1 = string
+	A2 = A1
+)
+
+type (
+	B1 string
+	B2 B1
+	B3 []B1
+	B4 B3
+)
+
+ +

+The underlying type of string, A1, A2, B1, +and B2 is string. +The underlying type of []B1, B3, and B4 is []B1. +

+ +

Method sets

+

+A type has a (possibly empty) method set associated with it. +The method set of an interface type is its interface. +The method set of any other type T consists of all +methods declared with receiver type T. +The method set of the corresponding pointer type *T +is the set of all methods declared with receiver *T or T +(that is, it also contains the method set of T). +Further rules apply to structs containing embedded fields, as described +in the section on struct types. +Any other type has an empty method set. +In a method set, each method must have a +unique +non-blank method name. +

+ +

+The method set of a type determines the interfaces that the +type implements +and the methods that can be called +using a receiver of that type. +

+ +

Boolean types

+ +

+A boolean type represents the set of Boolean truth values +denoted by the predeclared constants true +and false. The predeclared boolean type is bool; +it is a defined type. +

+ +

Numeric types

+ +

+A numeric type represents sets of integer or floating-point values. +The predeclared architecture-independent numeric types are: +

+ +
+uint8       the set of all unsigned  8-bit integers (0 to 255)
+uint16      the set of all unsigned 16-bit integers (0 to 65535)
+uint32      the set of all unsigned 32-bit integers (0 to 4294967295)
+uint64      the set of all unsigned 64-bit integers (0 to 18446744073709551615)
+
+int8        the set of all signed  8-bit integers (-128 to 127)
+int16       the set of all signed 16-bit integers (-32768 to 32767)
+int32       the set of all signed 32-bit integers (-2147483648 to 2147483647)
+int64       the set of all signed 64-bit integers (-9223372036854775808 to 9223372036854775807)
+
+float32     the set of all IEEE-754 32-bit floating-point numbers
+float64     the set of all IEEE-754 64-bit floating-point numbers
+
+complex64   the set of all complex numbers with float32 real and imaginary parts
+complex128  the set of all complex numbers with float64 real and imaginary parts
+
+byte        alias for uint8
+rune        alias for int32
+
+ +

+The value of an n-bit integer is n bits wide and represented using +two's complement arithmetic. +

+ +

+There is also a set of predeclared numeric types with implementation-specific sizes: +

+ +
+uint     either 32 or 64 bits
+int      same size as uint
+uintptr  an unsigned integer large enough to store the uninterpreted bits of a pointer value
+
+ +

+To avoid portability issues all numeric types are defined +types and thus distinct except +byte, which is an alias for uint8, and +rune, which is an alias for int32. +Explicit conversions +are required when different numeric types are mixed in an expression +or assignment. For instance, int32 and int +are not the same type even though they may have the same size on a +particular architecture. + + +

String types

+ +

+A string type represents the set of string values. +A string value is a (possibly empty) sequence of bytes. +The number of bytes is called the length of the string and is never negative. +Strings are immutable: once created, +it is impossible to change the contents of a string. +The predeclared string type is string; +it is a defined type. +

+ +

+The length of a string s can be discovered using +the built-in function len. +The length is a compile-time constant if the string is a constant. +A string's bytes can be accessed by integer indices +0 through len(s)-1. +It is illegal to take the address of such an element; if +s[i] is the i'th byte of a +string, &s[i] is invalid. +

+ + +

Array types

+ +

+An array is a numbered sequence of elements of a single +type, called the element type. +The number of elements is called the length of the array and is never negative. +

+ +
+ArrayType   = "[" ArrayLength "]" ElementType .
+ArrayLength = Expression .
+ElementType = Type .
+
+ +

+The length is part of the array's type; it must evaluate to a +non-negative constant +representable by a value +of type int. +The length of array a can be discovered +using the built-in function len. +The elements can be addressed by integer indices +0 through len(a)-1. +Array types are always one-dimensional but may be composed to form +multi-dimensional types. +

+ +
+[32]byte
+[2*N] struct { x, y int32 }
+[1000]*float64
+[3][5]int
+[2][2][2]float64  // same as [2]([2]([2]float64))
+
+ +

Slice types

+ +

+A slice is a descriptor for a contiguous segment of an underlying array and +provides access to a numbered sequence of elements from that array. +A slice type denotes the set of all slices of arrays of its element type. +The number of elements is called the length of the slice and is never negative. +The value of an uninitialized slice is nil. +

+ +
+SliceType = "[" "]" ElementType .
+
+ +

+The length of a slice s can be discovered by the built-in function +len; unlike with arrays it may change during +execution. The elements can be addressed by integer indices +0 through len(s)-1. The slice index of a +given element may be less than the index of the same element in the +underlying array. +

+

+A slice, once initialized, is always associated with an underlying +array that holds its elements. A slice therefore shares storage +with its array and with other slices of the same array; by contrast, +distinct arrays always represent distinct storage. +

+

+The array underlying a slice may extend past the end of the slice. +The capacity is a measure of that extent: it is the sum of +the length of the slice and the length of the array beyond the slice; +a slice of length up to that capacity can be created by +slicing a new one from the original slice. +The capacity of a slice a can be discovered using the +built-in function cap(a). +

+ +

+A new, initialized slice value for a given element type T is +made using the built-in function +make, +which takes a slice type +and parameters specifying the length and optionally the capacity. +A slice created with make always allocates a new, hidden array +to which the returned slice value refers. That is, executing +

+ +
+make([]T, length, capacity)
+
+ +

+produces the same slice as allocating an array and slicing +it, so these two expressions are equivalent: +

+ +
+make([]int, 50, 100)
+new([100]int)[0:50]
+
+ +

+Like arrays, slices are always one-dimensional but may be composed to construct +higher-dimensional objects. +With arrays of arrays, the inner arrays are, by construction, always the same length; +however with slices of slices (or arrays of slices), the inner lengths may vary dynamically. +Moreover, the inner slices must be initialized individually. +

+ +

Struct types

+ +

+A struct is a sequence of named elements, called fields, each of which has a +name and a type. Field names may be specified explicitly (IdentifierList) or +implicitly (EmbeddedField). +Within a struct, non-blank field names must +be unique. +

+ +
+StructType    = "struct" "{" { FieldDecl ";" } "}" .
+FieldDecl     = (IdentifierList Type | EmbeddedField) [ Tag ] .
+EmbeddedField = [ "*" ] TypeName .
+Tag           = string_lit .
+
+ +
+// An empty struct.
+struct {}
+
+// A struct with 6 fields.
+struct {
+	x, y int
+	u float32
+	_ float32  // padding
+	A *[]int
+	F func()
+}
+
+ +

+A field declared with a type but no explicit field name is called an embedded field. +An embedded field must be specified as +a type name T or as a pointer to a non-interface type name *T, +and T itself may not be +a pointer type. The unqualified type name acts as the field name. +

+ +
+// A struct with four embedded fields of types T1, *T2, P.T3 and *P.T4
+struct {
+	T1        // field name is T1
+	*T2       // field name is T2
+	P.T3      // field name is T3
+	*P.T4     // field name is T4
+	x, y int  // field names are x and y
+}
+
+ +

+The following declaration is illegal because field names must be unique +in a struct type: +

+ +
+struct {
+	T     // conflicts with embedded field *T and *P.T
+	*T    // conflicts with embedded field T and *P.T
+	*P.T  // conflicts with embedded field T and *T
+}
+
+ +

+A field or method f of an +embedded field in a struct x is called promoted if +x.f is a legal selector that denotes +that field or method f. +

+ +

+Promoted fields act like ordinary fields +of a struct except that they cannot be used as field names in +composite literals of the struct. +

+ +

+Given a struct type S and a defined type +T, promoted methods are included in the method set of the struct as follows: +

+
    +
  • + If S contains an embedded field T, + the method sets of S + and *S both include promoted methods with receiver + T. The method set of *S also + includes promoted methods with receiver *T. +
    • + +
  • + If S contains an embedded field *T, + the method sets of S and *S both + include promoted methods with receiver T or + *T. +
    • +
+ +

+A field declaration may be followed by an optional string literal tag, +which becomes an attribute for all the fields in the corresponding +field declaration. An empty tag string is equivalent to an absent tag. +The tags are made visible through a reflection interface +and take part in type identity for structs +but are otherwise ignored. +

+ +
+struct {
+	x, y float64 ""  // an empty tag string is like an absent tag
+	name string  "any string is permitted as a tag"
+	_    [4]byte "ceci n'est pas un champ de structure"
+}
+
+// A struct corresponding to a TimeStamp protocol buffer.
+// The tag strings define the protocol buffer field numbers;
+// they follow the convention outlined by the reflect package.
+struct {
+	microsec  uint64 `protobuf:"1"`
+	serverIP6 uint64 `protobuf:"2"`
+}
+
+ +

Pointer types

+ +

+A pointer type denotes the set of all pointers to variables of a given +type, called the base type of the pointer. +The value of an uninitialized pointer is nil. +

+ +
+PointerType = "*" BaseType .
+BaseType    = Type .
+
+ +
+*Point
+*[4]int
+
+ +

Function types

+ +

+A function type denotes the set of all functions with the same parameter +and result types. The value of an uninitialized variable of function type +is nil. +

+ +
+FunctionType   = "func" Signature .
+Signature      = Parameters [ Result ] .
+Result         = Parameters | Type .
+Parameters     = "(" [ ParameterList [ "," ] ] ")" .
+ParameterList  = ParameterDecl { "," ParameterDecl } .
+ParameterDecl  = [ IdentifierList ] [ "..." ] Type .
+
+ +

+Within a list of parameters or results, the names (IdentifierList) +must either all be present or all be absent. If present, each name +stands for one item (parameter or result) of the specified type and +all non-blank names in the signature +must be unique. +If absent, each type stands for one item of that type. +Parameter and result +lists are always parenthesized except that if there is exactly +one unnamed result it may be written as an unparenthesized type. +

+ +

+The final incoming parameter in a function signature may have +a type prefixed with .... +A function with such a parameter is called variadic and +may be invoked with zero or more arguments for that parameter. +

+ +
+func()
+func(x int) int
+func(a, _ int, z float32) bool
+func(a, b int, z float32) (bool)
+func(prefix string, values ...int)
+func(a, b int, z float64, opt ...interface{}) (success bool)
+func(int, int, float64) (float64, *[]int)
+func(n int) func(p *T)
+
+ + +

Interface types

+ +

+An interface type specifies a method set called its interface. +A variable of interface type can store a value of any type with a method set +that is any superset of the interface. Such a type is said to +implement the interface. +The value of an uninitialized variable of interface type is nil. +

+ +
+InterfaceType      = "interface" "{" { ( MethodSpec | InterfaceTypeName ) ";" } "}" .
+MethodSpec         = MethodName Signature .
+MethodName         = identifier .
+InterfaceTypeName  = TypeName .
+
+ +

+An interface type may specify methods explicitly through method specifications, +or it may embed methods of other interfaces through interface type names. +

+ +
+// A simple File interface.
+interface {
+	Read([]byte) (int, error)
+	Write([]byte) (int, error)
+	Close() error
+}
+
+ +

+The name of each explicitly specified method must be unique +and not blank. +

+ +
+interface {
+	String() string
+	String() string  // illegal: String not unique
+	_(x int)         // illegal: method must have non-blank name
+}
+
+ +

+More than one type may implement an interface. +For instance, if two types S1 and S2 +have the method set +

+ +
+func (p T) Read(p []byte) (n int, err error)
+func (p T) Write(p []byte) (n int, err error)
+func (p T) Close() error
+
+ +

+(where T stands for either S1 or S2) +then the File interface is implemented by both S1 and +S2, regardless of what other methods +S1 and S2 may have or share. +

+ +

+A type implements any interface comprising any subset of its methods +and may therefore implement several distinct interfaces. For +instance, all types implement the empty interface: +

+ +
+interface{}
+
+ +

+Similarly, consider this interface specification, +which appears within a type declaration +to define an interface called Locker: +

+ +
+type Locker interface {
+	Lock()
+	Unlock()
+}
+
+ +

+If S1 and S2 also implement +

+ +
+func (p T) Lock() { … }
+func (p T) Unlock() { … }
+
+ +

+they implement the Locker interface as well +as the File interface. +

+ +

+An interface T may use a (possibly qualified) interface type +name E in place of a method specification. This is called +embedding interface E in T. +The method set of T is the union +of the method sets of T’s explicitly declared methods and of +T’s embedded interfaces. +

+ +
+type Reader interface {
+	Read(p []byte) (n int, err error)
+	Close() error
+}
+
+type Writer interface {
+	Write(p []byte) (n int, err error)
+	Close() error
+}
+
+// ReadWriter's methods are Read, Write, and Close.
+type ReadWriter interface {
+	Reader  // includes methods of Reader in ReadWriter's method set
+	Writer  // includes methods of Writer in ReadWriter's method set
+}
+
+ +

+A union of method sets contains the (exported and non-exported) +methods of each method set exactly once, and methods with the +same names must +have identical signatures. +

+ +
+type ReadCloser interface {
+	Reader   // includes methods of Reader in ReadCloser's method set
+	Close()  // illegal: signatures of Reader.Close and Close are different
+}
+
+ +

+An interface type T may not embed itself +or any interface type that embeds T, recursively. +

+ +
+// illegal: Bad cannot embed itself
+type Bad interface {
+	Bad
+}
+
+// illegal: Bad1 cannot embed itself using Bad2
+type Bad1 interface {
+	Bad2
+}
+type Bad2 interface {
+	Bad1
+}
+
+ +

Map types

+ +

+A map is an unordered group of elements of one type, called the +element type, indexed by a set of unique keys of another type, +called the key type. +The value of an uninitialized map is nil. +

+ +
+MapType     = "map" "[" KeyType "]" ElementType .
+KeyType     = Type .
+
+ +

+The comparison operators +== and != must be fully defined +for operands of the key type; thus the key type must not be a function, map, or +slice. +If the key type is an interface type, these +comparison operators must be defined for the dynamic key values; +failure will cause a run-time panic. + +

+ +
+map[string]int
+map[*T]struct{ x, y float64 }
+map[string]interface{}
+
+ +

+The number of map elements is called its length. +For a map m, it can be discovered using the +built-in function len +and may change during execution. Elements may be added during execution +using assignments and retrieved with +index expressions; they may be removed with the +delete built-in function. +

+

+A new, empty map value is made using the built-in +function make, +which takes the map type and an optional capacity hint as arguments: +

+ +
+make(map[string]int)
+make(map[string]int, 100)
+
+ +

+The initial capacity does not bound its size: +maps grow to accommodate the number of items +stored in them, with the exception of nil maps. +A nil map is equivalent to an empty map except that no elements +may be added. + +

Channel types

+ +

+A channel provides a mechanism for +concurrently executing functions +to communicate by +sending and +receiving +values of a specified element type. +The value of an uninitialized channel is nil. +

+ +
+ChannelType = ( "chan" | "chan" "<-" | "<-" "chan" ) ElementType .
+
+ +

+The optional <- operator specifies the channel direction, +send or receive. If no direction is given, the channel is +bidirectional. +A channel may be constrained only to send or only to receive by +assignment or +explicit conversion. +

+ +
+chan T          // can be used to send and receive values of type T
+chan<- float64  // can only be used to send float64s
+<-chan int      // can only be used to receive ints
+
+ +

+The <- operator associates with the leftmost chan +possible: +

+ +
+chan<- chan int    // same as chan<- (chan int)
+chan<- <-chan int  // same as chan<- (<-chan int)
+<-chan <-chan int  // same as <-chan (<-chan int)
+chan (<-chan int)
+
+ +

+A new, initialized channel +value can be made using the built-in function +make, +which takes the channel type and an optional capacity as arguments: +

+ +
+make(chan int, 100)
+
+ +

+The capacity, in number of elements, sets the size of the buffer in the channel. +If the capacity is zero or absent, the channel is unbuffered and communication +succeeds only when both a sender and receiver are ready. Otherwise, the channel +is buffered and communication succeeds without blocking if the buffer +is not full (sends) or not empty (receives). +A nil channel is never ready for communication. +

+ +

+A channel may be closed with the built-in function +close. +The multi-valued assignment form of the +receive operator +reports whether a received value was sent before +the channel was closed. +

+ +

+A single channel may be used in +send statements, +receive operations, +and calls to the built-in functions +cap and +len +by any number of goroutines without further synchronization. +Channels act as first-in-first-out queues. +For example, if one goroutine sends values on a channel +and a second goroutine receives them, the values are +received in the order sent. +

+ +

Properties of types and values

+ +

Type identity

+ +

+Two types are either identical or different. +

+ +

+A defined type is always different from any other type. +Otherwise, two types are identical if their underlying type literals are +structurally equivalent; that is, they have the same literal structure and corresponding +components have identical types. In detail: +

+ +
    +
  • Two array types are identical if they have identical element types and + the same array length.
    • + +
  • Two slice types are identical if they have identical element types.
    • + +
  • Two struct types are identical if they have the same sequence of fields, + and if corresponding fields have the same names, and identical types, + and identical tags. + Non-exported field names from different + packages are always different.
    • + +
  • Two pointer types are identical if they have identical base types.
    • + +
  • Two function types are identical if they have the same number of parameters + and result values, corresponding parameter and result types are + identical, and either both functions are variadic or neither is. + Parameter and result names are not required to match.
    • + +
  • Two interface types are identical if they have the same set of methods + with the same names and identical function types. + Non-exported method names from different + packages are always different. The order of the methods is irrelevant.
    • + +
  • Two map types are identical if they have identical key and element types.
    • + +
  • Two channel types are identical if they have identical element types and + the same direction.
    • +
+ +

+Given the declarations +

+ +
+type (
+	A0 = []string
+	A1 = A0
+	A2 = struct{ a, b int }
+	A3 = int
+	A4 = func(A3, float64) *A0
+	A5 = func(x int, _ float64) *[]string
+)
+
+type (
+	B0 A0
+	B1 []string
+	B2 struct{ a, b int }
+	B3 struct{ a, c int }
+	B4 func(int, float64) *B0
+	B5 func(x int, y float64) *A1
+)
+
+type	C0 = B0
+
+ +

+these types are identical: +

+ +
+A0, A1, and []string
+A2 and struct{ a, b int }
+A3 and int
+A4, func(int, float64) *[]string, and A5
+
+B0 and C0
+[]int and []int
+struct{ a, b *T5 } and struct{ a, b *T5 }
+func(x int, y float64) *[]string, func(int, float64) (result *[]string), and A5
+
+ +

+B0 and B1 are different because they are new types +created by distinct type definitions; +func(int, float64) *B0 and func(x int, y float64) *[]string +are different because B0 is different from []string. +

+ + +

Assignability

+ +

+A value x is assignable to a variable of type T +("x is assignable to T") if one of the following conditions applies: +

+ +
    +
  • +x's type is identical to T. +
    • +
  • +x's type V and T have identical +underlying types and at least one of V +or T is not a defined type. +
    • +
  • +T is an interface type and +x implements T. +
    • +
  • +x is a bidirectional channel value, T is a channel type, +x's type V and T have identical element types, +and at least one of V or T is not a defined type. +
    • +
  • +x is the predeclared identifier nil and T +is a pointer, function, slice, map, channel, or interface type. +
    • +
  • +x is an untyped constant +representable +by a value of type T. +
    • +
+ + +

Representability

+ +

+A constant x is representable +by a value of type T if one of the following conditions applies: +

+ +
    +
  • +x is in the set of values determined by T. +
    • + +
  • +T is a floating-point type and x can be rounded to T's +precision without overflow. Rounding uses IEEE 754 round-to-even rules but with an IEEE +negative zero further simplified to an unsigned zero. Note that constant values never result +in an IEEE negative zero, NaN, or infinity. +
    • + +
  • +T is a complex type, and x's +components real(x) and imag(x) +are representable by values of T's component type (float32 or +float64). +
    • +
+ +
+x                   T           x is representable by a value of T because
+
+'a'                 byte        97 is in the set of byte values
+97                  rune        rune is an alias for int32, and 97 is in the set of 32-bit integers
+"foo"               string      "foo" is in the set of string values
+1024                int16       1024 is in the set of 16-bit integers
+42.0                byte        42 is in the set of unsigned 8-bit integers
+1e10                uint64      10000000000 is in the set of unsigned 64-bit integers
+2.718281828459045   float32     2.718281828459045 rounds to 2.7182817 which is in the set of float32 values
+-1e-1000            float64     -1e-1000 rounds to IEEE -0.0 which is further simplified to 0.0
+0i                  int         0 is an integer value
+(42 + 0i)           float32     42.0 (with zero imaginary part) is in the set of float32 values
+
+ +
+x                   T           x is not representable by a value of T because
+
+0                   bool        0 is not in the set of boolean values
+'a'                 string      'a' is a rune, it is not in the set of string values
+1024                byte        1024 is not in the set of unsigned 8-bit integers
+-1                  uint16      -1 is not in the set of unsigned 16-bit integers
+1.1                 int         1.1 is not an integer value
+42i                 float32     (0 + 42i) is not in the set of float32 values
+1e1000              float64     1e1000 overflows to IEEE +Inf after rounding
+
+ + +

Blocks

+ +

+A block is a possibly empty sequence of declarations and statements +within matching brace brackets. +

+ +
+Block = "{" StatementList "}" .
+StatementList = { Statement ";" } .
+
+ +

+In addition to explicit blocks in the source code, there are implicit blocks: +

+ +
    +
  1. The universe block encompasses all Go source text.
    2. + +
  2. Each package has a package block containing all + Go source text for that package.
    3. + +
  3. Each file has a file block containing all Go source text + in that file.
    4. + +
  4. Each "if", + "for", and + "switch" + statement is considered to be in its own implicit block.
    5. + +
  5. Each clause in a "switch" + or "select" statement + acts as an implicit block.
    6. +
+ +

+Blocks nest and influence scoping. +

+ + +

Declarations and scope

+ +

+A declaration binds a non-blank identifier to a +constant, +type, +variable, +function, +label, or +package. +Every identifier in a program must be declared. +No identifier may be declared twice in the same block, and +no identifier may be declared in both the file and package block. +

+ +

+The blank identifier may be used like any other identifier +in a declaration, but it does not introduce a binding and thus is not declared. +In the package block, the identifier init may only be used for +init function declarations, +and like the blank identifier it does not introduce a new binding. +

+ +
+Declaration   = ConstDecl | TypeDecl | VarDecl .
+TopLevelDecl  = Declaration | FunctionDecl | MethodDecl .
+
+ +

+The scope of a declared identifier is the extent of source text in which +the identifier denotes the specified constant, type, variable, function, label, or package. +

+ +

+Go is lexically scoped using blocks: +

+ +
    +
  1. The scope of a predeclared identifier is the universe block.
    2. + +
  2. The scope of an identifier denoting a constant, type, variable, + or function (but not method) declared at top level (outside any + function) is the package block.
    3. + +
  3. The scope of the package name of an imported package is the file block + of the file containing the import declaration.
    4. + +
  4. The scope of an identifier denoting a method receiver, function parameter, + or result variable is the function body.
    5. + +
  5. The scope of a constant or variable identifier declared + inside a function begins at the end of the ConstSpec or VarSpec + (ShortVarDecl for short variable declarations) + and ends at the end of the innermost containing block.
    6. + +
  6. The scope of a type identifier declared inside a function + begins at the identifier in the TypeSpec + and ends at the end of the innermost containing block.
    7. +
+ +

+An identifier declared in a block may be redeclared in an inner block. +While the identifier of the inner declaration is in scope, it denotes +the entity declared by the inner declaration. +

+ +

+The package clause is not a declaration; the package name +does not appear in any scope. Its purpose is to identify the files belonging +to the same package and to specify the default package name for import +declarations. +

+ + +

Label scopes

+ +

+Labels are declared by labeled statements and are +used in the "break", +"continue", and +"goto" statements. +It is illegal to define a label that is never used. +In contrast to other identifiers, labels are not block scoped and do +not conflict with identifiers that are not labels. The scope of a label +is the body of the function in which it is declared and excludes +the body of any nested function. +

+ + +

Blank identifier

+ +

+The blank identifier is represented by the underscore character _. +It serves as an anonymous placeholder instead of a regular (non-blank) +identifier and has special meaning in declarations, +as an operand, and in assignments. +

+ + +

Predeclared identifiers

+ +

+The following identifiers are implicitly declared in the +universe block: +

+
+Types:
+	bool byte complex64 complex128 error float32 float64
+	int int8 int16 int32 int64 rune string
+	uint uint8 uint16 uint32 uint64 uintptr
+
+Constants:
+	true false iota
+
+Zero value:
+	nil
+
+Functions:
+	append cap close complex copy delete imag len
+	make new panic print println real recover
+
+ + +

Exported identifiers

+ +

+An identifier may be exported to permit access to it from another package. +An identifier is exported if both: +

+
    +
  1. the first character of the identifier's name is a Unicode upper case + letter (Unicode class "Lu"); and
    2. +
  2. the identifier is declared in the package block + or it is a field name or + method name.
    3. +
+

+All other identifiers are not exported. +

+ + +

Uniqueness of identifiers

+ +

+Given a set of identifiers, an identifier is called unique if it is +different from every other in the set. +Two identifiers are different if they are spelled differently, or if they +appear in different packages and are not +exported. Otherwise, they are the same. +

+ +

Constant declarations

+ +

+A constant declaration binds a list of identifiers (the names of +the constants) to the values of a list of constant expressions. +The number of identifiers must be equal +to the number of expressions, and the nth identifier on +the left is bound to the value of the nth expression on the +right. +

+ +
+ConstDecl      = "const" ( ConstSpec | "(" { ConstSpec ";" } ")" ) .
+ConstSpec      = IdentifierList [ [ Type ] "=" ExpressionList ] .
+
+IdentifierList = identifier { "," identifier } .
+ExpressionList = Expression { "," Expression } .
+
+ +

+If the type is present, all constants take the type specified, and +the expressions must be assignable to that type. +If the type is omitted, the constants take the +individual types of the corresponding expressions. +If the expression values are untyped constants, +the declared constants remain untyped and the constant identifiers +denote the constant values. For instance, if the expression is a +floating-point literal, the constant identifier denotes a floating-point +constant, even if the literal's fractional part is zero. +

+ +
+const Pi float64 = 3.14159265358979323846
+const zero = 0.0         // untyped floating-point constant
+const (
+	size int64 = 1024
+	eof        = -1  // untyped integer constant
+)
+const a, b, c = 3, 4, "foo"  // a = 3, b = 4, c = "foo", untyped integer and string constants
+const u, v float32 = 0, 3    // u = 0.0, v = 3.0
+
+ +

+Within a parenthesized const declaration list the +expression list may be omitted from any but the first ConstSpec. +Such an empty list is equivalent to the textual substitution of the +first preceding non-empty expression list and its type if any. +Omitting the list of expressions is therefore equivalent to +repeating the previous list. The number of identifiers must be equal +to the number of expressions in the previous list. +Together with the iota constant generator +this mechanism permits light-weight declaration of sequential values: +

+ +
+const (
+	Sunday = iota
+	Monday
+	Tuesday
+	Wednesday
+	Thursday
+	Friday
+	Partyday
+	numberOfDays  // this constant is not exported
+)
+
+ + +

Iota

+ +

+Within a constant declaration, the predeclared identifier +iota represents successive untyped integer +constants. Its value is the index of the respective ConstSpec +in that constant declaration, starting at zero. +It can be used to construct a set of related constants: +

+ +
+const (
+	c0 = iota  // c0 == 0
+	c1 = iota  // c1 == 1
+	c2 = iota  // c2 == 2
+)
+
+const (
+	a = 1 << iota  // a == 1  (iota == 0)
+	b = 1 << iota  // b == 2  (iota == 1)
+	c = 3          // c == 3  (iota == 2, unused)
+	d = 1 << iota  // d == 8  (iota == 3)
+)
+
+const (
+	u         = iota * 42  // u == 0     (untyped integer constant)
+	v float64 = iota * 42  // v == 42.0  (float64 constant)
+	w         = iota * 42  // w == 84    (untyped integer constant)
+)
+
+const x = iota  // x == 0
+const y = iota  // y == 0
+
+ +

+By definition, multiple uses of iota in the same ConstSpec all have the same value: +

+ +
+const (
+	bit0, mask0 = 1 << iota, 1<<iota - 1  // bit0 == 1, mask0 == 0  (iota == 0)
+	bit1, mask1                           // bit1 == 2, mask1 == 1  (iota == 1)
+	_, _                                  //                        (iota == 2, unused)
+	bit3, mask3                           // bit3 == 8, mask3 == 7  (iota == 3)
+)
+
+ +

+This last example exploits the implicit repetition +of the last non-empty expression list. +

+ + +

Type declarations

+ +

+A type declaration binds an identifier, the type name, to a type. +Type declarations come in two forms: alias declarations and type definitions. +

+ +
+TypeDecl = "type" ( TypeSpec | "(" { TypeSpec ";" } ")" ) .
+TypeSpec = AliasDecl | TypeDef .
+
+ +

Alias declarations

+ +

+An alias declaration binds an identifier to the given type. +

+ +
+AliasDecl = identifier "=" Type .
+
+ +

+Within the scope of +the identifier, it serves as an alias for the type. +

+ +
+type (
+	nodeList = []*Node  // nodeList and []*Node are identical types
+	Polar    = polar    // Polar and polar denote identical types
+)
+
+ + +

Type definitions

+ +

+A type definition creates a new, distinct type with the same +underlying type and operations as the given type, +and binds an identifier to it. +

+ +
+TypeDef = identifier Type .
+
+ +

+The new type is called a defined type. +It is different from any other type, +including the type it is created from. +

+ +
+type (
+	Point struct{ x, y float64 }  // Point and struct{ x, y float64 } are different types
+	polar Point                   // polar and Point denote different types
+)
+
+type TreeNode struct {
+	left, right *TreeNode
+	value *Comparable
+}
+
+type Block interface {
+	BlockSize() int
+	Encrypt(src, dst []byte)
+	Decrypt(src, dst []byte)
+}
+
+ +

+A defined type may have methods associated with it. +It does not inherit any methods bound to the given type, +but the method set +of an interface type or of elements of a composite type remains unchanged: +

+ +
+// A Mutex is a data type with two methods, Lock and Unlock.
+type Mutex struct         { /* Mutex fields */ }
+func (m *Mutex) Lock()    { /* Lock implementation */ }
+func (m *Mutex) Unlock()  { /* Unlock implementation */ }
+
+// NewMutex has the same composition as Mutex but its method set is empty.
+type NewMutex Mutex
+
+// The method set of PtrMutex's underlying type *Mutex remains unchanged,
+// but the method set of PtrMutex is empty.
+type PtrMutex *Mutex
+
+// The method set of *PrintableMutex contains the methods
+// Lock and Unlock bound to its embedded field Mutex.
+type PrintableMutex struct {
+	Mutex
+}
+
+// MyBlock is an interface type that has the same method set as Block.
+type MyBlock Block
+
+ +

+Type definitions may be used to define different boolean, numeric, +or string types and associate methods with them: +

+ +
+type TimeZone int
+
+const (
+	EST TimeZone = -(5 + iota)
+	CST
+	MST
+	PST
+)
+
+func (tz TimeZone) String() string {
+	return fmt.Sprintf("GMT%+dh", tz)
+}
+
+ + +

Variable declarations

+ +

+A variable declaration creates one or more variables, +binds corresponding identifiers to them, and gives each a type and an initial value. +

+ +
+VarDecl     = "var" ( VarSpec | "(" { VarSpec ";" } ")" ) .
+VarSpec     = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) .
+
+ +
+var i int
+var U, V, W float64
+var k = 0
+var x, y float32 = -1, -2
+var (
+	i       int
+	u, v, s = 2.0, 3.0, "bar"
+)
+var re, im = complexSqrt(-1)
+var _, found = entries[name]  // map lookup; only interested in "found"
+
+ +

+If a list of expressions is given, the variables are initialized +with the expressions following the rules for assignments. +Otherwise, each variable is initialized to its zero value. +

+ +

+If a type is present, each variable is given that type. +Otherwise, each variable is given the type of the corresponding +initialization value in the assignment. +If that value is an untyped constant, it is first implicitly +converted to its default type; +if it is an untyped boolean value, it is first implicitly converted to type bool. +The predeclared value nil cannot be used to initialize a variable +with no explicit type. +

+ +
+var d = math.Sin(0.5)  // d is float64
+var i = 42             // i is int
+var t, ok = x.(T)      // t is T, ok is bool
+var n = nil            // illegal
+
+ +

+Implementation restriction: A compiler may make it illegal to declare a variable +inside a function body if the variable is +never used. +

+ +

Short variable declarations

+ +

+A short variable declaration uses the syntax: +

+ +
+ShortVarDecl = IdentifierList ":=" ExpressionList .
+
+ +

+It is shorthand for a regular variable declaration +with initializer expressions but no types: +

+ +
+"var" IdentifierList = ExpressionList .
+
+ +
+i, j := 0, 10
+f := func() int { return 7 }
+ch := make(chan int)
+r, w, _ := os.Pipe()  // os.Pipe() returns a connected pair of Files and an error, if any
+_, y, _ := coord(p)   // coord() returns three values; only interested in y coordinate
+
+ +

+Unlike regular variable declarations, a short variable declaration may redeclare +variables provided they were originally declared earlier in the same block +(or the parameter lists if the block is the function body) with the same type, +and at least one of the non-blank variables is new. +As a consequence, redeclaration can only appear in a multi-variable short declaration. +Redeclaration does not introduce a new variable; it just assigns a new value to the original. +

+ +
+field1, offset := nextField(str, 0)
+field2, offset := nextField(str, offset)  // redeclares offset
+a, a := 1, 2                              // illegal: double declaration of a or no new variable if a was declared elsewhere
+
+ +

+Short variable declarations may appear only inside functions. +In some contexts such as the initializers for +"if", +"for", or +"switch" statements, +they can be used to declare local temporary variables. +

+ +

Function declarations

+ +

+A function declaration binds an identifier, the function name, +to a function. +

+ +
+FunctionDecl = "func" FunctionName Signature [ FunctionBody ] .
+FunctionName = identifier .
+FunctionBody = Block .
+
+ +

+If the function's signature declares +result parameters, the function body's statement list must end in +a terminating statement. +

+ +
+func IndexRune(s string, r rune) int {
+	for i, c := range s {
+		if c == r {
+			return i
+		}
+	}
+	// invalid: missing return statement
+}
+
+ +

+A function declaration may omit the body. Such a declaration provides the +signature for a function implemented outside Go, such as an assembly routine. +

+ +
+func min(x int, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+func flushICache(begin, end uintptr)  // implemented externally
+
+ +

Method declarations

+ +

+A method is a function with a receiver. +A method declaration binds an identifier, the method name, to a method, +and associates the method with the receiver's base type. +

+ +
+MethodDecl = "func" Receiver MethodName Signature [ FunctionBody ] .
+Receiver   = Parameters .
+
+ +

+The receiver is specified via an extra parameter section preceding the method +name. That parameter section must declare a single non-variadic parameter, the receiver. +Its type must be a defined type T or a +pointer to a defined type T. T is called the receiver +base type. A receiver base type cannot be a pointer or interface type and +it must be defined in the same package as the method. +The method is said to be bound to its receiver base type and the method name +is visible only within selectors for type T +or *T. +

+ +

+A non-blank receiver identifier must be +unique in the method signature. +If the receiver's value is not referenced inside the body of the method, +its identifier may be omitted in the declaration. The same applies in +general to parameters of functions and methods. +

+ +

+For a base type, the non-blank names of methods bound to it must be unique. +If the base type is a struct type, +the non-blank method and field names must be distinct. +

+ +

+Given defined type Point, the declarations +

+ +
+func (p *Point) Length() float64 {
+	return math.Sqrt(p.x * p.x + p.y * p.y)
+}
+
+func (p *Point) Scale(factor float64) {
+	p.x *= factor
+	p.y *= factor
+}
+
+ +

+bind the methods Length and Scale, +with receiver type *Point, +to the base type Point. +

+ +

+The type of a method is the type of a function with the receiver as first +argument. For instance, the method Scale has type +

+ +
+func(p *Point, factor float64)
+
+ +

+However, a function declared this way is not a method. +

+ + +

Expressions

+ +

+An expression specifies the computation of a value by applying +operators and functions to operands. +

+ +

Operands

+ +

+Operands denote the elementary values in an expression. An operand may be a +literal, a (possibly qualified) +non-blank identifier denoting a +constant, +variable, or +function, +or a parenthesized expression. +

+ +

+The blank identifier may appear as an +operand only on the left-hand side of an assignment. +

+ +
+Operand     = Literal | OperandName | "(" Expression ")" .
+Literal     = BasicLit | CompositeLit | FunctionLit .
+BasicLit    = int_lit | float_lit | imaginary_lit | rune_lit | string_lit .
+OperandName = identifier | QualifiedIdent .
+
+ +

Qualified identifiers

+ +

+A qualified identifier is an identifier qualified with a package name prefix. +Both the package name and the identifier must not be +blank. +

+ +
+QualifiedIdent = PackageName "." identifier .
+
+ +

+A qualified identifier accesses an identifier in a different package, which +must be imported. +The identifier must be exported and +declared in the package block of that package. +

+ +
+math.Sin	// denotes the Sin function in package math
+
+ +

Composite literals

+ +

+Composite literals construct values for structs, arrays, slices, and maps +and create a new value each time they are evaluated. +They consist of the type of the literal followed by a brace-bound list of elements. +Each element may optionally be preceded by a corresponding key. +

+ +
+CompositeLit  = LiteralType LiteralValue .
+LiteralType   = StructType | ArrayType | "[" "..." "]" ElementType |
+                SliceType | MapType | TypeName .
+LiteralValue  = "{" [ ElementList [ "," ] ] "}" .
+ElementList   = KeyedElement { "," KeyedElement } .
+KeyedElement  = [ Key ":" ] Element .
+Key           = FieldName | Expression | LiteralValue .
+FieldName     = identifier .
+Element       = Expression | LiteralValue .
+
+ +

+The LiteralType's underlying type must be a struct, array, slice, or map type +(the grammar enforces this constraint except when the type is given +as a TypeName). +The types of the elements and keys must be assignable +to the respective field, element, and key types of the literal type; +there is no additional conversion. +The key is interpreted as a field name for struct literals, +an index for array and slice literals, and a key for map literals. +For map literals, all elements must have a key. It is an error +to specify multiple elements with the same field name or +constant key value. For non-constant map keys, see the section on +evaluation order. +

+ +

+For struct literals the following rules apply: +

+
    +
  • A key must be a field name declared in the struct type. +
    • +
  • An element list that does not contain any keys must + list an element for each struct field in the + order in which the fields are declared. +
    • +
  • If any element has a key, every element must have a key. +
    • +
  • An element list that contains keys does not need to + have an element for each struct field. Omitted fields + get the zero value for that field. +
    • +
  • A literal may omit the element list; such a literal evaluates + to the zero value for its type. +
    • +
  • It is an error to specify an element for a non-exported + field of a struct belonging to a different package. +
    • +
+ +

+Given the declarations +

+
+type Point3D struct { x, y, z float64 }
+type Line struct { p, q Point3D }
+
+ +

+one may write +

+ +
+origin := Point3D{}                            // zero value for Point3D
+line := Line{origin, Point3D{y: -4, z: 12.3}}  // zero value for line.q.x
+
+ +

+For array and slice literals the following rules apply: +

+
    +
  • Each element has an associated integer index marking + its position in the array. +
    • +
  • An element with a key uses the key as its index. The + key must be a non-negative constant + representable by + a value of type int; and if it is typed + it must be of integer type. +
    • +
  • An element without a key uses the previous element's index plus one. + If the first element has no key, its index is zero. +
    • +
+ +

+Taking the address of a composite literal +generates a pointer to a unique variable initialized +with the literal's value. +

+ +
+var pointer *Point3D = &Point3D{y: 1000}
+
+ +

+Note that the zero value for a slice or map +type is not the same as an initialized but empty value of the same type. +Consequently, taking the address of an empty slice or map composite literal +does not have the same effect as allocating a new slice or map value with +new. +

+ +
+p1 := &[]int{}    // p1 points to an initialized, empty slice with value []int{} and length 0
+p2 := new([]int)  // p2 points to an uninitialized slice with value nil and length 0
+
+ +

+The length of an array literal is the length specified in the literal type. +If fewer elements than the length are provided in the literal, the missing +elements are set to the zero value for the array element type. +It is an error to provide elements with index values outside the index range +of the array. The notation ... specifies an array length equal +to the maximum element index plus one. +

+ +
+buffer := [10]string{}             // len(buffer) == 10
+intSet := [6]int{1, 2, 3, 5}       // len(intSet) == 6
+days := [...]string{"Sat", "Sun"}  // len(days) == 2
+
+ +

+A slice literal describes the entire underlying array literal. +Thus the length and capacity of a slice literal are the maximum +element index plus one. A slice literal has the form +

+ +
+[]T{x1, x2, … xn}
+
+ +

+and is shorthand for a slice operation applied to an array: +

+ +
+tmp := [n]T{x1, x2, … xn}
+tmp[0 : n]
+
+ +

+Within a composite literal of array, slice, or map type T, +elements or map keys that are themselves composite literals may elide the respective +literal type if it is identical to the element or key type of T. +Similarly, elements or keys that are addresses of composite literals may elide +the &T when the element or key type is *T. +

+ +
+[...]Point{{1.5, -3.5}, {0, 0}}     // same as [...]Point{Point{1.5, -3.5}, Point{0, 0}}
+[][]int{{1, 2, 3}, {4, 5}}          // same as [][]int{[]int{1, 2, 3}, []int{4, 5}}
+[][]Point{{{0, 1}, {1, 2}}}         // same as [][]Point{[]Point{Point{0, 1}, Point{1, 2}}}
+map[string]Point{"orig": {0, 0}}    // same as map[string]Point{"orig": Point{0, 0}}
+map[Point]string{{0, 0}: "orig"}    // same as map[Point]string{Point{0, 0}: "orig"}
+
+type PPoint *Point
+[2]*Point{{1.5, -3.5}, {}}          // same as [2]*Point{&Point{1.5, -3.5}, &Point{}}
+[2]PPoint{{1.5, -3.5}, {}}          // same as [2]PPoint{PPoint(&Point{1.5, -3.5}), PPoint(&Point{})}
+
+ +

+A parsing ambiguity arises when a composite literal using the +TypeName form of the LiteralType appears as an operand between the +keyword and the opening brace of the block +of an "if", "for", or "switch" statement, and the composite literal +is not enclosed in parentheses, square brackets, or curly braces. +In this rare case, the opening brace of the literal is erroneously parsed +as the one introducing the block of statements. To resolve the ambiguity, +the composite literal must appear within parentheses. +

+ +
+if x == (T{a,b,c}[i]) { … }
+if (x == T{a,b,c}[i]) { … }
+
+ +

+Examples of valid array, slice, and map literals: +

+ +
+// list of prime numbers
+primes := []int{2, 3, 5, 7, 9, 2147483647}
+
+// vowels[ch] is true if ch is a vowel
+vowels := [128]bool{'a': true, 'e': true, 'i': true, 'o': true, 'u': true, 'y': true}
+
+// the array [10]float32{-1, 0, 0, 0, -0.1, -0.1, 0, 0, 0, -1}
+filter := [10]float32{-1, 4: -0.1, -0.1, 9: -1}
+
+// frequencies in Hz for equal-tempered scale (A4 = 440Hz)
+noteFrequency := map[string]float32{
+	"C0": 16.35, "D0": 18.35, "E0": 20.60, "F0": 21.83,
+	"G0": 24.50, "A0": 27.50, "B0": 30.87,
+}
+
+ + +

Function literals

+ +

+A function literal represents an anonymous function. +

+ +
+FunctionLit = "func" Signature FunctionBody .
+
+ +
+func(a, b int, z float64) bool { return a*b < int(z) }
+
+ +

+A function literal can be assigned to a variable or invoked directly. +

+ +
+f := func(x, y int) int { return x + y }
+func(ch chan int) { ch <- ACK }(replyChan)
+
+ +

+Function literals are closures: they may refer to variables +defined in a surrounding function. Those variables are then shared between +the surrounding function and the function literal, and they survive as long +as they are accessible. +

+ + +

Primary expressions

+ +

+Primary expressions are the operands for unary and binary expressions. +

+ +
+PrimaryExpr =
+	Operand |
+	Conversion |
+	MethodExpr |
+	PrimaryExpr Selector |
+	PrimaryExpr Index |
+	PrimaryExpr Slice |
+	PrimaryExpr TypeAssertion |
+	PrimaryExpr Arguments .
+
+Selector       = "." identifier .
+Index          = "[" Expression "]" .
+Slice          = "[" [ Expression ] ":" [ Expression ] "]" |
+                 "[" [ Expression ] ":" Expression ":" Expression "]" .
+TypeAssertion  = "." "(" Type ")" .
+Arguments      = "(" [ ( ExpressionList | Type [ "," ExpressionList ] ) [ "..." ] [ "," ] ] ")" .
+
+ + +
+x
+2
+(s + ".txt")
+f(3.1415, true)
+Point{1, 2}
+m["foo"]
+s[i : j + 1]
+obj.color
+f.p[i].x()
+
+ + +

Selectors

+ +

+For a primary expression x +that is not a package name, the +selector expression +

+ +
+x.f
+
+ +

+denotes the field or method f of the value x +(or sometimes *x; see below). +The identifier f is called the (field or method) selector; +it must not be the blank identifier. +The type of the selector expression is the type of f. +If x is a package name, see the section on +qualified identifiers. +

+ +

+A selector f may denote a field or method f of +a type T, or it may refer +to a field or method f of a nested +embedded field of T. +The number of embedded fields traversed +to reach f is called its depth in T. +The depth of a field or method f +declared in T is zero. +The depth of a field or method f declared in +an embedded field A in T is the +depth of f in A plus one. +

+ +

+The following rules apply to selectors: +

+ +
    +
  1. +For a value x of type T or *T +where T is not a pointer or interface type, +x.f denotes the field or method at the shallowest depth +in T where there +is such an f. +If there is not exactly one f +with shallowest depth, the selector expression is illegal. +
    2. + +
  2. +For a value x of type I where I +is an interface type, x.f denotes the actual method with name +f of the dynamic value of x. +If there is no method with name f in the +method set of I, the selector +expression is illegal. +
    3. + +
  3. +As an exception, if the type of x is a defined +pointer type and (*x).f is a valid selector expression denoting a field +(but not a method), x.f is shorthand for (*x).f. +
    4. + +
  4. +In all other cases, x.f is illegal. +
    5. + +
  5. +If x is of pointer type and has the value +nil and x.f denotes a struct field, +assigning to or evaluating x.f +causes a run-time panic. +
    6. + +
  6. +If x is of interface type and has the value +nil, calling or +evaluating the method x.f +causes a run-time panic. +
    7. +
+ +

+For example, given the declarations: +

+ +
+type T0 struct {
+	x int
+}
+
+func (*T0) M0()
+
+type T1 struct {
+	y int
+}
+
+func (T1) M1()
+
+type T2 struct {
+	z int
+	T1
+	*T0
+}
+
+func (*T2) M2()
+
+type Q *T2
+
+var t T2     // with t.T0 != nil
+var p *T2    // with p != nil and (*p).T0 != nil
+var q Q = p
+
+ +

+one may write: +

+ +
+t.z          // t.z
+t.y          // t.T1.y
+t.x          // (*t.T0).x
+
+p.z          // (*p).z
+p.y          // (*p).T1.y
+p.x          // (*(*p).T0).x
+
+q.x          // (*(*q).T0).x        (*q).x is a valid field selector
+
+p.M0()       // ((*p).T0).M0()      M0 expects *T0 receiver
+p.M1()       // ((*p).T1).M1()      M1 expects T1 receiver
+p.M2()       // p.M2()              M2 expects *T2 receiver
+t.M2()       // (&t).M2()           M2 expects *T2 receiver, see section on Calls
+
+ +

+but the following is invalid: +

+ +
+q.M0()       // (*q).M0 is valid but not a field selector
+
+ + +

Method expressions

+ +

+If M is in the method set of type T, +T.M is a function that is callable as a regular function +with the same arguments as M prefixed by an additional +argument that is the receiver of the method. +

+ +
+MethodExpr    = ReceiverType "." MethodName .
+ReceiverType  = Type .
+
+ +

+Consider a struct type T with two methods, +Mv, whose receiver is of type T, and +Mp, whose receiver is of type *T. +

+ +
+type T struct {
+	a int
+}
+func (tv  T) Mv(a int) int         { return 0 }  // value receiver
+func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver
+
+var t T
+
+ +

+The expression +

+ +
+T.Mv
+
+ +

+yields a function equivalent to Mv but +with an explicit receiver as its first argument; it has signature +

+ +
+func(tv T, a int) int
+
+ +

+That function may be called normally with an explicit receiver, so +these five invocations are equivalent: +

+ +
+t.Mv(7)
+T.Mv(t, 7)
+(T).Mv(t, 7)
+f1 := T.Mv; f1(t, 7)
+f2 := (T).Mv; f2(t, 7)
+
+ +

+Similarly, the expression +

+ +
+(*T).Mp
+
+ +

+yields a function value representing Mp with signature +

+ +
+func(tp *T, f float32) float32
+
+ +

+For a method with a value receiver, one can derive a function +with an explicit pointer receiver, so +

+ +
+(*T).Mv
+
+ +

+yields a function value representing Mv with signature +

+ +
+func(tv *T, a int) int
+
+ +

+Such a function indirects through the receiver to create a value +to pass as the receiver to the underlying method; +the method does not overwrite the value whose address is passed in +the function call. +

+ +

+The final case, a value-receiver function for a pointer-receiver method, +is illegal because pointer-receiver methods are not in the method set +of the value type. +

+ +

+Function values derived from methods are called with function call syntax; +the receiver is provided as the first argument to the call. +That is, given f := T.Mv, f is invoked +as f(t, 7) not t.f(7). +To construct a function that binds the receiver, use a +function literal or +method value. +

+ +

+It is legal to derive a function value from a method of an interface type. +The resulting function takes an explicit receiver of that interface type. +

+ +

Method values

+ +

+If the expression x has static type T and +M is in the method set of type T, +x.M is called a method value. +The method value x.M is a function value that is callable +with the same arguments as a method call of x.M. +The expression x is evaluated and saved during the evaluation of the +method value; the saved copy is then used as the receiver in any calls, +which may be executed later. +

+ +
+type S struct { *T }
+type T int
+func (t T) M() { print(t) }
+
+t := new(T)
+s := S{T: t}
+f := t.M                    // receiver *t is evaluated and stored in f
+g := s.M                    // receiver *(s.T) is evaluated and stored in g
+*t = 42                     // does not affect stored receivers in f and g
+
+ +

+The type T may be an interface or non-interface type. +

+ +

+As in the discussion of method expressions above, +consider a struct type T with two methods, +Mv, whose receiver is of type T, and +Mp, whose receiver is of type *T. +

+ +
+type T struct {
+	a int
+}
+func (tv  T) Mv(a int) int         { return 0 }  // value receiver
+func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver
+
+var t T
+var pt *T
+func makeT() T
+
+ +

+The expression +

+ +
+t.Mv
+
+ +

+yields a function value of type +

+ +
+func(int) int
+
+ +

+These two invocations are equivalent: +

+ +
+t.Mv(7)
+f := t.Mv; f(7)
+
+ +

+Similarly, the expression +

+ +
+pt.Mp
+
+ +

+yields a function value of type +

+ +
+func(float32) float32
+
+ +

+As with selectors, a reference to a non-interface method with a value receiver +using a pointer will automatically dereference that pointer: pt.Mv is equivalent to (*pt).Mv. +

+ +

+As with method calls, a reference to a non-interface method with a pointer receiver +using an addressable value will automatically take the address of that value: t.Mp is equivalent to (&t).Mp. +

+ +
+f := t.Mv; f(7)   // like t.Mv(7)
+f := pt.Mp; f(7)  // like pt.Mp(7)
+f := pt.Mv; f(7)  // like (*pt).Mv(7)
+f := t.Mp; f(7)   // like (&t).Mp(7)
+f := makeT().Mp   // invalid: result of makeT() is not addressable
+
+ +

+Although the examples above use non-interface types, it is also legal to create a method value +from a value of interface type. +

+ +
+var i interface { M(int) } = myVal
+f := i.M; f(7)  // like i.M(7)
+
+ + +

Index expressions

+ +

+A primary expression of the form +

+ +
+a[x]
+
+ +

+denotes the element of the array, pointer to array, slice, string or map a indexed by x. +The value x is called the index or map key, respectively. +The following rules apply: +

+ +

+If a is not a map: +

+
    +
  • the index x must be of integer type or an untyped constant
    • +
  • a constant index must be non-negative and + representable by a value of type int
    • +
  • a constant index that is untyped is given type int
    • +
  • the index x is in range if 0 <= x < len(a), + otherwise it is out of range
    • +
+ +

+For a of array type A: +

+
    +
  • a constant index must be in range
    • +
  • if x is out of range at run time, + a run-time panic occurs
    • +
  • a[x] is the array element at index x and the type of + a[x] is the element type of A
    • +
+ +

+For a of pointer to array type: +

+
    +
  • a[x] is shorthand for (*a)[x]
    • +
+ +

+For a of slice type S: +

+
    +
  • if x is out of range at run time, + a run-time panic occurs
    • +
  • a[x] is the slice element at index x and the type of + a[x] is the element type of S
    • +
+ +

+For a of string type: +

+
    +
  • a constant index must be in range + if the string a is also constant
    • +
  • if x is out of range at run time, + a run-time panic occurs
    • +
  • a[x] is the non-constant byte value at index x and the type of + a[x] is byte
    • +
  • a[x] may not be assigned to
    • +
+ +

+For a of map type M: +

+
    +
  • x's type must be + assignable + to the key type of M
    • +
  • if the map contains an entry with key x, + a[x] is the map element with key x + and the type of a[x] is the element type of M
    • +
  • if the map is nil or does not contain such an entry, + a[x] is the zero value + for the element type of M
    • +
+ +

+Otherwise a[x] is illegal. +

+ +

+An index expression on a map a of type map[K]V +used in an assignment or initialization of the special form +

+ +
+v, ok = a[x]
+v, ok := a[x]
+var v, ok = a[x]
+
+ +

+yields an additional untyped boolean value. The value of ok is +true if the key x is present in the map, and +false otherwise. +

+ +

+Assigning to an element of a nil map causes a +run-time panic. +

+ + +

Slice expressions

+ +

+Slice expressions construct a substring or slice from a string, array, pointer +to array, or slice. There are two variants: a simple form that specifies a low +and high bound, and a full form that also specifies a bound on the capacity. +

+ +

Simple slice expressions

+ +

+For a string, array, pointer to array, or slice a, the primary expression +

+ +
+a[low : high]
+
+ +

+constructs a substring or slice. The indices low and +high select which elements of operand a appear +in the result. The result has indices starting at 0 and length equal to +high - low. +After slicing the array a +

+ +
+a := [5]int{1, 2, 3, 4, 5}
+s := a[1:4]
+
+ +

+the slice s has type []int, length 3, capacity 4, and elements +

+ +
+s[0] == 2
+s[1] == 3
+s[2] == 4
+
+ +

+For convenience, any of the indices may be omitted. A missing low +index defaults to zero; a missing high index defaults to the length of the +sliced operand: +

+ +
+a[2:]  // same as a[2 : len(a)]
+a[:3]  // same as a[0 : 3]
+a[:]   // same as a[0 : len(a)]
+
+ +

+If a is a pointer to an array, a[low : high] is shorthand for +(*a)[low : high]. +

+ +

+For arrays or strings, the indices are in range if +0 <= low <= high <= len(a), +otherwise they are out of range. +For slices, the upper index bound is the slice capacity cap(a) rather than the length. +A constant index must be non-negative and +representable by a value of type +int; for arrays or constant strings, constant indices must also be in range. +If both indices are constant, they must satisfy low <= high. +If the indices are out of range at run time, a run-time panic occurs. +

+ +

+Except for untyped strings, if the sliced operand is a string or slice, +the result of the slice operation is a non-constant value of the same type as the operand. +For untyped string operands the result is a non-constant value of type string. +If the sliced operand is an array, it must be addressable +and the result of the slice operation is a slice with the same element type as the array. +

+ +

+If the sliced operand of a valid slice expression is a nil slice, the result +is a nil slice. Otherwise, if the result is a slice, it shares its underlying +array with the operand. +

+ +
+var a [10]int
+s1 := a[3:7]   // underlying array of s1 is array a; &s1[2] == &a[5]
+s2 := s1[1:4]  // underlying array of s2 is underlying array of s1 which is array a; &s2[1] == &a[5]
+s2[1] = 42     // s2[1] == s1[2] == a[5] == 42; they all refer to the same underlying array element
+
+ + +

Full slice expressions

+ +

+For an array, pointer to array, or slice a (but not a string), the primary expression +

+ +
+a[low : high : max]
+
+ +

+constructs a slice of the same type, and with the same length and elements as the simple slice +expression a[low : high]. Additionally, it controls the resulting slice's capacity +by setting it to max - low. Only the first index may be omitted; it defaults to 0. +After slicing the array a +

+ +
+a := [5]int{1, 2, 3, 4, 5}
+t := a[1:3:5]
+
+ +

+the slice t has type []int, length 2, capacity 4, and elements +

+ +
+t[0] == 2
+t[1] == 3
+
+ +

+As for simple slice expressions, if a is a pointer to an array, +a[low : high : max] is shorthand for (*a)[low : high : max]. +If the sliced operand is an array, it must be addressable. +

+ +

+The indices are in range if 0 <= low <= high <= max <= cap(a), +otherwise they are out of range. +A constant index must be non-negative and +representable by a value of type +int; for arrays, constant indices must also be in range. +If multiple indices are constant, the constants that are present must be in range relative to each +other. +If the indices are out of range at run time, a run-time panic occurs. +

+ +

Type assertions

+ +

+For an expression x of interface type +and a type T, the primary expression +

+ +
+x.(T)
+
+ +

+asserts that x is not nil +and that the value stored in x is of type T. +The notation x.(T) is called a type assertion. +

+

+More precisely, if T is not an interface type, x.(T) asserts +that the dynamic type of x is identical +to the type T. +In this case, T must implement the (interface) type of x; +otherwise the type assertion is invalid since it is not possible for x +to store a value of type T. +If T is an interface type, x.(T) asserts that the dynamic type +of x implements the interface T. +

+

+If the type assertion holds, the value of the expression is the value +stored in x and its type is T. If the type assertion is false, +a run-time panic occurs. +In other words, even though the dynamic type of x +is known only at run time, the type of x.(T) is +known to be T in a correct program. +

+ +
+var x interface{} = 7          // x has dynamic type int and value 7
+i := x.(int)                   // i has type int and value 7
+
+type I interface { m() }
+
+func f(y I) {
+	s := y.(string)        // illegal: string does not implement I (missing method m)
+	r := y.(io.Reader)     // r has type io.Reader and the dynamic type of y must implement both I and io.Reader
+	…
+}
+
+ +

+A type assertion used in an assignment or initialization of the special form +

+ +
+v, ok = x.(T)
+v, ok := x.(T)
+var v, ok = x.(T)
+var v, ok interface{} = x.(T) // dynamic types of v and ok are T and bool
+
+ +

+yields an additional untyped boolean value. The value of ok is true +if the assertion holds. Otherwise it is false and the value of v is +the zero value for type T. +No run-time panic occurs in this case. +

+ + +

Calls

+ +

+Given an expression f of function type +F, +

+ +
+f(a1, a2, … an)
+
+ +

+calls f with arguments a1, a2, … an. +Except for one special case, arguments must be single-valued expressions +assignable to the parameter types of +F and are evaluated before the function is called. +The type of the expression is the result type +of F. +A method invocation is similar but the method itself +is specified as a selector upon a value of the receiver type for +the method. +

+ +
+math.Atan2(x, y)  // function call
+var pt *Point
+pt.Scale(3.5)     // method call with receiver pt
+
+ +

+In a function call, the function value and arguments are evaluated in +the usual order. +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 caller when the function returns. +

+ +

+Calling a nil function value +causes a run-time panic. +

+ +

+As a special case, if the return values of a function or method +g are equal in number and individually +assignable to the parameters of another function or method +f, then the call f(g(parameters_of_g)) +will invoke f after binding the return values of +g to the parameters of f in order. The call +of f must contain no parameters other than the call of g, +and g must have at least one return value. +If f has a final ... parameter, it is +assigned the return values of g that remain after +assignment of regular parameters. +

+ +
+func Split(s string, pos int) (string, string) {
+	return s[0:pos], s[pos:]
+}
+
+func Join(s, t string) string {
+	return s + t
+}
+
+if Join(Split(value, len(value)/2)) != value {
+	log.Panic("test fails")
+}
+
+ +

+A method call x.m() is valid if the method set +of (the type of) x contains m and the +argument list can be assigned to the parameter list of m. +If x is addressable and &x's method +set contains m, x.m() is shorthand +for (&x).m(): +

+ +
+var p Point
+p.Scale(3.5)
+
+ +

+There is no distinct method type and there are no method literals. +

+ +

Passing arguments to ... parameters

+ +

+If f is variadic with a final +parameter p of type ...T, then within f +the type of p is equivalent to type []T. +If f is invoked with no actual arguments for p, +the value passed to p is nil. +Otherwise, the value passed is a new slice +of type []T with a new underlying array whose successive elements +are the actual arguments, which all must be assignable +to T. The length and capacity of the slice is therefore +the number of arguments bound to p and may differ for each +call site. +

+ +

+Given the function and calls +

+
+func Greeting(prefix string, who ...string)
+Greeting("nobody")
+Greeting("hello:", "Joe", "Anna", "Eileen")
+
+ +

+within Greeting, who will have the value +nil in the first call, and +[]string{"Joe", "Anna", "Eileen"} in the second. +

+ +

+If the final argument is assignable to a slice type []T and +is followed by ..., it is passed unchanged as the value +for a ...T parameter. In this case no new slice is created. +

+ +

+Given the slice s and call +

+ +
+s := []string{"James", "Jasmine"}
+Greeting("goodbye:", s...)
+
+ +

+within Greeting, who will have the same value as s +with the same underlying array. +

+ + +

Operators

+ +

+Operators combine operands into expressions. +

+ +
+Expression = UnaryExpr | Expression binary_op Expression .
+UnaryExpr  = PrimaryExpr | unary_op UnaryExpr .
+
+binary_op  = "||" | "&&" | rel_op | add_op | mul_op .
+rel_op     = "==" | "!=" | "<" | "<=" | ">" | ">=" .
+add_op     = "+" | "-" | "|" | "^" .
+mul_op     = "*" | "/" | "%" | "<<" | ">>" | "&" | "&^" .
+
+unary_op   = "+" | "-" | "!" | "^" | "*" | "&" | "<-" .
+
+ +

+Comparisons are discussed elsewhere. +For other binary operators, the operand types must be identical +unless the operation involves shifts or untyped constants. +For operations involving constants only, see the section on +constant expressions. +

+ +

+Except for shift operations, if one operand is an untyped constant +and the other operand is not, the constant is implicitly converted +to the type of the other operand. +

+ +

+The right operand in a shift expression must have integer type +or be an untyped constant representable by a +value of type uint. +If the left operand of a non-constant shift expression is an untyped constant, +it is first implicitly converted to the type it would assume if the shift expression were +replaced by its left operand alone. +

+ +
+var a [1024]byte
+var s uint = 33
+
+// The results of the following examples are given for 64-bit ints.
+var i = 1<<s                   // 1 has type int
+var j int32 = 1<<s             // 1 has type int32; j == 0
+var k = uint64(1<<s)           // 1 has type uint64; k == 1<<33
+var m int = 1.0<<s             // 1.0 has type int; m == 1<<33
+var n = 1.0<<s == j            // 1.0 has type int32; n == true
+var o = 1<<s == 2<<s           // 1 and 2 have type int; o == false
+var p = 1<<s == 1<<33          // 1 has type int; p == true
+var u = 1.0<<s                 // illegal: 1.0 has type float64, cannot shift
+var u1 = 1.0<<s != 0           // illegal: 1.0 has type float64, cannot shift
+var u2 = 1<<s != 1.0           // illegal: 1 has type float64, cannot shift
+var v float32 = 1<<s           // illegal: 1 has type float32, cannot shift
+var w int64 = 1.0<<33          // 1.0<<33 is a constant shift expression; w == 1<<33
+var x = a[1.0<<s]              // panics: 1.0 has type int, but 1<<33 overflows array bounds
+var b = make([]byte, 1.0<<s)   // 1.0 has type int; len(b) == 1<<33
+
+// The results of the following examples are given for 32-bit ints,
+// which means the shifts will overflow.
+var mm int = 1.0<<s            // 1.0 has type int; mm == 0
+var oo = 1<<s == 2<<s          // 1 and 2 have type int; oo == true
+var pp = 1<<s == 1<<33         // illegal: 1 has type int, but 1<<33 overflows int
+var xx = a[1.0<<s]             // 1.0 has type int; xx == a[0]
+var bb = make([]byte, 1.0<<s)  // 1.0 has type int; len(bb) == 0
+
+ +

Operator precedence

+

+Unary operators have the highest precedence. +As the ++ and -- operators form +statements, not expressions, they fall +outside the operator hierarchy. +As a consequence, statement *p++ is the same as (*p)++. +

+There are five precedence levels for binary operators. +Multiplication operators bind strongest, followed by addition +operators, comparison operators, && (logical AND), +and finally || (logical OR): +

+ +
+Precedence    Operator
+    5             *  /  %  <<  >>  &  &^
+    4             +  -  |  ^
+    3             ==  !=  <  <=  >  >=
+    2             &&
+    1             ||
+
+ +

+Binary operators of the same precedence associate from left to right. +For instance, x / y * z is the same as (x / y) * z. +

+ +
++x
+23 + 3*x[i]
+x <= f()
+^a >> b
+f() || g()
+x == y+1 && <-chanInt > 0
+
+ + +

Arithmetic operators

+

+Arithmetic operators apply to numeric values and yield a result of the same +type as the first operand. The four standard arithmetic operators (+, +-, *, /) apply to integer, +floating-point, and complex types; + also applies to strings. +The bitwise logical and shift operators apply to integers only. +

+ +
++    sum                    integers, floats, complex values, strings
+-    difference             integers, floats, complex values
+*    product                integers, floats, complex values
+/    quotient               integers, floats, complex values
+%    remainder              integers
+
+&    bitwise AND            integers
+|    bitwise OR             integers
+^    bitwise XOR            integers
+&^   bit clear (AND NOT)    integers
+
+<<   left shift             integer << integer >= 0
+>>   right shift            integer >> integer >= 0
+
+ + +

Integer operators

+ +

+For two integer values x and y, the integer quotient +q = x / y and remainder r = x % y satisfy the following +relationships: +

+ +
+x = q*y + r  and  |r| < |y|
+
+ +

+with x / y truncated towards zero +("truncated division"). +

+ +
+ x     y     x / y     x % y
+ 5     3       1         2
+-5     3      -1        -2
+ 5    -3      -1         2
+-5    -3       1        -2
+
+ +

+The one exception to this rule is that if the dividend x is +the most negative value for the int type of x, the quotient +q = x / -1 is equal to x (and r = 0) +due to two's-complement integer overflow: +

+ +
+			 x, q
+int8                     -128
+int16                  -32768
+int32             -2147483648
+int64    -9223372036854775808
+
+ +

+If the divisor is a constant, it must not be zero. +If the divisor is zero at run time, a run-time panic occurs. +If the dividend is non-negative and the divisor is a constant power of 2, +the division may be replaced by a right shift, and computing the remainder may +be replaced by a bitwise AND operation: +

+ +
+ x     x / 4     x % 4     x >> 2     x & 3
+ 11      2         3         2          3
+-11     -2        -3        -3          1
+
+ +

+The shift operators shift the left operand by the shift count specified by the +right operand, which must be non-negative. If the shift count is negative at run time, +a run-time panic occurs. +The shift operators implement arithmetic shifts if the left operand is a signed +integer and logical shifts if it is an unsigned integer. +There is no upper limit on the shift count. Shifts behave +as if the left operand is shifted n times by 1 for a shift +count of n. +As a result, x << 1 is the same as x*2 +and x >> 1 is the same as +x/2 but truncated towards negative infinity. +

+ +

+For integer operands, the unary operators ++, -, and ^ are defined as +follows: +

+ +
++x                          is 0 + x
+-x    negation              is 0 - x
+^x    bitwise complement    is m ^ x  with m = "all bits set to 1" for unsigned x
+                                      and  m = -1 for signed x
+
+ + +

Integer overflow

+ +

+For unsigned integer values, the operations +, +-, *, and << are +computed modulo 2n, where n is the bit width of +the unsigned integer's type. +Loosely speaking, these unsigned integer operations +discard high bits upon overflow, and programs may rely on "wrap around". +

+

+For signed integers, the operations +, +-, *, /, and << may legally +overflow and the resulting value exists and is deterministically defined +by the signed integer representation, the operation, and its operands. +Overflow does not cause a run-time panic. +A compiler may not optimize code under the assumption that overflow does +not occur. For instance, it may not assume that x < x + 1 is always true. +

+ + +

Floating-point operators

+ +

+For floating-point and complex numbers, ++x is the same as x, +while -x is the negation of x. +The result of a floating-point or complex division by zero is not specified beyond the +IEEE-754 standard; whether a run-time panic +occurs is implementation-specific. +

+ +

+An implementation may combine multiple floating-point operations into a single +fused operation, possibly across statements, and produce a result that differs +from the value obtained by executing and rounding the instructions individually. +An explicit floating-point type conversion rounds to +the precision of the target type, preventing fusion that would discard that rounding. +

+ +

+For instance, some architectures provide a "fused multiply and add" (FMA) instruction +that computes x*y + z without rounding the intermediate result x*y. +These examples show when a Go implementation can use that instruction: +

+ +
+// FMA allowed for computing r, because x*y is not explicitly rounded:
+r  = x*y + z
+r  = z;   r += x*y
+t  = x*y; r = t + z
+*p = x*y; r = *p + z
+r  = x*y + float64(z)
+
+// FMA disallowed for computing r, because it would omit rounding of x*y:
+r  = float64(x*y) + z
+r  = z; r += float64(x*y)
+t  = float64(x*y); r = t + z
+
+ +

String concatenation

+ +

+Strings can be concatenated using the + operator +or the += assignment operator: +

+ +
+s := "hi" + string(c)
+s += " and good bye"
+
+ +

+String addition creates a new string by concatenating the operands. +

+ + +

Comparison operators

+ +

+Comparison operators compare two operands and yield an untyped boolean value. +

+ +
+==    equal
+!=    not equal
+<     less
+<=    less or equal
+>     greater
+>=    greater or equal
+
+ +

+In any comparison, the first operand +must be assignable +to the type of the second operand, or vice versa. +

+

+The equality operators == and != apply +to operands that are comparable. +The ordering operators <, <=, >, and >= +apply to operands that are ordered. +These terms and the result of the comparisons are defined as follows: +

+ +
    +
  • + Boolean values are comparable. + Two boolean values are equal if they are either both + true or both false. +
    • + +
  • + Integer values are comparable and ordered, in the usual way. +
    • + +
  • + Floating-point values are comparable and ordered, + as defined by the IEEE-754 standard. +
    • + +
  • + Complex values are comparable. + Two complex values u and v are + equal if both real(u) == real(v) and + imag(u) == imag(v). +
    • + +
  • + String values are comparable and ordered, lexically byte-wise. +
    • + +
  • + Pointer values are comparable. + Two pointer values are equal if they point to the same variable or if both have value nil. + Pointers to distinct zero-size variables may or may not be equal. +
    • + +
  • + Channel values are comparable. + Two channel values are equal if they were created by the same call to + make + or if both have value nil. +
    • + +
  • + Interface values are comparable. + Two interface values are equal if they have identical dynamic types + and equal dynamic values or if both have value nil. +
    • + +
  • + A value x of non-interface type X and + a value t of interface type T are comparable when values + of type X are comparable and + X implements T. + They are equal if t's dynamic type is identical to X + and t's dynamic value is equal to x. +
    • + +
  • + Struct values are comparable if all their fields are comparable. + Two struct values are equal if their corresponding + non-blank fields are equal. +
    • + +
  • + Array values are comparable if values of the array element type are comparable. + Two array values are equal if their corresponding elements are equal. +
    • +
+ +

+A comparison of two interface values with identical dynamic types +causes a run-time panic if values +of that type are not comparable. This behavior applies not only to direct interface +value comparisons but also when comparing arrays of interface values +or structs with interface-valued fields. +

+ +

+Slice, map, and function values are not comparable. +However, as a special case, a slice, map, or function value may +be compared to the predeclared identifier nil. +Comparison of pointer, channel, and interface values to nil +is also allowed and follows from the general rules above. +

+ +
+const c = 3 < 4            // c is the untyped boolean constant true
+
+type MyBool bool
+var x, y int
+var (
+	// The result of a comparison is an untyped boolean.
+	// The usual assignment rules apply.
+	b3        = x == y // b3 has type bool
+	b4 bool   = x == y // b4 has type bool
+	b5 MyBool = x == y // b5 has type MyBool
+)
+
+ +

Logical operators

+ +

+Logical operators apply to boolean values +and yield a result of the same type as the operands. +The right operand is evaluated conditionally. +

+ +
+&&    conditional AND    p && q  is  "if p then q else false"
+||    conditional OR     p || q  is  "if p then true else q"
+!     NOT                !p      is  "not p"
+
+ + +

Address operators

+ +

+For an operand x of type T, the address operation +&x generates a pointer of type *T to x. +The operand must be addressable, +that is, either a variable, pointer indirection, or slice indexing +operation; or a field selector of an addressable struct operand; +or an array indexing operation of an addressable array. +As an exception to the addressability requirement, x may also be a +(possibly parenthesized) +composite literal. +If the evaluation of x would cause a run-time panic, +then the evaluation of &x does too. +

+ +

+For an operand x of pointer type *T, the pointer +indirection *x denotes the variable of type T pointed +to by x. +If x is nil, an attempt to evaluate *x +will cause a run-time panic. +

+ +
+&x
+&a[f(2)]
+&Point{2, 3}
+*p
+*pf(x)
+
+var x *int = nil
+*x   // causes a run-time panic
+&*x  // causes a run-time panic
+
+ + +

Receive operator

+ +

+For an operand ch of channel type, +the value of the receive operation <-ch is the value received +from the channel ch. The channel direction must permit receive operations, +and the type of the receive operation is the element type of the channel. +The expression blocks until a value is available. +Receiving from a nil channel blocks forever. +A receive operation on a closed channel can always proceed +immediately, yielding the element type's zero value +after any previously sent values have been received. +

+ +
+v1 := <-ch
+v2 = <-ch
+f(<-ch)
+<-strobe  // wait until clock pulse and discard received value
+
+ +

+A receive expression used in an assignment or initialization of the special form +

+ +
+x, ok = <-ch
+x, ok := <-ch
+var x, ok = <-ch
+var x, ok T = <-ch
+
+ +

+yields an additional untyped boolean result reporting whether the +communication succeeded. The value of ok is true +if the value received was delivered by a successful send operation to the +channel, or false if it is a zero value generated because the +channel is closed and empty. +

+ + +

Conversions

+ +

+A conversion changes the type of an expression +to the type specified by the conversion. +A conversion may appear literally in the source, or it may be implied +by the context in which an expression appears. +

+ +

+An explicit conversion is an expression of the form T(x) +where T is a type and x is an expression +that can be converted to type T. +

+ +
+Conversion = Type "(" Expression [ "," ] ")" .
+
+ +

+If the type starts with the operator * or <-, +or if the type starts with the keyword func +and has no result list, it must be parenthesized when +necessary to avoid ambiguity: +

+ +
+*Point(p)        // same as *(Point(p))
+(*Point)(p)      // p is converted to *Point
+<-chan int(c)    // same as <-(chan int(c))
+(<-chan int)(c)  // c is converted to <-chan int
+func()(x)        // function signature func() x
+(func())(x)      // x is converted to func()
+(func() int)(x)  // x is converted to func() int
+func() int(x)    // x is converted to func() int (unambiguous)
+
+ +

+A constant value x can be converted to +type T if x is representable +by a value of T. +As a special case, an integer constant x can be explicitly converted to a +string type using the +same rule +as for non-constant x. +

+ +

+Converting a constant yields a typed constant as result. +

+ +
+uint(iota)               // iota value of type uint
+float32(2.718281828)     // 2.718281828 of type float32
+complex128(1)            // 1.0 + 0.0i of type complex128
+float32(0.49999999)      // 0.5 of type float32
+float64(-1e-1000)        // 0.0 of type float64
+string('x')              // "x" of type string
+string(0x266c)           // "♬" of type string
+MyString("foo" + "bar")  // "foobar" of type MyString
+string([]byte{'a'})      // not a constant: []byte{'a'} is not a constant
+(*int)(nil)              // not a constant: nil is not a constant, *int is not a boolean, numeric, or string type
+int(1.2)                 // illegal: 1.2 cannot be represented as an int
+string(65.0)             // illegal: 65.0 is not an integer constant
+
+ +

+A non-constant value x can be converted to type T +in any of these cases: +

+ +
    +
  • + x is assignable + to T. +
    • +
  • + ignoring struct tags (see below), + x's type and T have identical + underlying types. +
    • +
  • + ignoring struct tags (see below), + x's type and T are pointer types + that are not defined types, + and their pointer base types have identical underlying types. +
    • +
  • + x's type and T are both integer or floating + point types. +
    • +
  • + x's type and T are both complex types. +
    • +
  • + x is an integer or a slice of bytes or runes + and T is a string type. +
    • +
  • + x is a string and T is a slice of bytes or runes. +
    • +
  • + x is a slice, T is a pointer to an array, + and the slice and array types have identical element types. +
    • +
+ +

+Struct tags are ignored when comparing struct types +for identity for the purpose of conversion: +

+ +
+type Person struct {
+	Name    string
+	Address *struct {
+		Street string
+		City   string
+	}
+}
+
+var data *struct {
+	Name    string `json:"name"`
+	Address *struct {
+		Street string `json:"street"`
+		City   string `json:"city"`
+	} `json:"address"`
+}
+
+var person = (*Person)(data)  // ignoring tags, the underlying types are identical
+
+ +

+Specific rules apply to (non-constant) conversions between numeric types or +to and from a string type. +These conversions may change the representation of x +and incur a run-time cost. +All other conversions only change the type but not the representation +of x. +

+ +

+There is no linguistic mechanism to convert between pointers and integers. +The package unsafe +implements this functionality under +restricted circumstances. +

+ +

Conversions between numeric types

+ +

+For the conversion of non-constant numeric values, the following rules apply: +

+ +
    +
  1. +When converting between integer types, if the value is a signed integer, it is +sign extended to implicit infinite precision; otherwise it is zero extended. +It is then truncated to fit in the result type's size. +For example, if v := uint16(0x10F0), then uint32(int8(v)) == 0xFFFFFFF0. +The conversion always yields a valid value; there is no indication of overflow. +
    2. +
  2. +When converting a floating-point number to an integer, the fraction is discarded +(truncation towards zero). +
    3. +
  3. +When converting an integer or floating-point number to a floating-point type, +or a complex number to another complex type, the result value is rounded +to the precision specified by the destination type. +For instance, the value of a variable x of type float32 +may be stored using additional precision beyond that of an IEEE-754 32-bit number, +but float32(x) represents the result of rounding x's value to +32-bit precision. Similarly, x + 0.1 may use more than 32 bits +of precision, but float32(x + 0.1) does not. +
    4. +
+ +

+In all non-constant conversions involving floating-point or complex values, +if the result type cannot represent the value the conversion +succeeds but the result value is implementation-dependent. +

+ +

Conversions to and from a string type

+ +
    +
  1. +Converting a signed or unsigned integer value to a string type yields a +string containing the UTF-8 representation of the integer. Values outside +the range of valid Unicode code points are converted to "\uFFFD". + +
    +string('a')       // "a"
+string(-1)        // "\ufffd" == "\xef\xbf\xbd"
+string(0xf8)      // "\u00f8" == "ø" == "\xc3\xb8"
+type MyString string
+MyString(0x65e5)  // "\u65e5" == "日" == "\xe6\x97\xa5"
+
    +
    2. + +
  2. +Converting a slice of bytes to a string type yields +a string whose successive bytes are the elements of the slice. + +
    +string([]byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'})   // "hellø"
+string([]byte{})                                     // ""
+string([]byte(nil))                                  // ""
+
+type MyBytes []byte
+string(MyBytes{'h', 'e', 'l', 'l', '\xc3', '\xb8'})  // "hellø"
+
    +
    3. + +
  3. +Converting a slice of runes to a string type yields +a string that is the concatenation of the individual rune values +converted to strings. + +
    +string([]rune{0x767d, 0x9d6c, 0x7fd4})   // "\u767d\u9d6c\u7fd4" == "白鵬翔"
+string([]rune{})                         // ""
+string([]rune(nil))                      // ""
+
+type MyRunes []rune
+string(MyRunes{0x767d, 0x9d6c, 0x7fd4})  // "\u767d\u9d6c\u7fd4" == "白鵬翔"
+
    +
    4. + +
  4. +Converting a value of a string type to a slice of bytes type +yields a slice whose successive elements are the bytes of the string. + +
    +[]byte("hellø")   // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}
+[]byte("")        // []byte{}
+
+MyBytes("hellø")  // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}
+
    +
    5. + +
  5. +Converting a value of a string type to a slice of runes type +yields a slice containing the individual Unicode code points of the string. + +
    +[]rune(MyString("白鵬翔"))  // []rune{0x767d, 0x9d6c, 0x7fd4}
+[]rune("")                 // []rune{}
+
+MyRunes("白鵬翔")           // []rune{0x767d, 0x9d6c, 0x7fd4}
+
    +
    6. +
+ +

Conversions from slice to array pointer

+ +

+Converting a slice to an array pointer yields a pointer to the underlying array of the slice. +If the length of the slice is less than the length of the array, +a run-time panic occurs. +

+ +
+s := make([]byte, 2, 4)
+s0 := (*[0]byte)(s)      // s0 != nil
+s1 := (*[1]byte)(s[1:])  // &s1[0] == &s[1]
+s2 := (*[2]byte)(s)      // &s2[0] == &s[0]
+s4 := (*[4]byte)(s)      // panics: len([4]byte) > len(s)
+
+var t []string
+t0 := (*[0]string)(t)    // t0 == nil
+t1 := (*[1]string)(t)    // panics: len([1]string) > len(t)
+
+u := make([]byte, 0)
+u0 := (*[0]byte)(u)      // u0 != nil
+
+ +

Constant expressions

+ +

+Constant expressions may contain only constant +operands and are evaluated at compile time. +

+ +

+Untyped boolean, numeric, and string constants may be used as operands +wherever it is legal to use an operand of boolean, numeric, or string type, +respectively. +

+ +

+A constant comparison always yields +an untyped boolean constant. If the left operand of a constant +shift expression is an untyped constant, the +result is an integer constant; otherwise it is a constant of the same +type as the left operand, which must be of +integer type. +

+ +

+Any other operation on untyped constants results in an untyped constant of the +same kind; that is, a boolean, integer, floating-point, complex, or string +constant. +If the untyped operands of a binary operation (other than a shift) are of +different kinds, the result is of the operand's kind that appears later in this +list: integer, rune, floating-point, complex. +For example, an untyped integer constant divided by an +untyped complex constant yields an untyped complex constant. +

+ +
+const a = 2 + 3.0          // a == 5.0   (untyped floating-point constant)
+const b = 15 / 4           // b == 3     (untyped integer constant)
+const c = 15 / 4.0         // c == 3.75  (untyped floating-point constant)
+const Θ float64 = 3/2      // Θ == 1.0   (type float64, 3/2 is integer division)
+const Π float64 = 3/2.     // Π == 1.5   (type float64, 3/2. is float division)
+const d = 1 << 3.0         // d == 8     (untyped integer constant)
+const e = 1.0 << 3         // e == 8     (untyped integer constant)
+const f = int32(1) << 33   // illegal    (constant 8589934592 overflows int32)
+const g = float64(2) >> 1  // illegal    (float64(2) is a typed floating-point constant)
+const h = "foo" > "bar"    // h == true  (untyped boolean constant)
+const j = true             // j == true  (untyped boolean constant)
+const k = 'w' + 1          // k == 'x'   (untyped rune constant)
+const l = "hi"             // l == "hi"  (untyped string constant)
+const m = string(k)        // m == "x"   (type string)
+const Σ = 1 - 0.707i       //            (untyped complex constant)
+const Δ = Σ + 2.0e-4       //            (untyped complex constant)
+const Φ = iota*1i - 1/1i   //            (untyped complex constant)
+
+ +

+Applying the built-in function complex to untyped +integer, rune, or floating-point constants yields +an untyped complex constant. +

+ +
+const ic = complex(0, c)   // ic == 3.75i  (untyped complex constant)
+const iΘ = complex(0, Θ)   // iΘ == 1i     (type complex128)
+
+ +

+Constant expressions are always evaluated exactly; intermediate values and the +constants themselves may require precision significantly larger than supported +by any predeclared type in the language. The following are legal declarations: +

+ +
+const Huge = 1 << 100         // Huge == 1267650600228229401496703205376  (untyped integer constant)
+const Four int8 = Huge >> 98  // Four == 4                                (type int8)
+
+ +

+The divisor of a constant division or remainder operation must not be zero: +

+ +
+3.14 / 0.0   // illegal: division by zero
+
+ +

+The values of typed constants must always be accurately +representable by values +of the constant type. The following constant expressions are illegal: +

+ +
+uint(-1)     // -1 cannot be represented as a uint
+int(3.14)    // 3.14 cannot be represented as an int
+int64(Huge)  // 1267650600228229401496703205376 cannot be represented as an int64
+Four * 300   // operand 300 cannot be represented as an int8 (type of Four)
+Four * 100   // product 400 cannot be represented as an int8 (type of Four)
+
+ +

+The mask used by the unary bitwise complement operator ^ matches +the rule for non-constants: the mask is all 1s for unsigned constants +and -1 for signed and untyped constants. +

+ +
+^1         // untyped integer constant, equal to -2
+uint8(^1)  // illegal: same as uint8(-2), -2 cannot be represented as a uint8
+^uint8(1)  // typed uint8 constant, same as 0xFF ^ uint8(1) = uint8(0xFE)
+int8(^1)   // same as int8(-2)
+^int8(1)   // same as -1 ^ int8(1) = -2
+
+ +

+Implementation restriction: A compiler may use rounding while +computing untyped floating-point or complex constant expressions; see +the implementation restriction in the section +on constants. This rounding may cause a +floating-point constant expression to be invalid in an integer +context, even if it would be integral when calculated using infinite +precision, and vice versa. +

+ + +

Order of evaluation

+ +

+At package level, initialization dependencies +determine the evaluation order of individual initialization expressions in +variable declarations. +Otherwise, when evaluating the operands of an +expression, assignment, or +return statement, +all function calls, method calls, and +communication operations are evaluated in lexical left-to-right +order. +

+ +

+For example, in the (function-local) assignment +

+
+y[f()], ok = g(h(), i()+x[j()], <-c), k()
+
+

+the function calls and communication happen in the order +f(), h(), i(), j(), +<-c, g(), and k(). +However, the order of those events compared to the evaluation +and indexing of x and the evaluation +of y is not specified. +

+ +
+a := 1
+f := func() int { a++; return a }
+x := []int{a, f()}            // x may be [1, 2] or [2, 2]: evaluation order between a and f() is not specified
+m := map[int]int{a: 1, a: 2}  // m may be {2: 1} or {2: 2}: evaluation order between the two map assignments is not specified
+n := map[int]int{a: f()}      // n may be {2: 3} or {3: 3}: evaluation order between the key and the value is not specified
+
+ +

+At package level, initialization dependencies override the left-to-right rule +for individual initialization expressions, but not for operands within each +expression: +

+ +
+var a, b, c = f() + v(), g(), sqr(u()) + v()
+
+func f() int        { return c }
+func g() int        { return a }
+func sqr(x int) int { return x*x }
+
+// functions u and v are independent of all other variables and functions
+
+ +

+The function calls happen in the order +u(), sqr(), v(), +f(), v(), and g(). +

+ +

+Floating-point operations within a single expression are evaluated according to +the associativity of the operators. Explicit parentheses affect the evaluation +by overriding the default associativity. +In the expression x + (y + z) the addition y + z +is performed before adding x. +

+ +

Statements

+ +

+Statements control execution. +

+ +
+Statement =
+	Declaration | LabeledStmt | SimpleStmt |
+	GoStmt | ReturnStmt | BreakStmt | ContinueStmt | GotoStmt |
+	FallthroughStmt | Block | IfStmt | SwitchStmt | SelectStmt | ForStmt |
+	DeferStmt .
+
+SimpleStmt = EmptyStmt | ExpressionStmt | SendStmt | IncDecStmt | Assignment | ShortVarDecl .
+
+ +

Terminating statements

+ +

+A terminating statement interrupts the regular flow of control in +a block. The following statements are terminating: +

+ +
    +
  1. + A "return" or + "goto" statement. + +
    +
    2. + +
  2. + A call to the built-in function + panic. + +
    +
    3. + +
  3. + A block in which the statement list ends in a terminating statement. + +
    +
    4. + +
  4. + An "if" statement in which: +
      +
    • the "else" branch is present, and
      • +
    • both branches are terminating statements.
      • +
    +
    5. + +
  5. + A "for" statement in which: +
      +
    • there are no "break" statements referring to the "for" statement, and
      • +
    • the loop condition is absent, and
      • +
    • the "for" statement does not use a range clause.
      • +
    +
    6. + +
  6. + A "switch" statement in which: +
      +
    • there are no "break" statements referring to the "switch" statement,
      • +
    • there is a default case, and
      • +
    • the statement lists in each case, including the default, end in a terminating + statement, or a possibly labeled "fallthrough" + statement.
      • +
    +
    7. + +
  7. + A "select" statement in which: +
      +
    • there are no "break" statements referring to the "select" statement, and
      • +
    • the statement lists in each case, including the default if present, + end in a terminating statement.
      • +
    +
    8. + +
  8. + A labeled statement labeling + a terminating statement. +
    9. +
+ +

+All other statements are not terminating. +

+ +

+A statement list ends in a terminating statement if the list +is not empty and its final non-empty statement is terminating. +

+ + +

Empty statements

+ +

+The empty statement does nothing. +

+ +
+EmptyStmt = .
+
+ + +

Labeled statements

+ +

+A labeled statement may be the target of a goto, +break or continue statement. +

+ +
+LabeledStmt = Label ":" Statement .
+Label       = identifier .
+
+ +
+Error: log.Panic("error encountered")
+
+ + +

Expression statements

+ +

+With the exception of specific built-in functions, +function and method calls and +receive operations +can appear in statement context. Such statements may be parenthesized. +

+ +
+ExpressionStmt = Expression .
+
+ +

+The following built-in functions are not permitted in statement context: +

+ +
+append cap complex imag len make new real
+unsafe.Add unsafe.Alignof unsafe.Offsetof unsafe.Sizeof unsafe.Slice
+
+ +
+h(x+y)
+f.Close()
+<-ch
+(<-ch)
+len("foo")  // illegal if len is the built-in function
+
+ + +

Send statements

+ +

+A send statement sends a value on a channel. +The channel expression must be of channel type, +the channel direction must permit send operations, +and the type of the value to be sent must be assignable +to the channel's element type. +

+ +
+SendStmt = Channel "<-" Expression .
+Channel  = Expression .
+
+ +

+Both the channel and the value expression are evaluated before communication +begins. Communication blocks until the send can proceed. +A send on an unbuffered channel can proceed if a receiver is ready. +A send on a buffered channel can proceed if there is room in the buffer. +A send on a closed channel proceeds by causing a run-time panic. +A send on a nil channel blocks forever. +

+ +
+ch <- 3  // send value 3 to channel ch
+
+ + +

IncDec statements

+ +

+The "++" and "--" statements increment or decrement their operands +by the untyped constant 1. +As with an assignment, the operand must be addressable +or a map index expression. +

+ +
+IncDecStmt = Expression ( "++" | "--" ) .
+
+ +

+The following assignment statements are semantically +equivalent: +

+ +
+IncDec statement    Assignment
+x++                 x += 1
+x--                 x -= 1
+
+ + +

Assignments

+ +
+Assignment = ExpressionList assign_op ExpressionList .
+
+assign_op = [ add_op | mul_op ] "=" .
+
+ +

+Each left-hand side operand must be addressable, +a map index expression, or (for = assignments only) the +blank identifier. +Operands may be parenthesized. +

+ +
+x = 1
+*p = f()
+a[i] = 23
+(k) = <-ch  // same as: k = <-ch
+
+ +

+An assignment operation x op= +y where op is a binary arithmetic operator +is equivalent to x = x op +(y) but evaluates x +only once. The op= construct is a single token. +In assignment operations, both the left- and right-hand expression lists +must contain exactly one single-valued expression, and the left-hand +expression must not be the blank identifier. +

+ +
+a[i] <<= 2
+i &^= 1<<n
+
+ +

+A tuple assignment assigns the individual elements of a multi-valued +operation to a list of variables. There are two forms. In the +first, the right hand operand is a single multi-valued expression +such as a function call, a channel or +map operation, or a type assertion. +The number of operands on the left +hand side must match the number of values. For instance, if +f is a function returning two values, +

+ +
+x, y = f()
+
+ +

+assigns the first value to x and the second to y. +In the second form, the number of operands on the left must equal the number +of expressions on the right, each of which must be single-valued, and the +nth expression on the right is assigned to the nth +operand on the left: +

+ +
+one, two, three = '一', '二', '三'
+
+ +

+The blank identifier provides a way to +ignore right-hand side values in an assignment: +

+ +
+_ = x       // evaluate x but ignore it
+x, _ = f()  // evaluate f() but ignore second result value
+
+ +

+The assignment proceeds in two phases. +First, the operands of index expressions +and pointer indirections +(including implicit pointer indirections in selectors) +on the left and the expressions on the right are all +evaluated in the usual order. +Second, the assignments are carried out in left-to-right order. +

+ +
+a, b = b, a  // exchange a and b
+
+x := []int{1, 2, 3}
+i := 0
+i, x[i] = 1, 2  // set i = 1, x[0] = 2
+
+i = 0
+x[i], i = 2, 1  // set x[0] = 2, i = 1
+
+x[0], x[0] = 1, 2  // set x[0] = 1, then x[0] = 2 (so x[0] == 2 at end)
+
+x[1], x[3] = 4, 5  // set x[1] = 4, then panic setting x[3] = 5.
+
+type Point struct { x, y int }
+var p *Point
+x[2], p.x = 6, 7  // set x[2] = 6, then panic setting p.x = 7
+
+i = 2
+x = []int{3, 5, 7}
+for i, x[i] = range x {  // set i, x[2] = 0, x[0]
+	break
+}
+// after this loop, i == 0 and x == []int{3, 5, 3}
+
+ +

+In assignments, each value must be assignable +to the type of the operand to which it is assigned, with the following special cases: +

+ +
    +
  1. + Any typed value may be assigned to the blank identifier. +
    2. + +
  2. + If an untyped constant + is assigned to a variable of interface type or the blank identifier, + the constant is first implicitly converted to its + default type. +
    3. + +
  3. + If an untyped boolean value is assigned to a variable of interface type or + the blank identifier, it is first implicitly converted to type bool. +
    4. +
+ +

If statements

+ +

+"If" statements specify the conditional execution of two branches +according to the value of a boolean expression. If the expression +evaluates to true, the "if" branch is executed, otherwise, if +present, the "else" branch is executed. +

+ +
+IfStmt = "if" [ SimpleStmt ";" ] Expression Block [ "else" ( IfStmt | Block ) ] .
+
+ +
+if x > max {
+	x = max
+}
+
+ +

+The expression may be preceded by a simple statement, which +executes before the expression is evaluated. +

+ +
+if x := f(); x < y {
+	return x
+} else if x > z {
+	return z
+} else {
+	return y
+}
+
+ + +

Switch statements

+ +

+"Switch" statements provide multi-way execution. +An expression or type is compared to the "cases" +inside the "switch" to determine which branch +to execute. +

+ +
+SwitchStmt = ExprSwitchStmt | TypeSwitchStmt .
+
+ +

+There are two forms: expression switches and type switches. +In an expression switch, the cases contain expressions that are compared +against the value of the switch expression. +In a type switch, the cases contain types that are compared against the +type of a specially annotated switch expression. +The switch expression is evaluated exactly once in a switch statement. +

+ +

Expression switches

+ +

+In an expression switch, +the switch expression is evaluated and +the case expressions, which need not be constants, +are evaluated left-to-right and top-to-bottom; the first one that equals the +switch expression +triggers execution of the statements of the associated case; +the other cases are skipped. +If no case matches and there is a "default" case, +its statements are executed. +There can be at most one default case and it may appear anywhere in the +"switch" statement. +A missing switch expression is equivalent to the boolean value +true. +

+ +
+ExprSwitchStmt = "switch" [ SimpleStmt ";" ] [ Expression ] "{" { ExprCaseClause } "}" .
+ExprCaseClause = ExprSwitchCase ":" StatementList .
+ExprSwitchCase = "case" ExpressionList | "default" .
+
+ +

+If the switch expression evaluates to an untyped constant, it is first implicitly +converted to its default type. +The predeclared untyped value nil cannot be used as a switch expression. +The switch expression type must be comparable. +

+ +

+If a case expression is untyped, it is first implicitly converted +to the type of the switch expression. +For each (possibly converted) case expression x and the value t +of the switch expression, x == t must be a valid comparison. +

+ +

+In other words, the switch expression is treated as if it were used to declare and +initialize a temporary variable t without explicit type; it is that +value of t against which each case expression x is tested +for equality. +

+ +

+In a case or default clause, the last non-empty statement +may be a (possibly labeled) +"fallthrough" statement to +indicate that control should flow from the end of this clause to +the first statement of the next clause. +Otherwise control flows to the end of the "switch" statement. +A "fallthrough" statement may appear as the last statement of all +but the last clause of an expression switch. +

+ +

+The switch expression may be preceded by a simple statement, which +executes before the expression is evaluated. +

+ +
+switch tag {
+default: s3()
+case 0, 1, 2, 3: s1()
+case 4, 5, 6, 7: s2()
+}
+
+switch x := f(); {  // missing switch expression means "true"
+case x < 0: return -x
+default: return x
+}
+
+switch {
+case x < y: f1()
+case x < z: f2()
+case x == 4: f3()
+}
+
+ +

+Implementation restriction: A compiler may disallow multiple case +expressions evaluating to the same constant. +For instance, the current compilers disallow duplicate integer, +floating point, or string constants in case expressions. +

+ +

Type switches

+ +

+A type switch compares types rather than values. It is otherwise similar +to an expression switch. It is marked by a special switch expression that +has the form of a type assertion +using the keyword type rather than an actual type: +

+ +
+switch x.(type) {
+// cases
+}
+
+ +

+Cases then match actual types T against the dynamic type of the +expression x. As with type assertions, x must be of +interface type, and each non-interface type +T listed in a case must implement the type of x. +The types listed in the cases of a type switch must all be +different. +

+ +
+TypeSwitchStmt  = "switch" [ SimpleStmt ";" ] TypeSwitchGuard "{" { TypeCaseClause } "}" .
+TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" .
+TypeCaseClause  = TypeSwitchCase ":" StatementList .
+TypeSwitchCase  = "case" TypeList | "default" .
+TypeList        = Type { "," Type } .
+
+ +

+The TypeSwitchGuard may include a +short variable declaration. +When that form is used, the variable is declared at the end of the +TypeSwitchCase in the implicit block of each clause. +In clauses with a case listing exactly one type, the variable +has that type; otherwise, the variable has the type of the expression +in the TypeSwitchGuard. +

+ +

+Instead of a type, a case may use the predeclared identifier +nil; +that case is selected when the expression in the TypeSwitchGuard +is a nil interface value. +There may be at most one nil case. +

+ +

+Given an expression x of type interface{}, +the following type switch: +

+ +
+switch i := x.(type) {
+case nil:
+	printString("x is nil")                // type of i is type of x (interface{})
+case int:
+	printInt(i)                            // type of i is int
+case float64:
+	printFloat64(i)                        // type of i is float64
+case func(int) float64:
+	printFunction(i)                       // type of i is func(int) float64
+case bool, string:
+	printString("type is bool or string")  // type of i is type of x (interface{})
+default:
+	printString("don't know the type")     // type of i is type of x (interface{})
+}
+
+ +

+could be rewritten: +

+ +
+v := x  // x is evaluated exactly once
+if v == nil {
+	i := v                                 // type of i is type of x (interface{})
+	printString("x is nil")
+} else if i, isInt := v.(int); isInt {
+	printInt(i)                            // type of i is int
+} else if i, isFloat64 := v.(float64); isFloat64 {
+	printFloat64(i)                        // type of i is float64
+} else if i, isFunc := v.(func(int) float64); isFunc {
+	printFunction(i)                       // type of i is func(int) float64
+} else {
+	_, isBool := v.(bool)
+	_, isString := v.(string)
+	if isBool || isString {
+		i := v                         // type of i is type of x (interface{})
+		printString("type is bool or string")
+	} else {
+		i := v                         // type of i is type of x (interface{})
+		printString("don't know the type")
+	}
+}
+
+ +

+The type switch guard may be preceded by a simple statement, which +executes before the guard is evaluated. +

+ +

+The "fallthrough" statement is not permitted in a type switch. +

+ +

For statements

+ +

+A "for" statement specifies repeated execution of a block. There are three forms: +The iteration may be controlled by a single condition, a "for" clause, or a "range" clause. +

+ +
+ForStmt = "for" [ Condition | ForClause | RangeClause ] Block .
+Condition = Expression .
+
+ +

For statements with single condition

+ +

+In its simplest form, a "for" statement specifies the repeated execution of +a block as long as a boolean condition evaluates to true. +The condition is evaluated before each iteration. +If the condition is absent, it is equivalent to the boolean value +true. +

+ +
+for a < b {
+	a *= 2
+}
+
+ +

For statements with for clause

+ +

+A "for" statement with a ForClause is also controlled by its condition, but +additionally it may specify an init +and a post statement, such as an assignment, +an increment or decrement statement. The init statement may be a +short variable declaration, but the post statement must not. +Variables declared by the init statement are re-used in each iteration. +

+ +
+ForClause = [ InitStmt ] ";" [ Condition ] ";" [ PostStmt ] .
+InitStmt = SimpleStmt .
+PostStmt = SimpleStmt .
+
+ +
+for i := 0; i < 10; i++ {
+	f(i)
+}
+
+ +

+If non-empty, the init statement is executed once before evaluating the +condition for the first iteration; +the post statement is executed after each execution of the block (and +only if the block was executed). +Any element of the ForClause may be empty but the +semicolons are +required unless there is only a condition. +If the condition is absent, it is equivalent to the boolean value +true. +

+ +
+for cond { S() }    is the same as    for ; cond ; { S() }
+for      { S() }    is the same as    for true     { S() }
+
+ +

For statements with range clause

+ +

+A "for" statement with a "range" clause +iterates through all entries of an array, slice, string or map, +or values received on a channel. For each entry it assigns iteration values +to corresponding iteration variables if present and then executes the block. +

+ +
+RangeClause = [ ExpressionList "=" | IdentifierList ":=" ] "range" Expression .
+
+ +

+The expression on the right in the "range" clause is called the range expression, +which may be an array, pointer to an array, slice, string, map, or channel permitting +receive operations. +As with an assignment, if present the operands on the left must be +addressable or map index expressions; they +denote the iteration variables. If the range expression is a channel, at most +one iteration variable is permitted, otherwise there may be up to two. +If the last iteration variable is the blank identifier, +the range clause is equivalent to the same clause without that identifier. +

+ +

+The range expression x is evaluated once before beginning the loop, +with one exception: if at most one iteration variable is present and +len(x) is constant, +the range expression is not evaluated. +

+ +

+Function calls on the left are evaluated once per iteration. +For each iteration, iteration values are produced as follows +if the respective iteration variables are present: +

+ +
+Range expression                          1st value          2nd value
+
+array or slice  a  [n]E, *[n]E, or []E    index    i  int    a[i]       E
+string          s  string type            index    i  int    see below  rune
+map             m  map[K]V                key      k  K      m[k]       V
+channel         c  chan E, <-chan E       element  e  E
+
+ +
    +
  1. +For an array, pointer to array, or slice value a, the index iteration +values are produced in increasing order, starting at element index 0. +If at most one iteration variable is present, the range loop produces +iteration values from 0 up to len(a)-1 and does not index into the array +or slice itself. For a nil slice, the number of iterations is 0. +
    2. + +
  2. +For a string value, the "range" clause iterates over the Unicode code points +in the string starting at byte index 0. On successive iterations, the index value will be the +index of the first byte of successive UTF-8-encoded code points in the string, +and the second value, of type rune, will be the value of +the corresponding code point. If the iteration encounters an invalid +UTF-8 sequence, the second value will be 0xFFFD, +the Unicode replacement character, and the next iteration will advance +a single byte in the string. +
    3. + +
  3. +The iteration order over maps is not specified +and is not guaranteed to be the same from one iteration to the next. +If a map entry that has not yet been reached is removed during iteration, +the corresponding iteration value will not be produced. If a map entry is +created during iteration, that entry may be produced during the iteration or +may be skipped. The choice may vary for each entry created and from one +iteration to the next. +If the map is nil, the number of iterations is 0. +
    4. + +
  4. +For channels, the iteration values produced are the successive values sent on +the channel until the channel is closed. If the channel +is nil, the range expression blocks forever. +
    5. +
+ +

+The iteration values are assigned to the respective +iteration variables as in an assignment statement. +

+ +

+The iteration variables may be declared by the "range" clause using a form of +short variable declaration +(:=). +In this case their types are set to the types of the respective iteration values +and their scope is the block of the "for" +statement; they are re-used in each iteration. +If the iteration variables are declared outside the "for" statement, +after execution their values will be those of the last iteration. +

+ +
+var testdata *struct {
+	a *[7]int
+}
+for i, _ := range testdata.a {
+	// testdata.a is never evaluated; len(testdata.a) is constant
+	// i ranges from 0 to 6
+	f(i)
+}
+
+var a [10]string
+for i, s := range a {
+	// type of i is int
+	// type of s is string
+	// s == a[i]
+	g(i, s)
+}
+
+var key string
+var val interface{}  // element type of m is assignable to val
+m := map[string]int{"mon":0, "tue":1, "wed":2, "thu":3, "fri":4, "sat":5, "sun":6}
+for key, val = range m {
+	h(key, val)
+}
+// key == last map key encountered in iteration
+// val == map[key]
+
+var ch chan Work = producer()
+for w := range ch {
+	doWork(w)
+}
+
+// empty a channel
+for range ch {}
+
+ + +

Go statements

+ +

+A "go" statement starts the execution of a function call +as an independent concurrent thread of control, or goroutine, +within the same address space. +

+ +
+GoStmt = "go" Expression .
+
+ +

+The expression must be a function or method call; it cannot be parenthesized. +Calls of built-in functions are restricted as for +expression statements. +

+ +

+The function value and parameters are +evaluated as usual +in the calling goroutine, but +unlike with a regular call, program execution does not wait +for the invoked function to complete. +Instead, the function begins executing independently +in a new goroutine. +When the function terminates, its goroutine also terminates. +If the function has any return values, they are discarded when the +function completes. +

+ +
+go Server()
+go func(ch chan<- bool) { for { sleep(10); ch <- true }} (c)
+
+ + +

Select statements

+ +

+A "select" statement chooses which of a set of possible +send or +receive +operations will proceed. +It looks similar to a +"switch" statement but with the +cases all referring to communication operations. +

+ +
+SelectStmt = "select" "{" { CommClause } "}" .
+CommClause = CommCase ":" StatementList .
+CommCase   = "case" ( SendStmt | RecvStmt ) | "default" .
+RecvStmt   = [ ExpressionList "=" | IdentifierList ":=" ] RecvExpr .
+RecvExpr   = Expression .
+
+ +

+A case with a RecvStmt may assign the result of a RecvExpr to one or +two variables, which may be declared using a +short variable declaration. +The RecvExpr must be a (possibly parenthesized) receive operation. +There can be at most one default case and it may appear anywhere +in the list of cases. +

+ +

+Execution of a "select" statement proceeds in several steps: +

+ +
    +
  1. +For all the cases in the statement, the channel operands of receive operations +and the channel and right-hand-side expressions of send statements are +evaluated exactly once, in source order, upon entering the "select" statement. +The result is a set of channels to receive from or send to, +and the corresponding values to send. +Any side effects in that evaluation will occur irrespective of which (if any) +communication operation is selected to proceed. +Expressions on the left-hand side of a RecvStmt with a short variable declaration +or assignment are not yet evaluated. +
    2. + +
  2. +If one or more of the communications can proceed, +a single one that can proceed is chosen via a uniform pseudo-random selection. +Otherwise, if there is a default case, that case is chosen. +If there is no default case, the "select" statement blocks until +at least one of the communications can proceed. +
    3. + +
  3. +Unless the selected case is the default case, the respective communication +operation is executed. +
    4. + +
  4. +If the selected case is a RecvStmt with a short variable declaration or +an assignment, the left-hand side expressions are evaluated and the +received value (or values) are assigned. +
    5. + +
  5. +The statement list of the selected case is executed. +
    6. +
+ +

+Since communication on nil channels can never proceed, +a select with only nil channels and no default case blocks forever. +

+ +
+var a []int
+var c, c1, c2, c3, c4 chan int
+var i1, i2 int
+select {
+case i1 = <-c1:
+	print("received ", i1, " from c1\n")
+case c2 <- i2:
+	print("sent ", i2, " to c2\n")
+case i3, ok := (<-c3):  // same as: i3, ok := <-c3
+	if ok {
+		print("received ", i3, " from c3\n")
+	} else {
+		print("c3 is closed\n")
+	}
+case a[f()] = <-c4:
+	// same as:
+	// case t := <-c4
+	//	a[f()] = t
+default:
+	print("no communication\n")
+}
+
+for {  // send random sequence of bits to c
+	select {
+	case c <- 0:  // note: no statement, no fallthrough, no folding of cases
+	case c <- 1:
+	}
+}
+
+select {}  // block forever
+
+ + +

Return statements

+ +

+A "return" statement in a function F terminates the execution +of F, and optionally provides one or more result values. +Any functions deferred by F +are executed before F returns to its caller. +

+ +
+ReturnStmt = "return" [ ExpressionList ] .
+
+ +

+In a function without a result type, a "return" statement must not +specify any result values. +

+
+func noResult() {
+	return
+}
+
+ +

+There are three ways to return values from a function with a result +type: +

+ +
    +
  1. The return value or values may be explicitly listed + in the "return" statement. Each expression must be single-valued + and assignable + to the corresponding element of the function's result type. +
    +func simpleF() int {
+	return 2
+}
+
+func complexF1() (re float64, im float64) {
+	return -7.0, -4.0
+}
+
    +
    2. +
  2. The expression list in the "return" statement may be a single + call to a multi-valued function. The effect is as if each value + returned from that function were assigned to a temporary + variable with the type of the respective value, followed by a + "return" statement listing these variables, at which point the + rules of the previous case apply. +
    +func complexF2() (re float64, im float64) {
+	return complexF1()
+}
+
    +
    3. +
  3. The expression list may be empty if the function's result + type specifies names for its result parameters. + The result parameters act as ordinary local variables + and the function may assign values to them as necessary. + The "return" statement returns the values of these variables. +
    +func complexF3() (re float64, im float64) {
+	re = 7.0
+	im = 4.0
+	return
+}
+
+func (devnull) Write(p []byte) (n int, _ error) {
+	n = len(p)
+	return
+}
+
    +
    4. +
+ +

+Regardless of how they are declared, all the result values are initialized to +the zero values for their type upon entry to the +function. A "return" statement that specifies results sets the result parameters before +any deferred functions are executed. +

+ +

+Implementation restriction: A compiler may disallow an empty expression list +in a "return" statement if a different entity (constant, type, or variable) +with the same name as a result parameter is in +scope at the place of the return. +

+ +
+func f(n int) (res int, err error) {
+	if _, err := f(n-1); err != nil {
+		return  // invalid return statement: err is shadowed
+	}
+	return
+}
+
+ +

Break statements

+ +

+A "break" statement terminates execution of the innermost +"for", +"switch", or +"select" statement +within the same function. +

+ +
+BreakStmt = "break" [ Label ] .
+
+ +

+If there is a label, it must be that of an enclosing +"for", "switch", or "select" statement, +and that is the one whose execution terminates. +

+ +
+OuterLoop:
+	for i = 0; i < n; i++ {
+		for j = 0; j < m; j++ {
+			switch a[i][j] {
+			case nil:
+				state = Error
+				break OuterLoop
+			case item:
+				state = Found
+				break OuterLoop
+			}
+		}
+	}
+
+ +

Continue statements

+ +

+A "continue" statement begins the next iteration of the +innermost "for" loop at its post statement. +The "for" loop must be within the same function. +

+ +
+ContinueStmt = "continue" [ Label ] .
+
+ +

+If there is a label, it must be that of an enclosing +"for" statement, and that is the one whose execution +advances. +

+ +
+RowLoop:
+	for y, row := range rows {
+		for x, data := range row {
+			if data == endOfRow {
+				continue RowLoop
+			}
+			row[x] = data + bias(x, y)
+		}
+	}
+
+ +

Goto statements

+ +

+A "goto" statement transfers control to the statement with the corresponding label +within the same function. +

+ +
+GotoStmt = "goto" Label .
+
+ +
+goto Error
+
+ +

+Executing the "goto" statement must not cause any variables to come into +scope that were not already in scope at the point of the goto. +For instance, this example: +

+ +
+	goto L  // BAD
+	v := 3
+L:
+
+ +

+is erroneous because the jump to label L skips +the creation of v. +

+ +

+A "goto" statement outside a block cannot jump to a label inside that block. +For instance, this example: +

+ +
+if n%2 == 1 {
+	goto L1
+}
+for n > 0 {
+	f()
+	n--
+L1:
+	f()
+	n--
+}
+
+ +

+is erroneous because the label L1 is inside +the "for" statement's block but the goto is not. +

+ +

Fallthrough statements

+ +

+A "fallthrough" statement transfers control to the first statement of the +next case clause in an expression "switch" statement. +It may be used only as the final non-empty statement in such a clause. +

+ +
+FallthroughStmt = "fallthrough" .
+
+ + +

Defer statements

+ +

+A "defer" statement invokes a function whose execution is deferred +to the moment the surrounding function returns, either because the +surrounding function executed a return statement, +reached the end of its function body, +or because the corresponding goroutine is panicking. +

+ +
+DeferStmt = "defer" Expression .
+
+ +

+The expression must be a function or method call; it cannot be parenthesized. +Calls of built-in functions are restricted as for +expression statements. +

+ +

+Each time a "defer" statement +executes, the function value and parameters to the call are +evaluated as usual +and saved anew but the actual function is not invoked. +Instead, deferred functions are invoked immediately before +the surrounding function returns, in the reverse order +they were deferred. That is, if the surrounding function +returns through an explicit return statement, +deferred functions are executed after any result parameters are set +by that return statement but before the function returns to its caller. +If a deferred function value evaluates +to nil, execution panics +when the function is invoked, not when the "defer" statement is executed. +

+ +

+For instance, if the deferred function is +a function literal and the surrounding +function has named result parameters that +are in scope within the literal, the deferred function may access and modify +the result parameters before they are returned. +If the deferred function has any return values, they are discarded when +the function completes. +(See also the section on handling panics.) +

+ +
+lock(l)
+defer unlock(l)  // unlocking happens before surrounding function returns
+
+// prints 3 2 1 0 before surrounding function returns
+for i := 0; i <= 3; i++ {
+	defer fmt.Print(i)
+}
+
+// f returns 42
+func f() (result int) {
+	defer func() {
+		// result is accessed after it was set to 6 by the return statement
+		result *= 7
+	}()
+	return 6
+}
+
+ +

Built-in functions

+ +

+Built-in functions are +predeclared. +They are called like any other function but some of them +accept a type instead of an expression as the first argument. +

+ +

+The built-in functions do not have standard Go types, +so they can only appear in call expressions; +they cannot be used as function values. +

+ +

Close

+ +

+For a channel c, the built-in function close(c) +records that no more values will be sent on the channel. +It is an error if c is a receive-only channel. +Sending to or closing a closed channel causes a run-time panic. +Closing the nil channel also causes a run-time panic. +After calling close, and after any previously +sent values have been received, receive operations will return +the zero value for the channel's type without blocking. +The multi-valued receive operation +returns a received value along with an indication of whether the channel is closed. +

+ + +

Length and capacity

+ +

+The built-in functions len and cap take arguments +of various types and return a result of type int. +The implementation guarantees that the result always fits into an int. +

+ +
+Call      Argument type    Result
+
+len(s)    string type      string length in bytes
+          [n]T, *[n]T      array length (== n)
+          []T              slice length
+          map[K]T          map length (number of defined keys)
+          chan T           number of elements queued in channel buffer
+
+cap(s)    [n]T, *[n]T      array length (== n)
+          []T              slice capacity
+          chan T           channel buffer capacity
+
+ +

+The capacity of a slice is the number of elements for which there is +space allocated in the underlying array. +At any time the following relationship holds: +

+ +
+0 <= len(s) <= cap(s)
+
+ +

+The length of a nil slice, map or channel is 0. +The capacity of a nil slice or channel is 0. +

+ +

+The expression len(s) is constant if +s is a string constant. The expressions len(s) and +cap(s) are constants if the type of s is an array +or pointer to an array and the expression s does not contain +channel receives or (non-constant) +function calls; in this case s is not evaluated. +Otherwise, invocations of len and cap are not +constant and s is evaluated. +

+ +
+const (
+	c1 = imag(2i)                    // imag(2i) = 2.0 is a constant
+	c2 = len([10]float64{2})         // [10]float64{2} contains no function calls
+	c3 = len([10]float64{c1})        // [10]float64{c1} contains no function calls
+	c4 = len([10]float64{imag(2i)})  // imag(2i) is a constant and no function call is issued
+	c5 = len([10]float64{imag(z)})   // invalid: imag(z) is a (non-constant) function call
+)
+var z complex128
+
+ +

Allocation

+ +

+The built-in function new takes a type T, +allocates storage for a variable of that type +at run time, and returns a value of type *T +pointing to it. +The variable is initialized as described in the section on +initial values. +

+ +
+new(T)
+
+ +

+For instance +

+ +
+type S struct { a int; b float64 }
+new(S)
+
+ +

+allocates storage for a variable of type S, +initializes it (a=0, b=0.0), +and returns a value of type *S containing the address +of the location. +

+ +

Making slices, maps and channels

+ +

+The built-in function make takes a type T, +which must be a slice, map or channel type, +optionally followed by a type-specific list of expressions. +It returns a value of type T (not *T). +The memory is initialized as described in the section on +initial values. +

+ +
+Call             Type T     Result
+
+make(T, n)       slice      slice of type T with length n and capacity n
+make(T, n, m)    slice      slice of type T with length n and capacity m
+
+make(T)          map        map of type T
+make(T, n)       map        map of type T with initial space for approximately n elements
+
+make(T)          channel    unbuffered channel of type T
+make(T, n)       channel    buffered channel of type T, buffer size n
+
+ + +

+Each of the size arguments n and m must be of integer type +or an untyped constant. +A constant size argument must be non-negative and representable +by a value of type int; if it is an untyped constant it is given type int. +If both n and m are provided and are constant, then +n must be no larger than m. +If n is negative or larger than m at run time, +a run-time panic occurs. +

+ +
+s := make([]int, 10, 100)       // slice with len(s) == 10, cap(s) == 100
+s := make([]int, 1e3)           // slice with len(s) == cap(s) == 1000
+s := make([]int, 1<<63)         // illegal: len(s) is not representable by a value of type int
+s := make([]int, 10, 0)         // illegal: len(s) > cap(s)
+c := make(chan int, 10)         // channel with a buffer size of 10
+m := make(map[string]int, 100)  // map with initial space for approximately 100 elements
+
+ +

+Calling make with a map type and size hint n will +create a map with initial space to hold n map elements. +The precise behavior is implementation-dependent. +

+ + +

Appending to and copying slices

+ +

+The built-in functions append and copy assist in +common slice operations. +For both functions, the result is independent of whether the memory referenced +by the arguments overlaps. +

+ +

+The variadic function append +appends zero or more values x +to s of type S, which must be a slice type, and +returns the resulting slice, also of type S. +The values x are passed to a parameter of type ...T +where T is the element type of +S and the respective +parameter passing rules apply. +As a special case, append also accepts a first argument +assignable to type []byte with a second argument of +string type followed by .... This form appends the +bytes of the string. +

+ +
+append(s S, x ...T) S  // T is the element type of S
+
+ +

+If the capacity of s is not large enough to fit the additional +values, append allocates a new, sufficiently large underlying +array that fits both the existing slice elements and the additional values. +Otherwise, append re-uses the underlying array. +

+ +
+s0 := []int{0, 0}
+s1 := append(s0, 2)                // append a single element     s1 == []int{0, 0, 2}
+s2 := append(s1, 3, 5, 7)          // append multiple elements    s2 == []int{0, 0, 2, 3, 5, 7}
+s3 := append(s2, s0...)            // append a slice              s3 == []int{0, 0, 2, 3, 5, 7, 0, 0}
+s4 := append(s3[3:6], s3[2:]...)   // append overlapping slice    s4 == []int{3, 5, 7, 2, 3, 5, 7, 0, 0}
+
+var t []interface{}
+t = append(t, 42, 3.1415, "foo")   //                             t == []interface{}{42, 3.1415, "foo"}
+
+var b []byte
+b = append(b, "bar"...)            // append string contents      b == []byte{'b', 'a', 'r' }
+
+ +

+The function copy copies slice elements from +a source src to a destination dst and returns the +number of elements copied. +Both arguments must have identical element type T and must be +assignable to a slice of type []T. +The number of elements copied is the minimum of +len(src) and len(dst). +As a special case, copy also accepts a destination argument assignable +to type []byte with a source argument of a string type. +This form copies the bytes from the string into the byte slice. +

+ +
+copy(dst, src []T) int
+copy(dst []byte, src string) int
+
+ +

+Examples: +

+ +
+var a = [...]int{0, 1, 2, 3, 4, 5, 6, 7}
+var s = make([]int, 6)
+var b = make([]byte, 5)
+n1 := copy(s, a[0:])            // n1 == 6, s == []int{0, 1, 2, 3, 4, 5}
+n2 := copy(s, s[2:])            // n2 == 4, s == []int{2, 3, 4, 5, 4, 5}
+n3 := copy(b, "Hello, World!")  // n3 == 5, b == []byte("Hello")
+
+ + +

Deletion of map elements

+ +

+The built-in function delete removes the element with key +k from a map m. The +type of k must be assignable +to the key type of m. +

+ +
+delete(m, k)  // remove element m[k] from map m
+
+ +

+If the map m is nil or the element m[k] +does not exist, delete is a no-op. +

+ + +

Manipulating complex numbers

+ +

+Three functions assemble and disassemble complex numbers. +The built-in function complex constructs a complex +value from a floating-point real and imaginary part, while +real and imag +extract the real and imaginary parts of a complex value. +

+ +
+complex(realPart, imaginaryPart floatT) complexT
+real(complexT) floatT
+imag(complexT) floatT
+
+ +

+The type of the arguments and return value correspond. +For complex, the two arguments must be of the same +floating-point type and the return type is the complex type +with the corresponding floating-point constituents: +complex64 for float32 arguments, and +complex128 for float64 arguments. +If one of the arguments evaluates to an untyped constant, it is first implicitly +converted to the type of the other argument. +If both arguments evaluate to untyped constants, they must be non-complex +numbers or their imaginary parts must be zero, and the return value of +the function is an untyped complex constant. +

+ +

+For real and imag, the argument must be +of complex type, and the return type is the corresponding floating-point +type: float32 for a complex64 argument, and +float64 for a complex128 argument. +If the argument evaluates to an untyped constant, it must be a number, +and the return value of the function is an untyped floating-point constant. +

+ +

+The real and imag functions together form the inverse of +complex, so for a value z of a complex type Z, +z == Z(complex(real(z), imag(z))). +

+ +

+If the operands of these functions are all constants, the return +value is a constant. +

+ +
+var a = complex(2, -2)             // complex128
+const b = complex(1.0, -1.4)       // untyped complex constant 1 - 1.4i
+x := float32(math.Cos(math.Pi/2))  // float32
+var c64 = complex(5, -x)           // complex64
+var s int = complex(1, 0)          // untyped complex constant 1 + 0i can be converted to int
+_ = complex(1, 2<<s)               // illegal: 2 assumes floating-point type, cannot shift
+var rl = real(c64)                 // float32
+var im = imag(a)                   // float64
+const c = imag(b)                  // untyped constant -1.4
+_ = imag(3 << s)                   // illegal: 3 assumes complex type, cannot shift
+
+ +

Handling panics

+ +

Two built-in functions, panic and recover, +assist in reporting and handling run-time panics +and program-defined error conditions. +

+ +
+func panic(interface{})
+func recover() interface{}
+
+ +

+While executing a function F, +an explicit call to panic or a run-time panic +terminates the execution of F. +Any functions deferred by F +are then executed as usual. +Next, any deferred functions run by F's caller are run, +and so on up to any deferred by the top-level function in the executing goroutine. +At that point, the program is terminated and the error +condition is reported, including the value of the argument to panic. +This termination sequence is called panicking. +

+ +
+panic(42)
+panic("unreachable")
+panic(Error("cannot parse"))
+
+ +

+The recover function allows a program to manage behavior +of a panicking goroutine. +Suppose a function G defers a function D that calls +recover and a panic occurs in a function on the same goroutine in which G +is executing. +When the running of deferred functions reaches D, +the return value of D's call to recover will be the value passed to the call of panic. +If D returns normally, without starting a new +panic, the panicking sequence stops. In that case, +the state of functions called between G and the call to panic +is discarded, and normal execution resumes. +Any functions deferred by G before D are then run and G's +execution terminates by returning to its caller. +

+ +

+The return value of recover is nil if any of the following conditions holds: +

+
    +
  • +panic's argument was nil; +
    • +
  • +the goroutine is not panicking; +
    • +
  • +recover was not called directly by a deferred function. +
    • +
+ +

+The protect function in the example below invokes +the function argument g and protects callers from +run-time panics raised by g. +

+ +
+func protect(g func()) {
+	defer func() {
+		log.Println("done")  // Println executes normally even if there is a panic
+		if x := recover(); x != nil {
+			log.Printf("run time panic: %v", x)
+		}
+	}()
+	log.Println("start")
+	g()
+}
+
+ + +

Bootstrapping

+ +

+Current implementations provide several built-in functions useful during +bootstrapping. These functions are documented for completeness but are not +guaranteed to stay in the language. They do not return a result. +

+ +
+Function   Behavior
+
+print      prints all arguments; formatting of arguments is implementation-specific
+println    like print but prints spaces between arguments and a newline at the end
+
+ +

+Implementation restriction: print and println need not +accept arbitrary argument types, but printing of boolean, numeric, and string +types must be supported. +

+ +

Packages

+ +

+Go programs are constructed by linking together packages. +A package in turn is constructed from one or more source files +that together declare constants, types, variables and functions +belonging to the package and which are accessible in all files +of the same package. Those elements may be +exported and used in another package. +

+ +

Source file organization

+ +

+Each source file consists of a package clause defining the package +to which it belongs, followed by a possibly empty set of import +declarations that declare packages whose contents it wishes to use, +followed by a possibly empty set of declarations of functions, +types, variables, and constants. +

+ +
+SourceFile       = PackageClause ";" { ImportDecl ";" } { TopLevelDecl ";" } .
+
+ +

Package clause

+ +

+A package clause begins each source file and defines the package +to which the file belongs. +

+ +
+PackageClause  = "package" PackageName .
+PackageName    = identifier .
+
+ +

+The PackageName must not be the blank identifier. +

+ +
+package math
+
+ +

+A set of files sharing the same PackageName form the implementation of a package. +An implementation may require that all source files for a package inhabit the same directory. +

+ +

Import declarations

+ +

+An import declaration states that the source file containing the declaration +depends on functionality of the imported package +(§Program initialization and execution) +and enables access to exported identifiers +of that package. +The import names an identifier (PackageName) to be used for access and an ImportPath +that specifies the package to be imported. +

+ +
+ImportDecl       = "import" ( ImportSpec | "(" { ImportSpec ";" } ")" ) .
+ImportSpec       = [ "." | PackageName ] ImportPath .
+ImportPath       = string_lit .
+
+ +

+The PackageName is used in qualified identifiers +to access exported identifiers of the package within the importing source file. +It is declared in the file block. +If the PackageName is omitted, it defaults to the identifier specified in the +package clause of the imported package. +If an explicit period (.) appears instead of a name, all the +package's exported identifiers declared in that package's +package block will be declared in the importing source +file's file block and must be accessed without a qualifier. +

+ +

+The interpretation of the ImportPath is implementation-dependent but +it is typically a substring of the full file name of the compiled +package and may be relative to a repository of installed packages. +

+ +

+Implementation restriction: A compiler may restrict ImportPaths to +non-empty strings using only characters belonging to +Unicode's +L, M, N, P, and S general categories (the Graphic characters without +spaces) and may also exclude the characters +!"#$%&'()*,:;<=>?[\]^`{|} +and the Unicode replacement character U+FFFD. +

+ +

+Assume we have compiled a package containing the package clause +package math, which exports function Sin, and +installed the compiled package in the file identified by +"lib/math". +This table illustrates how Sin is accessed in files +that import the package after the +various types of import declaration. +

+ +
+Import declaration          Local name of Sin
+
+import   "lib/math"         math.Sin
+import m "lib/math"         m.Sin
+import . "lib/math"         Sin
+
+ +

+An import declaration declares a dependency relation between +the importing and imported package. +It is illegal for a package to import itself, directly or indirectly, +or to directly import a package without +referring to any of its exported identifiers. To import a package solely for +its side-effects (initialization), use the blank +identifier as explicit package name: +

+ +
+import _ "lib/math"
+
+ + +

An example package

+ +

+Here is a complete Go package that implements 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 'src' to channel 'dst',
+// removing those divisible by 'prime'.
+func filter(src <-chan int, dst chan<- int, prime int) {
+	for i := range src {  // Loop over values received from 'src'.
+		if i%prime != 0 {
+			dst <- i  // Send 'i' to channel 'dst'.
+		}
+	}
+}
+
+// The prime sieve: Daisy-chain filter processes together.
+func sieve() {
+	ch := make(chan int)  // Create a new channel.
+	go generate(ch)       // Start generate() as a subprocess.
+	for {
+		prime := <-ch
+		fmt.Print(prime, "\n")
+		ch1 := make(chan int)
+		go filter(ch, ch1, prime)
+		ch = ch1
+	}
+}
+
+func main() {
+	sieve()
+}
+
+ +

Program initialization and execution

+ +

The zero value

+

+When storage is allocated for a variable, +either through a declaration or a call of new, or when +a new value is created, either through a composite literal or a call +of make, +and no explicit initialization is provided, the variable or value is +given a default value. Each element of such a variable or value is +set to the zero value for its type: false for booleans, +0 for numeric types, "" +for strings, and nil for pointers, functions, interfaces, slices, channels, and maps. +This initialization is done recursively, so for instance each element of an +array of structs will have its fields zeroed if no value is specified. +

+

+These two simple declarations are equivalent: +

+ +
+var i int
+var i int = 0
+
+ +

+After +

+ +
+type T struct { i int; f float64; next *T }
+t := new(T)
+
+ +

+the following holds: +

+ +
+t.i == 0
+t.f == 0.0
+t.next == nil
+
+ +

+The same would also be true after +

+ +
+var t T
+
+ +

Package initialization

+ +

+Within a package, package-level variable initialization proceeds stepwise, +with each step selecting the variable earliest in declaration order +which has no dependencies on uninitialized variables. +

+ +

+More precisely, a package-level variable is considered ready for +initialization if it is not yet initialized and either has +no initialization expression or +its initialization expression has no dependencies on uninitialized variables. +Initialization proceeds by repeatedly initializing the next package-level +variable that is earliest in declaration order and ready for initialization, +until there are no variables ready for initialization. +

+ +

+If any variables are still uninitialized when this +process ends, those variables are part of one or more initialization cycles, +and the program is not valid. +

+ +

+Multiple variables on the left-hand side of a variable declaration initialized +by single (multi-valued) expression on the right-hand side are initialized +together: If any of the variables on the left-hand side is initialized, all +those variables are initialized in the same step. +

+ +
+var x = a
+var a, b = f() // a and b are initialized together, before x is initialized
+
+ +

+For the purpose of package initialization, blank +variables are treated like any other variables in declarations. +

+ +

+The declaration order of variables declared in multiple files is determined +by the order in which the files are presented to the compiler: Variables +declared in the first file are declared before any of the variables declared +in the second file, and so on. +

+ +

+Dependency analysis does not rely on the actual values of the +variables, only on lexical references to them in the source, +analyzed transitively. For instance, if a variable x's +initialization expression refers to a function whose body refers to +variable y then x depends on y. +Specifically: +

+ +
    +
  • +A reference to a variable or function is an identifier denoting that +variable or function. +
    • + +
  • +A reference to a method m is a +method value or +method expression of the form +t.m, where the (static) type of t is +not an interface type, and the method m is in the +method set of t. +It is immaterial whether the resulting function value +t.m is invoked. +
    • + +
  • +A variable, function, or method x depends on a variable +y if x's initialization expression or body +(for functions and methods) contains a reference to y +or to a function or method that depends on y. +
    • +
+ +

+For example, given the declarations +

+ +
+var (
+	a = c + b  // == 9
+	b = f()    // == 4
+	c = f()    // == 5
+	d = 3      // == 5 after initialization has finished
+)
+
+func f() int {
+	d++
+	return d
+}
+
+ +

+the initialization order is d, b, c, a. +Note that the order of subexpressions in initialization expressions is irrelevant: +a = c + b and a = b + c result in the same initialization +order in this example. +

+ +

+Dependency analysis is performed per package; only references referring +to variables, functions, and (non-interface) methods declared in the current +package are considered. If other, hidden, data dependencies exists between +variables, the initialization order between those variables is unspecified. +

+ +

+For instance, given the declarations +

+ +
+var x = I(T{}).ab()   // x has an undetected, hidden dependency on a and b
+var _ = sideEffect()  // unrelated to x, a, or b
+var a = b
+var b = 42
+
+type I interface      { ab() []int }
+type T struct{}
+func (T) ab() []int   { return []int{a, b} }
+
+ +

+the variable a will be initialized after b but +whether x is initialized before b, between +b and a, or after a, and +thus also the moment at which sideEffect() is called (before +or after x is initialized) is not specified. +

+ +

+Variables may also be initialized using functions named init +declared in the package block, with no arguments and no result parameters. +

+ +
+func init() { … }
+
+ +

+Multiple such functions may be defined per package, even within a single +source file. In the package block, the init identifier can +be used only to declare init functions, yet the identifier +itself is not declared. Thus +init functions cannot be referred to from anywhere +in a program. +

+ +

+A package with no imports is initialized by assigning initial values +to all its package-level variables followed by calling all init +functions in the order they appear in the source, possibly in multiple files, +as presented to the compiler. +If a package has imports, the imported packages are initialized +before initializing the package itself. If multiple packages import +a package, the imported package will be initialized only once. +The importing of packages, by construction, guarantees that there +can be no cyclic initialization dependencies. +

+ +

+Package initialization—variable initialization and the invocation of +init functions—happens in a single goroutine, +sequentially, one package at a time. +An init function may launch other goroutines, which can run +concurrently with the initialization code. However, initialization +always sequences +the init functions: it will not invoke the next one +until the previous one has returned. +

+ +

+To ensure reproducible initialization behavior, build systems are encouraged +to present multiple files belonging to the same package in lexical file name +order to a compiler. +

+ + +

Program execution

+

+A complete program is created by linking a single, unimported package +called the main package with all the packages it imports, transitively. +The main package must +have package name main and +declare a function main that takes no +arguments and returns no value. +

+ +
+func main() { … }
+
+ +

+Program execution begins by initializing the main package and then +invoking the function main. +When that function invocation returns, the program exits. +It does not wait for other (non-main) goroutines to complete. +

+ +

Errors

+ +

+The predeclared type error is defined as +

+ +
+type error interface {
+	Error() string
+}
+
+ +

+It is the conventional interface for representing an error condition, +with the nil value representing no error. +For instance, a function to read data from a file might be defined: +

+ +
+func Read(f *File, b []byte) (n int, err error)
+
+ +

Run-time panics

+ +

+Execution errors such as attempting to index an array out +of bounds trigger a run-time panic equivalent to a call of +the built-in function panic +with a value of the implementation-defined interface type runtime.Error. +That type satisfies the predeclared interface type +error. +The exact error values that +represent distinct run-time error conditions are unspecified. +

+ +
+package runtime
+
+type Error interface {
+	error
+	// and perhaps other methods
+}
+
+ +

System considerations

+ +

Package unsafe

+ +

+The built-in package unsafe, known to the compiler +and accessible through the import path "unsafe", +provides facilities for low-level programming including operations +that violate the type system. A package using unsafe +must be vetted manually for type safety and may not be portable. +The package provides the following interface: +

+ +
+package unsafe
+
+type ArbitraryType int  // shorthand for an arbitrary Go type; it is not a real type
+type Pointer *ArbitraryType
+
+func Alignof(variable ArbitraryType) uintptr
+func Offsetof(selector ArbitraryType) uintptr
+func Sizeof(variable ArbitraryType) uintptr
+
+type IntegerType int  // shorthand for an integer type; it is not a real type
+func Add(ptr Pointer, len IntegerType) Pointer
+func Slice(ptr *ArbitraryType, len IntegerType) []ArbitraryType
+
+ +

+A Pointer is a pointer type but a Pointer +value may not be dereferenced. +Any pointer or value of underlying type uintptr can be converted to +a type of underlying type Pointer and vice versa. +The effect of converting between Pointer and uintptr is implementation-defined. +

+ +
+var f float64
+bits = *(*uint64)(unsafe.Pointer(&f))
+
+type ptr unsafe.Pointer
+bits = *(*uint64)(ptr(&f))
+
+var p ptr = nil
+
+ +

+The functions Alignof and Sizeof take an expression x +of any type and return the alignment or size, respectively, of a hypothetical variable v +as if v was declared via var v = x. +

+

+The function Offsetof takes a (possibly parenthesized) selector +s.f, denoting a field f of the struct denoted by s +or *s, and returns the field offset in bytes relative to the struct's address. +If f is an embedded field, it must be reachable +without pointer indirections through fields of the struct. +For a struct s with field f: +

+ +
+uintptr(unsafe.Pointer(&s)) + unsafe.Offsetof(s.f) == uintptr(unsafe.Pointer(&s.f))
+
+ +

+Computer architectures may require memory addresses to be aligned; +that is, for addresses of a variable to be a multiple of a factor, +the variable's type's alignment. The function Alignof +takes an expression denoting a variable of any type and returns the +alignment of the (type of the) variable in bytes. For a variable +x: +

+ +
+uintptr(unsafe.Pointer(&x)) % unsafe.Alignof(x) == 0
+
+ +

+Calls to Alignof, Offsetof, and +Sizeof are compile-time constant expressions of type uintptr. +

+ +

+The function Add adds len to ptr +and returns the updated pointer unsafe.Pointer(uintptr(ptr) + uintptr(len)). +The len argument must be of integer type or an untyped constant. +A constant len argument must be representable by a value of type int; +if it is an untyped constant it is given type int. +The rules for valid uses of Pointer still apply. +

+ +

+The function Slice returns a slice whose underlying array starts at ptr +and whose length and capacity are len. +Slice(ptr, len) is equivalent to +

+ +
+(*[len]ArbitraryType)(unsafe.Pointer(ptr))[:]
+
+ +

+except that, as a special case, if ptr +is nil and len is zero, +Slice returns nil. +

+ +

+The len argument must be of integer type or an untyped constant. +A constant len argument must be non-negative and representable by a value of type int; +if it is an untyped constant it is given type int. +At run time, if len is negative, +or if ptr is nil and len is not zero, +a run-time panic occurs. +

+ +

Size and alignment guarantees

+ +

+For the numeric types, the following sizes are guaranteed: +

+ +
+type                                 size in bytes
+
+byte, uint8, int8                     1
+uint16, int16                         2
+uint32, int32, float32                4
+uint64, int64, float64, complex64     8
+complex128                           16
+
+ +

+The following minimal alignment properties are guaranteed: +

+
    +
  1. For a variable x of any type: unsafe.Alignof(x) is at least 1. +
    2. + +
  2. For a variable x of struct type: unsafe.Alignof(x) is the largest of + all the values unsafe.Alignof(x.f) for each field f of x, but at least 1. +
    3. + +
  3. For a variable x of array type: unsafe.Alignof(x) is the same as + the alignment of a variable of the array's element type. +
    4. +
+ +

+A struct or array type has size zero if it contains no fields (or elements, respectively) that have a size greater than zero. Two distinct zero-size variables may have the same address in memory. +

From 0aa194f7589fb5f75fc3a9c34bb69943daf6fc5c Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 9 Nov 2021 21:12:03 -0800 Subject: [PATCH 078/752] cmd/compile/internal/types2: use type variables consistently in Checker.conversion We have V and T and Vu and Tu. When calling the various isX predicates consistently use Vu and Tu. (We could also use V an T because the predicates call under anyway, but using Vu and Tu removes an unnecessary call to Named.under if V or T are *Named.) Also, removed some outdated comments. Change-Id: I6fcd9ce5f6292e89ac2afd597b72fd0790e84ff1 Reviewed-on: https://go-review.googlesource.com/c/go/+/362895 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Go Bot Reviewed-by: Robert Findley --- .../compile/internal/types2/conversions.go | 24 +++++++------------ 1 file changed, 8 insertions(+), 16 deletions(-) diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go index dd89f29762..7f93e2467f 100644 --- a/src/cmd/compile/internal/types2/conversions.go +++ b/src/cmd/compile/internal/types2/conversions.go @@ -142,39 +142,39 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { } // "V and T are both integer or floating point types" - if isIntegerOrFloat(V) && isIntegerOrFloat(T) { + if isIntegerOrFloat(Vu) && isIntegerOrFloat(Tu) { return true } // "V and T are both complex types" - if isComplex(V) && isComplex(T) { + if isComplex(Vu) && isComplex(Tu) { return true } // "V is an integer or a slice of bytes or runes and T is a string type" - if (isInteger(V) || isBytesOrRunes(Vu)) && isString(T) { + if (isInteger(Vu) || isBytesOrRunes(Vu)) && isString(Tu) { return true } // "V is a string and T is a slice of bytes or runes" - if isString(V) && isBytesOrRunes(Tu) { + if isString(Vu) && isBytesOrRunes(Tu) { return true } // package unsafe: // "any pointer or value of underlying type uintptr can be converted into a unsafe.Pointer" - if (isPointer(Vu) || isUintptr(Vu)) && isUnsafePointer(T) { + if (isPointer(Vu) || isUintptr(Vu)) && isUnsafePointer(Tu) { return true } // "and vice versa" - if isUnsafePointer(V) && (isPointer(Tu) || isUintptr(Tu)) { + if isUnsafePointer(Vu) && (isPointer(Tu) || isUintptr(Tu)) { return true } // "V a slice, T is a pointer-to-array type, // and the slice and array types have identical element types." - if s, _ := under(V).(*Slice); s != nil { - if p, _ := under(T).(*Pointer); p != nil { + if s, _ := Vu.(*Slice); s != nil { + if p, _ := Tu.(*Pointer); p != nil { if a, _ := under(p.Elem()).(*Array); a != nil { if Identical(s.Elem(), a.Elem()) { if check == nil || check.allowVersion(check.pkg, 1, 17) { @@ -257,20 +257,12 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { return false } -// Helper predicates for convertibleToImpl. The types provided to convertibleToImpl -// may be type parameters but they won't have specific type terms. Thus it is ok to -// use the toT convenience converters in the predicates below. - func isUintptr(typ Type) bool { t, _ := under(typ).(*Basic) return t != nil && t.kind == Uintptr } func isUnsafePointer(typ Type) bool { - // TODO(gri): Is this under(typ).(*Basic) instead of typ.(*Basic) correct? - // (The former calls under(), while the latter doesn't.) - // The spec does not say so, but gc claims it is. See also - // issue 6326. t, _ := under(typ).(*Basic) return t != nil && t.kind == UnsafePointer } From 8a3be150775f80850e179bd1860b286be27ca407 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 10 Nov 2021 08:12:21 -0800 Subject: [PATCH 079/752] cmd/compile/internal/types2: rename structure to structuralType And rename structureString to structuralString. Now that we have an updated definition for structural types in the (forthcoming) spec, name the corresponding function accordingly. No semantic changes. Change-Id: Iab838f01a37075bedf2d8bc4f166b0217672b85f Reviewed-on: https://go-review.googlesource.com/c/go/+/362994 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Go Bot --- src/cmd/compile/internal/types2/builtins.go | 24 +++++++++---------- src/cmd/compile/internal/types2/call.go | 2 +- src/cmd/compile/internal/types2/expr.go | 2 +- src/cmd/compile/internal/types2/index.go | 2 +- src/cmd/compile/internal/types2/infer.go | 2 +- src/cmd/compile/internal/types2/predicates.go | 4 ++-- src/cmd/compile/internal/types2/stmt.go | 2 +- 7 files changed, 19 insertions(+), 19 deletions(-) diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go index 916aed40b3..4c659d65cd 100644 --- a/src/cmd/compile/internal/types2/builtins.go +++ b/src/cmd/compile/internal/types2/builtins.go @@ -82,7 +82,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( // of S and the respective parameter passing rules apply." S := x.typ var T Type - if s, _ := structure(S).(*Slice); s != nil { + if s, _ := structuralType(S).(*Slice); s != nil { T = s.elem } else { check.errorf(x, invalidArg+"%s is not a slice", x) @@ -327,14 +327,14 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( case _Copy: // copy(x, y []T) int - dst, _ := structure(x.typ).(*Slice) + dst, _ := structuralType(x.typ).(*Slice) var y operand arg(&y, 1) if y.mode == invalid { return } - src, _ := structureString(y.typ).(*Slice) + src, _ := structuralString(y.typ).(*Slice) if dst == nil || src == nil { check.errorf(x, invalidArg+"copy expects slice arguments; found %s and %s", x, &y) @@ -464,7 +464,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( } var min int // minimum number of arguments - switch structure(T).(type) { + switch structuralType(T).(type) { case *Slice: min = 2 case *Map, *Chan: @@ -774,14 +774,14 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( // or nil otherwise. If typ is not a type parameter, Structure returns // the underlying type. func Structure(typ Type) Type { - return structure(typ) + return structuralType(typ) } -// If typ is a type parameter, structure returns the single underlying -// type of all types in the corresponding type constraint if it exists, -// or nil otherwise. If typ is not a type parameter, structure returns +// If typ is a type parameter, structuralType returns the single underlying +// type of all types in the corresponding type constraint if it exists, or +// nil otherwise. If typ is not a type parameter, structuralType returns // the underlying type. -func structure(typ Type) Type { +func structuralType(typ Type) Type { var su Type if underIs(typ, func(u Type) bool { if su != nil && !Identical(su, u) { @@ -796,10 +796,10 @@ func structure(typ Type) Type { return nil } -// structureString is like structure but also considers []byte and -// string as "identical". In this case, if successful, the result +// structuralString is like structuralType but also considers []byte +// and string as "identical". In this case, if successful, the result // is always []byte. -func structureString(typ Type) Type { +func structuralString(typ Type) Type { var su Type if underIs(typ, func(u Type) bool { if isString(u) { diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go index 3a571285c1..0540feaa78 100644 --- a/src/cmd/compile/internal/types2/call.go +++ b/src/cmd/compile/internal/types2/call.go @@ -170,7 +170,7 @@ func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind { cgocall := x.mode == cgofunc // a type parameter may be "called" if all types have the same signature - sig, _ := structure(x.typ).(*Signature) + sig, _ := structuralType(x.typ).(*Signature) if sig == nil { check.errorf(x, invalidOp+"cannot call non-function %s", x) x.mode = invalid diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index 8125fba717..169417016f 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -1258,7 +1258,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin goto Error } - switch utyp := structure(base).(type) { + switch utyp := structuralType(base).(type) { case *Struct: // Prevent crash if the struct referred to is not yet set up. // See analogous comment for *Array. diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go index f096674536..10e85ef6e1 100644 --- a/src/cmd/compile/internal/types2/index.go +++ b/src/cmd/compile/internal/types2/index.go @@ -210,7 +210,7 @@ func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) { valid := false length := int64(-1) // valid if >= 0 - switch u := structure(x.typ).(type) { + switch u := structuralType(x.typ).(type) { case nil: check.errorf(x, invalidOp+"cannot slice %s: type set has no single underlying type", x) x.mode = invalid diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go index 24c461f1c3..4f85a5894c 100644 --- a/src/cmd/compile/internal/types2/infer.go +++ b/src/cmd/compile/internal/types2/infer.go @@ -378,7 +378,7 @@ func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type, // If a constraint has a structural type, unify the corresponding type parameter with it. for _, tpar := range tparams { - sbound := structure(tpar) + sbound := structuralType(tpar) if sbound != nil { // If the structural type is the underlying type of a single // defined type in the constraint, use that defined type instead. diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go index 8d676ed8f6..f1fd33c5de 100644 --- a/src/cmd/compile/internal/types2/predicates.go +++ b/src/cmd/compile/internal/types2/predicates.go @@ -31,7 +31,7 @@ func isBasic(t Type, info BasicInfo) bool { // The allX predicates below report whether t is an X. // If t is a type parameter the result is true if isX is true // for all specified types of the type parameter's type set. -// allX is an optimized version of isX(structure(t)) (which +// allX is an optimized version of isX(structuralType(t)) (which // is the same as underIs(t, isX)). func allBoolean(t Type) bool { return allBasic(t, IsBoolean) } @@ -45,7 +45,7 @@ func allNumericOrString(t Type) bool { return allBasic(t, IsNumeric|IsString) } // allBasic reports whether under(t) is a basic type with the specified info. // If t is a type parameter, the result is true if isBasic(t, info) is true // for all specific types of the type parameter's type set. -// allBasic(t, info) is an optimized version of isBasic(structure(t), info). +// allBasic(t, info) is an optimized version of isBasic(structuralType(t), info). func allBasic(t Type, info BasicInfo) bool { switch u := under(t).(type) { case *Basic: diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go index eaf420aca7..39b24398d7 100644 --- a/src/cmd/compile/internal/types2/stmt.go +++ b/src/cmd/compile/internal/types2/stmt.go @@ -836,7 +836,7 @@ func (check *Checker) rangeStmt(inner stmtContext, s *syntax.ForStmt, rclause *s if x.mode != invalid { // Ranging over a type parameter is permitted if it has a single underlying type. var cause string - u := structure(x.typ) + u := structuralType(x.typ) switch t := u.(type) { case nil: cause = "type set has no single underlying type" From 097aaa9cd68fdce10b81fbba43fbb6569a95b53f Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Wed, 10 Nov 2021 11:21:57 -0500 Subject: [PATCH 080/752] go/doc: don't treat functions returning type parameters as constructors Functions returning type parameters were erroneously being interpreted as 'constructors' of their type parameter, resulting in them being excluded from documentation. Fix this by explicitly excluding type parameters when looking for defined type names among function results. Fixes #49477 Change-Id: I22510f655f47e192a852332df5b91740f46c51eb Reviewed-on: https://go-review.googlesource.com/c/go/+/362758 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Jonathan Amsterdam TryBot-Result: Go Bot --- src/go/doc/reader.go | 21 +++++++++++++++++++++ src/go/doc/testdata/generics.0.golden | 6 ++++++ src/go/doc/testdata/generics.1.golden | 6 ++++++ src/go/doc/testdata/generics.2.golden | 6 ++++++ src/go/doc/testdata/generics.go | 13 +++++++++++++ 5 files changed, 52 insertions(+) diff --git a/src/go/doc/reader.go b/src/go/doc/reader.go index 348b9b59a0..7ff868f062 100644 --- a/src/go/doc/reader.go +++ b/src/go/doc/reader.go @@ -425,6 +425,11 @@ func (r *reader) readFunc(fun *ast.FuncDecl) { factoryType = t.Elt } if n, imp := baseTypeName(factoryType); !imp && r.isVisible(n) && !r.isPredeclared(n) { + if lookupTypeParam(n, fun.Type.TypeParams) != nil { + // Issue #49477: don't associate fun with its type parameter result. + // A type parameter is not a defined type. + continue + } if t := r.lookupType(n); t != nil { typ = t numResultTypes++ @@ -446,6 +451,22 @@ func (r *reader) readFunc(fun *ast.FuncDecl) { r.funcs.set(fun, r.mode&PreserveAST != 0) } +// lookupTypeParam searches for type parameters named name within the tparams +// field list, returning the relevant identifier if found, or nil if not. +func lookupTypeParam(name string, tparams *ast.FieldList) *ast.Ident { + if tparams == nil { + return nil + } + for _, field := range tparams.List { + for _, id := range field.Names { + if id.Name == name { + return id + } + } + } + return nil +} + var ( noteMarker = `([A-Z][A-Z]+)\(([^)]+)\):?` // MARKER(uid), MARKER at least 2 chars, uid at least 1 char noteMarkerRx = lazyregexp.New(`^[ \t]*` + noteMarker) // MARKER(uid) at text start diff --git a/src/go/doc/testdata/generics.0.golden b/src/go/doc/testdata/generics.0.golden index a6dbcf673c..91c874c84d 100644 --- a/src/go/doc/testdata/generics.0.golden +++ b/src/go/doc/testdata/generics.0.golden @@ -14,6 +14,12 @@ FUNCTIONS // Func has an instantiated constraint. func Func[T Constraint[string, Type[int]]]() + // Single is not a factory function. + func Single[T any]() *T + + // Slice is not a factory function. + func Slice[T any]() []T + TYPES // AFuncType demonstrates filtering of parameters and type ... diff --git a/src/go/doc/testdata/generics.1.golden b/src/go/doc/testdata/generics.1.golden index c0548b5e96..923a4ce5d9 100644 --- a/src/go/doc/testdata/generics.1.golden +++ b/src/go/doc/testdata/generics.1.golden @@ -14,6 +14,12 @@ FUNCTIONS // Func has an instantiated constraint. func Func[T Constraint[string, Type[int]]]() + // Single is not a factory function. + func Single[T any]() *T + + // Slice is not a factory function. + func Slice[T any]() []T + TYPES // AFuncType demonstrates filtering of parameters and type ... diff --git a/src/go/doc/testdata/generics.2.golden b/src/go/doc/testdata/generics.2.golden index a6dbcf673c..91c874c84d 100644 --- a/src/go/doc/testdata/generics.2.golden +++ b/src/go/doc/testdata/generics.2.golden @@ -14,6 +14,12 @@ FUNCTIONS // Func has an instantiated constraint. func Func[T Constraint[string, Type[int]]]() + // Single is not a factory function. + func Single[T any]() *T + + // Slice is not a factory function. + func Slice[T any]() []T + TYPES // AFuncType demonstrates filtering of parameters and type ... diff --git a/src/go/doc/testdata/generics.go b/src/go/doc/testdata/generics.go index b5debba437..ba7187e4dd 100644 --- a/src/go/doc/testdata/generics.go +++ b/src/go/doc/testdata/generics.go @@ -59,3 +59,16 @@ func AnotherFunc[T ~struct{ f int }](_ struct{ f int }) {} // don't filter type parameters (to be consistent with function declarations), // but DO filter the RHS. type AFuncType[T ~struct{ f int }] func(_ struct{ f int }) + +// See issue #49477: type parameters should not be interpreted as named types +// for the purpose of determining whether a function is a factory function. + +// Slice is not a factory function. +func Slice[T any]() []T { + return nil +} + +// Single is not a factory function. +func Single[T any]() *T { + return nil +} From 6406e09f69c70b10cab58702f10456a3e9a83bef Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 10 Nov 2021 08:33:26 -0800 Subject: [PATCH 081/752] cmd/compile/internal/types2: move some functions into different files (cleanup) - move structuralType/structuralString into type.go - move functions exported for the compiler into compilersupport.go - updated/added comments - removed AsNamed and AsInterface - not needed by compiler No semantic changes. Change-Id: Ia454a49edafd627c2a25b0b71db4aa93ddd7f1f2 Reviewed-on: https://go-review.googlesource.com/c/go/+/362995 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Go Bot Reviewed-by: Robert Findley --- src/cmd/compile/internal/noder/decl.go | 2 +- src/cmd/compile/internal/noder/expr.go | 4 +- src/cmd/compile/internal/types2/builtins.go | 50 ------------- .../internal/types2/compilersupport.go | 34 +++++++++ src/cmd/compile/internal/types2/type.go | 74 ++++++++++--------- 5 files changed, 78 insertions(+), 86 deletions(-) create mode 100644 src/cmd/compile/internal/types2/compilersupport.go diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go index 82455f7d4a..0143fd3d45 100644 --- a/src/cmd/compile/internal/noder/decl.go +++ b/src/cmd/compile/internal/noder/decl.go @@ -94,7 +94,7 @@ func (g *irgen) funcDecl(out *ir.Nodes, decl *syntax.FuncDecl) { if recv != nil { t2 := deref2(recv.Type()) // This is a method, so set g.curDecl to recvTypeName.methName instead. - g.curDecl = types2.AsNamed(t2).Obj().Name() + "." + g.curDecl + g.curDecl = t2.(*types2.Named).Obj().Name() + "." + g.curDecl } fn := ir.NewFunc(g.pos(decl)) diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go index 24e6dbefe7..6891d1ec30 100644 --- a/src/cmd/compile/internal/noder/expr.go +++ b/src/cmd/compile/internal/noder/expr.go @@ -266,7 +266,7 @@ func (g *irgen) selectorExpr(pos src.XPos, typ types2.Type, expr *syntax.Selecto if wantPtr { recvType2Base = types2.AsPointer(recvType2).Elem() } - if types2.AsNamed(recvType2Base).TypeParams().Len() > 0 { + if recvType2Base.(*types2.Named).TypeParams().Len() > 0 { // recvType2 is the original generic type that is // instantiated for this method call. // selinfo.Recv() is the instantiated type @@ -338,7 +338,7 @@ func (g *irgen) compLit(typ types2.Type, lit *syntax.CompositeLit) ir.Node { return typed(g.typ(typ), n) } - _, isStruct := types2.Structure(typ).(*types2.Struct) + _, isStruct := types2.StructuralType(typ).(*types2.Struct) exprs := make([]ir.Node, len(lit.ElemList)) for i, elem := range lit.ElemList { diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go index 4c659d65cd..5c3f0aac8a 100644 --- a/src/cmd/compile/internal/types2/builtins.go +++ b/src/cmd/compile/internal/types2/builtins.go @@ -767,56 +767,6 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( return true } -// Structure is exported for the compiler. - -// If typ is a type parameter, Structure returns the single underlying -// type of all types in the corresponding type constraint if it exists, -// or nil otherwise. If typ is not a type parameter, Structure returns -// the underlying type. -func Structure(typ Type) Type { - return structuralType(typ) -} - -// If typ is a type parameter, structuralType returns the single underlying -// type of all types in the corresponding type constraint if it exists, or -// nil otherwise. If typ is not a type parameter, structuralType returns -// the underlying type. -func structuralType(typ Type) Type { - var su Type - if underIs(typ, func(u Type) bool { - if su != nil && !Identical(su, u) { - return false - } - // su == nil || Identical(su, u) - su = u - return true - }) { - return su - } - return nil -} - -// structuralString is like structuralType but also considers []byte -// and string as "identical". In this case, if successful, the result -// is always []byte. -func structuralString(typ Type) Type { - var su Type - if underIs(typ, func(u Type) bool { - if isString(u) { - u = NewSlice(universeByte) - } - if su != nil && !Identical(su, u) { - return false - } - // su == nil || Identical(su, u) - su = u - return true - }) { - return su - } - return nil -} - // hasVarSize reports if the size of type t is variable due to type parameters. func hasVarSize(t Type) bool { switch t := under(t).(type) { diff --git a/src/cmd/compile/internal/types2/compilersupport.go b/src/cmd/compile/internal/types2/compilersupport.go new file mode 100644 index 0000000000..1e79bbf9be --- /dev/null +++ b/src/cmd/compile/internal/types2/compilersupport.go @@ -0,0 +1,34 @@ +// 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. + +// Helper functions exported for the compiler. +// Do not use internally. + +package types2 + +// If t is a pointer, AsPointer returns that type, otherwise it returns nil. +func AsPointer(t Type) *Pointer { + u, _ := t.Underlying().(*Pointer) + return u +} + +// If t is a signature, AsSignature returns that type, otherwise it returns nil. +func AsSignature(t Type) *Signature { + u, _ := t.Underlying().(*Signature) + return u +} + +// If t is a type parameter, AsTypeParam returns that type, otherwise it returns nil. +func AsTypeParam(t Type) *TypeParam { + u, _ := t.Underlying().(*TypeParam) + return u +} + +// If t is a type parameter, StructuralType returns the single underlying +// type of all types in the type parameter's type constraint if it exists, +// or nil otherwise. If t is not a type parameter, StructuralType returns +// the underlying type of t. +func StructuralType(t Type) Type { + return structuralType(t) +} diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go index d1655c55f8..64f25c6dac 100644 --- a/src/cmd/compile/internal/types2/type.go +++ b/src/cmd/compile/internal/types2/type.go @@ -27,10 +27,47 @@ func under(t Type) Type { return t } -// If the argument to asNamed, or asTypeParam is of the respective type -// (possibly after resolving a *Named type), these methods return that type. -// Otherwise the result is nil. +// If typ is a type parameter, structuralType returns the single underlying +// type of all types in the corresponding type constraint if it exists, or +// nil otherwise. If typ is not a type parameter, structuralType returns +// the underlying type. +func structuralType(typ Type) Type { + var su Type + if underIs(typ, func(u Type) bool { + if su != nil && !Identical(su, u) { + return false + } + // su == nil || Identical(su, u) + su = u + return true + }) { + return su + } + return nil +} +// structuralString is like structuralType but also considers []byte +// and string as "identical". In this case, if successful, the result +// is always []byte. +func structuralString(typ Type) Type { + var su Type + if underIs(typ, func(u Type) bool { + if isString(u) { + u = NewSlice(universeByte) + } + if su != nil && !Identical(su, u) { + return false + } + // su == nil || Identical(su, u) + su = u + return true + }) { + return su + } + return nil +} + +// If t is a defined type, asNamed returns that type (possibly after resolving it), otherwise it returns nil. func asNamed(t Type) *Named { e, _ := t.(*Named) if e != nil { @@ -39,37 +76,8 @@ func asNamed(t Type) *Named { return e } +// If t is a type parameter, asTypeParam returns that type, otherwise it returns nil. func asTypeParam(t Type) *TypeParam { u, _ := under(t).(*TypeParam) return u } - -// Helper functions exported for the compiler. -// These functions assume type checking has completed -// and Type.Underlying() is returning the fully set up -// underlying type. Do not use internally. - -func AsPointer(t Type) *Pointer { - u, _ := t.Underlying().(*Pointer) - return u -} - -func AsNamed(t Type) *Named { - u, _ := t.(*Named) - return u -} - -func AsSignature(t Type) *Signature { - u, _ := t.Underlying().(*Signature) - return u -} - -func AsInterface(t Type) *Interface { - u, _ := t.Underlying().(*Interface) - return u -} - -func AsTypeParam(t Type) *TypeParam { - u, _ := t.Underlying().(*TypeParam) - return u -} From 23dd389ac6ef59210580614c4a73e0d0a13c2911 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 10 Nov 2021 09:33:53 -0800 Subject: [PATCH 082/752] cmd/compile/internal/types2: refer to structural rather than single underlying type in errors This brings the error messages in sync with the terminology that will be used it the spec. Change-Id: Ia05993776c649be9eb2cdf948a583b9a49f9b192 Reviewed-on: https://go-review.googlesource.com/c/go/+/362997 Reviewed-by: Robert Findley Trust: Robert Griesemer --- src/cmd/compile/internal/types2/builtins.go | 2 +- src/cmd/compile/internal/types2/index.go | 2 +- src/cmd/compile/internal/types2/stmt.go | 4 ++-- .../internal/types2/testdata/check/builtins.go2 | 6 +++--- .../internal/types2/testdata/check/typeparams.go2 | 12 ++++++------ 5 files changed, 13 insertions(+), 13 deletions(-) diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go index 5c3f0aac8a..fa0fc1e5e6 100644 --- a/src/cmd/compile/internal/types2/builtins.go +++ b/src/cmd/compile/internal/types2/builtins.go @@ -470,7 +470,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( case *Map, *Chan: min = 1 case nil: - check.errorf(arg0, invalidArg+"cannot make %s; type set has no single underlying type", arg0) + check.errorf(arg0, invalidArg+"cannot make %s: no structural type", arg0) return default: check.errorf(arg0, invalidArg+"cannot make %s; type must be slice, map, or channel", arg0) diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go index 10e85ef6e1..10fb57c321 100644 --- a/src/cmd/compile/internal/types2/index.go +++ b/src/cmd/compile/internal/types2/index.go @@ -212,7 +212,7 @@ func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) { length := int64(-1) // valid if >= 0 switch u := structuralType(x.typ).(type) { case nil: - check.errorf(x, invalidOp+"cannot slice %s: type set has no single underlying type", x) + check.errorf(x, invalidOp+"cannot slice %s: %s has no structural type", x, x.typ) x.mode = invalid return diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go index 39b24398d7..2d41489152 100644 --- a/src/cmd/compile/internal/types2/stmt.go +++ b/src/cmd/compile/internal/types2/stmt.go @@ -834,12 +834,12 @@ func (check *Checker) rangeStmt(inner stmtContext, s *syntax.ForStmt, rclause *s // determine key/value types var key, val Type if x.mode != invalid { - // Ranging over a type parameter is permitted if it has a single underlying type. + // Ranging over a type parameter is permitted if it has a structural type. var cause string u := structuralType(x.typ) switch t := u.(type) { case nil: - cause = "type set has no single underlying type" + cause = check.sprintf("%s has no structural type", x.typ) case *Chan: if sValue != nil { check.softErrorf(sValue, "range over %s permits only one iteration variable", &x) diff --git a/src/cmd/compile/internal/types2/testdata/check/builtins.go2 b/src/cmd/compile/internal/types2/testdata/check/builtins.go2 index d1067a190f..48a39891bf 100644 --- a/src/cmd/compile/internal/types2/testdata/check/builtins.go2 +++ b/src/cmd/compile/internal/types2/testdata/check/builtins.go2 @@ -148,7 +148,7 @@ func _[ _ = make /* ERROR expects 2 or 3 arguments */ (S1) _ = make(S1, 10, 20) _ = make /* ERROR expects 2 or 3 arguments */ (S1, 10, 20, 30) - _ = make(S2 /* ERROR cannot make .* no single underlying type */ , 10) + _ = make(S2 /* ERROR cannot make S2: no structural type */ , 10) type M0 map[string]int _ = make(map[string]int) @@ -156,7 +156,7 @@ func _[ _ = make(M1) _ = make(M1, 10) _ = make/* ERROR expects 1 or 2 arguments */(M1, 10, 20) - _ = make(M2 /* ERROR cannot make .* no single underlying type */ ) + _ = make(M2 /* ERROR cannot make M2: no structural type */ ) type C0 chan int _ = make(chan int) @@ -164,7 +164,7 @@ func _[ _ = make(C1) _ = make(C1, 10) _ = make/* ERROR expects 1 or 2 arguments */(C1, 10, 20) - _ = make(C2 /* ERROR cannot make .* no single underlying type */ ) + _ = make(C2 /* ERROR cannot make C2: no structural type */ ) _ = make(C3) } diff --git a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 index a1bf6c262f..9e7960a474 100644 --- a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 +++ b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 @@ -134,7 +134,7 @@ func _[T interface{ ~string }] (x T, i, j, k int) { var _ T = x /* ERROR 3-index type myByte1 []byte type myByte2 []byte func _[T interface{ []byte | myByte1 | myByte2 }] (x T, i, j, k int) { var _ T = x[i:j:k] } -func _[T interface{ []byte | myByte1 | []int }] (x T, i, j, k int) { var _ T = x[ /* ERROR no single underlying type */ i:j:k] } +func _[T interface{ []byte | myByte1 | []int }] (x T, i, j, k int) { var _ T = x[ /* ERROR no structural type */ i:j:k] } // len/cap built-ins @@ -210,7 +210,7 @@ func _[ for _, _ /* ERROR permits only one iteration variable */ = range c1 {} var c2 C2 - for range c2 /* ERROR cannot range over c2.*no single underlying type */ {} + for range c2 /* ERROR cannot range over c2.*no structural type */ {} var c3 C3 for range c3 /* ERROR receive from send-only channel */ {} @@ -226,7 +226,7 @@ func _[ for _, _ = range s1 {} var s2 S2 - for range s2 /* ERROR cannot range over s2.*no single underlying type */ {} + for range s2 /* ERROR cannot range over s2.*no structural type */ {} var a0 []int for range a0 {} @@ -239,7 +239,7 @@ func _[ for _, _ = range a1 {} var a2 A2 - for range a2 /* ERROR cannot range over a2.*no single underlying type */ {} + for range a2 /* ERROR cannot range over a2.*no structural type */ {} var p0 *[10]int for range p0 {} @@ -252,7 +252,7 @@ func _[ for _, _ = range p1 {} var p2 P2 - for range p2 /* ERROR cannot range over p2.*no single underlying type */ {} + for range p2 /* ERROR cannot range over p2.*no structural type */ {} var m0 map[string]int for range m0 {} @@ -265,7 +265,7 @@ func _[ for _, _ = range m1 {} var m2 M2 - for range m2 /* ERROR cannot range over m2.*no single underlying type */ {} + for range m2 /* ERROR cannot range over m2.*no structural type */ {} } // type inference checks From b2d826c09f0f73cd9dc0022a2b052543e8bf4c06 Mon Sep 17 00:00:00 2001 From: emahiro Date: Thu, 21 Oct 2021 18:01:10 +0900 Subject: [PATCH 083/752] internal/cache: document 'go clean -fuzzcache' in README Fixes: #48900 Change-Id: I9235441886ed7cbdfdcbd283480f52d9216c3ea2 Reviewed-on: https://go-review.googlesource.com/c/go/+/357233 Reviewed-by: Bryan C. Mills Reviewed-by: Katie Hockman Run-TryBot: Bryan C. Mills TryBot-Result: Go Bot Trust: Katie Hockman --- src/cmd/go/internal/cache/default.go | 1 + 1 file changed, 1 insertion(+) diff --git a/src/cmd/go/internal/cache/default.go b/src/cmd/go/internal/cache/default.go index 0b1c1e0c20..426dddfb97 100644 --- a/src/cmd/go/internal/cache/default.go +++ b/src/cmd/go/internal/cache/default.go @@ -30,6 +30,7 @@ var ( // README as a courtesy to explain where it came from. const cacheREADME = `This directory holds cached build artifacts from the Go build system. Run "go clean -cache" if the directory is getting too large. +Run "go clean -fuzzcache" to delete the fuzz cache. See golang.org to learn more about Go. ` From a881409960a2a8117c99dcc0c91ab74885a3c53a Mon Sep 17 00:00:00 2001 From: Michael Anthony Knyszek Date: Wed, 10 Nov 2021 20:14:15 +0000 Subject: [PATCH 084/752] runtime: rewrite TestPhysicalMemoryUtilization This test changes TestPhysicalMemoryUtilization to be simpler, more robust, and more honest about what's going on. Fixes #49411. Change-Id: I913ef055c6e166c104c62595c1597d44db62018c Reviewed-on: https://go-review.googlesource.com/c/go/+/362978 Trust: Michael Knyszek Run-TryBot: Michael Knyszek Reviewed-by: David Chase --- src/runtime/testdata/testprog/gc.go | 121 ++++++++++++---------------- 1 file changed, 53 insertions(+), 68 deletions(-) diff --git a/src/runtime/testdata/testprog/gc.go b/src/runtime/testdata/testprog/gc.go index 74732cd9f4..6484c36139 100644 --- a/src/runtime/testdata/testprog/gc.go +++ b/src/runtime/testdata/testprog/gc.go @@ -132,81 +132,75 @@ func GCFairness2() { func GCPhys() { // This test ensures that heap-growth scavenging is working as intended. // - // It sets up a specific scenario: it allocates two pairs of objects whose - // sizes sum to size. One object in each pair is "small" (though must be - // large enough to be considered a large object by the runtime) and one is - // large. The small objects are kept while the large objects are freed, - // creating two large unscavenged holes in the heap. The heap goal should - // also be small as a result (so size must be at least as large as the - // minimum heap size). We then allocate one large object, bigger than both - // pairs of objects combined. This allocation, because it will tip - // HeapSys-HeapReleased well above the heap goal, should trigger heap-growth - // scavenging and scavenge most, if not all, of the large holes we created - // earlier. + // It attempts to construct a sizeable "swiss cheese" heap, with many + // allocChunk-sized holes. Then, it triggers a heap growth by trying to + // allocate as much memory as would fit in those holes. + // + // The heap growth should cause a large number of those holes to be + // returned to the OS. + const ( - // Size must be also large enough to be considered a large - // object (not in any size-segregated span). - size = 4 << 20 - split = 64 << 10 - objects = 2 + allocTotal = 32 << 20 + allocChunk = 64 << 10 + allocs = allocTotal / allocChunk // The page cache could hide 64 8-KiB pages from the scavenger today. maxPageCache = (8 << 10) * 64 - - // Reduce GOMAXPROCS down to 4 if it's greater. We need to bound the amount - // of memory held in the page cache because the scavenger can't reach it. - // The page cache will hold at most maxPageCache of memory per-P, so this - // bounds the amount of memory hidden from the scavenger to 4*maxPageCache - // at most. - maxProcs = 4 ) - // Set GOGC so that this test operates under consistent assumptions. + // Set GC percent just so this test is a little more consistent in the + // face of varying environments. debug.SetGCPercent(100) - procs := runtime.GOMAXPROCS(-1) - if procs > maxProcs { - defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(maxProcs)) - procs = runtime.GOMAXPROCS(-1) - } - // Save objects which we want to survive, and condemn objects which we don't. - // Note that we condemn objects in this way and release them all at once in - // order to avoid having the GC start freeing up these objects while the loop - // is still running and filling in the holes we intend to make. - saved := make([][]byte, 0, objects+1) - condemned := make([][]byte, 0, objects) - for i := 0; i < 2*objects; i++ { + + // Set GOMAXPROCS to 1 to minimize the amount of memory held in the page cache, + // and to reduce the chance that the background scavenger gets scheduled. + defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(1)) + + // Allocate allocTotal bytes of memory in allocChunk byte chunks. + // Alternate between whether the chunk will be held live or will be + // condemned to GC to create holes in the heap. + saved := make([][]byte, allocs/2+1) + condemned := make([][]byte, allocs/2) + for i := 0; i < allocs; i++ { + b := make([]byte, allocChunk) if i%2 == 0 { - saved = append(saved, make([]byte, split)) + saved = append(saved, b) } else { - condemned = append(condemned, make([]byte, size-split)) + condemned = append(condemned, b) } } + + // Run a GC cycle just so we're at a consistent state. + runtime.GC() + + // Drop the only reference to all the condemned memory. condemned = nil - // Clean up the heap. This will free up every other object created above - // (i.e. everything in condemned) creating holes in the heap. - // Also, if the condemned objects are still being swept, its possible that - // the scavenging that happens as a result of the next allocation won't see - // the holes at all. We call runtime.GC() twice here so that when we allocate - // our large object there's no race with sweeping. - runtime.GC() - runtime.GC() - // Perform one big allocation which should also scavenge any holes. - // - // The heap goal will rise after this object is allocated, so it's very - // important that we try to do all the scavenging in a single allocation - // that exceeds the heap goal. Otherwise the rising heap goal could foil our - // test. - saved = append(saved, make([]byte, objects*size)) - // Clean up the heap again just to put it in a known state. + + // Clear the condemned memory. runtime.GC() + + // At this point, the background scavenger is likely running + // and could pick up the work, so the next line of code doesn't + // end up doing anything. That's fine. What's important is that + // this test fails somewhat regularly if the runtime doesn't + // scavenge on heap growth, and doesn't fail at all otherwise. + + // Make a large allocation that in theory could fit, but won't + // because we turned the heap into swiss cheese. + saved = append(saved, make([]byte, allocTotal/2)) + // heapBacked is an estimate of the amount of physical memory used by // this test. HeapSys is an estimate of the size of the mapped virtual // address space (which may or may not be backed by physical pages) // whereas HeapReleased is an estimate of the amount of bytes returned // to the OS. Their difference then roughly corresponds to the amount // of virtual address space that is backed by physical pages. + // + // heapBacked also subtracts out maxPageCache bytes of memory because + // this is memory that may be hidden from the scavenger per-P. Since + // GOMAXPROCS=1 here, that's fine. var stats runtime.MemStats runtime.ReadMemStats(&stats) - heapBacked := stats.HeapSys - stats.HeapReleased + heapBacked := stats.HeapSys - stats.HeapReleased - maxPageCache // If heapBacked does not exceed the heap goal by more than retainExtraPercent // then the scavenger is working as expected; the newly-created holes have been // scavenged immediately as part of the allocations which cannot fit in the holes. @@ -216,19 +210,9 @@ func GCPhys() { // to other allocations that happen during this test we may still see some physical // memory over-use. overuse := (float64(heapBacked) - float64(stats.HeapAlloc)) / float64(stats.HeapAlloc) - // Compute the threshold. - // - // In theory, this threshold should just be zero, but that's not possible in practice. - // Firstly, the runtime's page cache can hide up to maxPageCache of free memory from the - // scavenger per P. To account for this, we increase the threshold by the ratio between the - // total amount the runtime could hide from the scavenger to the amount of memory we expect - // to be able to scavenge here, which is (size-split)*objects. This computation is the crux - // GOMAXPROCS above; if GOMAXPROCS is too high the threshold just becomes 100%+ since the - // amount of memory being allocated is fixed. Then we add 5% to account for noise, such as - // other allocations this test may have performed that we don't explicitly account for The - // baseline threshold here is around 11% for GOMAXPROCS=1, capping out at around 30% for - // GOMAXPROCS=4. - threshold := 0.05 + float64(procs)*maxPageCache/float64((size-split)*objects) + // Check against our overuse threshold, which is what the scavenger always reserves + // to encourage allocation of memory that doesn't need to be faulted in. + const threshold = 0.1 if overuse <= threshold { fmt.Println("OK") return @@ -243,6 +227,7 @@ func GCPhys() { "(alloc: %d, goal: %d, sys: %d, rel: %d, objs: %d)\n", threshold*100, overuse*100, stats.HeapAlloc, stats.NextGC, stats.HeapSys, stats.HeapReleased, len(saved)) runtime.KeepAlive(saved) + runtime.KeepAlive(condemned) } // Test that defer closure is correctly scanned when the stack is scanned. From f410786c5f12d0cc4f44ce9daf8d0883df39a2f6 Mon Sep 17 00:00:00 2001 From: Paschalis Tsilias Date: Wed, 28 Jul 2021 17:03:21 +0300 Subject: [PATCH 085/752] cmd/go: add 'go mod vendor -o' flag Adds a new flag to 'go mod vendor' which overrides the default 'vendor' destination directory. This can be helpful for writing the vendor tree to a temporary location for use by other tools. The argument can be a relative or an absolute path. This flag has no other influence on how the command behaves. Fixes #47327 Change-Id: I4502931127616b181dc90a2066d2fb57bfe48f96 Reviewed-on: https://go-review.googlesource.com/c/go/+/338149 Reviewed-by: Bryan C. Mills Reviewed-by: Jay Conrod Trust: Bryan C. Mills Trust: Jay Conrod Run-TryBot: Bryan C. Mills TryBot-Result: Go Bot --- src/cmd/go/alldocs.go | 7 +++- src/cmd/go/internal/modcmd/vendor.go | 21 ++++++++++-- src/cmd/go/testdata/script/mod_vendor.txt | 42 +++++++++++++++++++++++ 3 files changed, 66 insertions(+), 4 deletions(-) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index 81d2f7021d..ff144f9847 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -1295,7 +1295,7 @@ // // Usage: // -// go mod vendor [-e] [-v] +// go mod vendor [-e] [-v] [-o outdir] // // Vendor resets the main module's vendor directory to include all packages // needed to build and test all the main module's packages. @@ -1307,6 +1307,11 @@ // The -e flag causes vendor to attempt to proceed despite errors // encountered while loading packages. // +// The -o flag causes vendor to create the vendor directory at the given +// path instead of "vendor". The go command can only use a vendor directory +// named "vendor" within the module root directory, so this flag is +// primarily useful for other tools. +// // See https://golang.org/ref/mod#go-mod-vendor for more about 'go mod vendor'. // // diff --git a/src/cmd/go/internal/modcmd/vendor.go b/src/cmd/go/internal/modcmd/vendor.go index 484e095cc7..ef123700aa 100644 --- a/src/cmd/go/internal/modcmd/vendor.go +++ b/src/cmd/go/internal/modcmd/vendor.go @@ -31,7 +31,7 @@ import ( ) var cmdVendor = &base.Command{ - UsageLine: "go mod vendor [-e] [-v]", + UsageLine: "go mod vendor [-e] [-v] [-o outdir]", Short: "make vendored copy of dependencies", Long: ` Vendor resets the main module's vendor directory to include all packages @@ -44,16 +44,23 @@ modules and packages to standard error. The -e flag causes vendor to attempt to proceed despite errors encountered while loading packages. +The -o flag causes vendor to create the vendor directory at the given +path instead of "vendor". The go command can only use a vendor directory +named "vendor" within the module root directory, so this flag is +primarily useful for other tools. + See https://golang.org/ref/mod#go-mod-vendor for more about 'go mod vendor'. `, Run: runVendor, } -var vendorE bool // if true, report errors but proceed anyway +var vendorE bool // if true, report errors but proceed anyway +var vendorO string // if set, overrides the default output directory func init() { cmdVendor.Flag.BoolVar(&cfg.BuildV, "v", false, "") cmdVendor.Flag.BoolVar(&vendorE, "e", false, "") + cmdVendor.Flag.StringVar(&vendorO, "o", "", "") base.AddModCommonFlags(&cmdVendor.Flag) } @@ -74,7 +81,15 @@ func runVendor(ctx context.Context, cmd *base.Command, args []string) { } _, pkgs := modload.LoadPackages(ctx, loadOpts, "all") - vdir := filepath.Join(modload.VendorDir()) + var vdir string + switch { + case filepath.IsAbs(vendorO): + vdir = vendorO + case vendorO != "": + vdir = filepath.Join(base.Cwd(), vendorO) + default: + vdir = filepath.Join(modload.VendorDir()) + } if err := os.RemoveAll(vdir); err != nil { base.Fatalf("go: %v", err) } diff --git a/src/cmd/go/testdata/script/mod_vendor.txt b/src/cmd/go/testdata/script/mod_vendor.txt index 4eb80c2332..a2727ddf7f 100644 --- a/src/cmd/go/testdata/script/mod_vendor.txt +++ b/src/cmd/go/testdata/script/mod_vendor.txt @@ -82,6 +82,48 @@ exists vendor/mysite/myname/mypkg/LICENSE.txt ! exists vendor/x/x2 ! exists vendor/x/x2/LICENSE +# 'go mod vendor' should work with an alternative vendor directory if the -o flag is provided. +go mod vendor -v -o alternative-vendor-dir +exists alternative-vendor-dir/modules.txt +exists alternative-vendor-dir/a/foo/LICENSE + +# 'go mod vendor' should interpret paths relative to the current working directory when the -o flag is provided. +mkdir dir1 +mkdir dir2 + +cd dir1 +go mod vendor -v -o relative-vendor-dir + +go mod vendor -v -o ../dir2/relative-vendor-dir + +cd .. +exists dir1/relative-vendor-dir/modules.txt +exists dir1/relative-vendor-dir/a/foo/LICENSE +exists dir2/relative-vendor-dir/modules.txt +exists dir2/relative-vendor-dir/a/foo/LICENSE + +# 'go mod vendor' should fall back to the default 'vendor' directory when an empty argument is passed to the -o flag +# the same behavior should be exhibited both on the module root directory, as well as nested subdirectories + +go mod vendor -v -o '' +exists vendor/modules.txt + +env GOFLAGS=-o=foo +go mod vendor -v -o '' +exists vendor/modules.txt +env GOFLAGS='' + +mkdir -p nested/dir +cd nested/dir +go mod vendor -v -o '' +! exists vendor/ +exists ../../vendor/modules.txt +cd ../.. + +# 'go mod vendor' should work with absolute paths as well +go mod vendor -v -o $WORK/tmp/absolute-vendor-dir +exists $WORK/tmp/absolute-vendor-dir/modules.txt + [short] stop # 'go build' and 'go test' using vendored packages should succeed. From 229b90931312aa1686f4bace25d1f40f896884ad Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Wed, 10 Nov 2021 11:39:18 -0800 Subject: [PATCH 086/752] cmd/compile: don't do Resolve on OKEY identifiers during import For generic functions, we can export untransformed OKEY nodes, and the key identifier is written as an ONONAME. But in this case, we do not want to call Resolve() on the identifier, since we may resolve to a global type (as happens in this issue) or other global symbol with the same name, if it exists. We just want to keep the key identifier as an Ident node. To solve this, I added an extra bool when exporting an ONONAME entry, which indicates if this entry is for a key or for a global (external) symbol. When the bool is true (this is for a key), we avoid calling Resolve(). Fixes #49497 Change-Id: Ic8fa93d37bcad2110e0e0d060080b733e07e35d7 Reviewed-on: https://go-review.googlesource.com/c/go/+/363074 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Go Bot Reviewed-by: Keith Randall --- src/cmd/compile/internal/typecheck/iexport.go | 6 ++++- src/cmd/compile/internal/typecheck/iimport.go | 8 +++++- test/typeparam/issue49497.dir/a.go | 26 +++++++++++++++++++ test/typeparam/issue49497.dir/main.go | 11 ++++++++ test/typeparam/issue49497.go | 7 +++++ 5 files changed, 56 insertions(+), 2 deletions(-) create mode 100644 test/typeparam/issue49497.dir/a.go create mode 100644 test/typeparam/issue49497.dir/main.go create mode 100644 test/typeparam/issue49497.go diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go index f685851e40..bf12ba803b 100644 --- a/src/cmd/compile/internal/typecheck/iexport.go +++ b/src/cmd/compile/internal/typecheck/iexport.go @@ -1735,6 +1735,8 @@ func (w *exportWriter) expr(n ir.Node) { n := n.(*ir.Name) if (n.Class == ir.PEXTERN || n.Class == ir.PFUNC) && !ir.IsBlank(n) { w.op(ir.ONONAME) + // Indicate that this is not an OKEY entry. + w.bool(false) w.qualifiedIdent(n) if go117ExportTypes { w.typ(n.Type()) @@ -1761,7 +1763,9 @@ func (w *exportWriter) expr(n ir.Node) { case ir.ONONAME: w.op(ir.ONONAME) - // This should only be for OKEY nodes in generic functions + // This can only be for OKEY nodes in generic functions. Mark it + // as a key entry. + w.bool(true) s := n.Sym() w.string(s.Name) w.pkg(s.Pkg) diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go index 26bc838ed9..09f87df580 100644 --- a/src/cmd/compile/internal/typecheck/iimport.go +++ b/src/cmd/compile/internal/typecheck/iimport.go @@ -1315,9 +1315,15 @@ func (r *importReader) node() ir.Node { return n case ir.ONONAME: + isKey := r.bool() n := r.qualifiedIdent() if go117ExportTypes { - n2 := Resolve(n) + var n2 ir.Node = n + // Key ONONAME entries should not be resolved - they should + // stay as identifiers. + if !isKey { + n2 = Resolve(n) + } typ := r.typ() if n2.Type() == nil { n2.SetType(typ) diff --git a/test/typeparam/issue49497.dir/a.go b/test/typeparam/issue49497.dir/a.go new file mode 100644 index 0000000000..86062d446f --- /dev/null +++ b/test/typeparam/issue49497.dir/a.go @@ -0,0 +1,26 @@ +// 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[T any]() A[T] { + var x A[T] + return x +} + +type A[T any] struct { + b B[T] +} + +func (a A[T]) M() C[T] { + return C[T]{ + B: a.b, + } +} + +type B[T any] struct{} + +type C[T any] struct { + B B[T] +} diff --git a/test/typeparam/issue49497.dir/main.go b/test/typeparam/issue49497.dir/main.go new file mode 100644 index 0000000000..3725e5591e --- /dev/null +++ b/test/typeparam/issue49497.dir/main.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. + +package main + +import "a" + +func main() { + a.F[string]() +} diff --git a/test/typeparam/issue49497.go b/test/typeparam/issue49497.go new file mode 100644 index 0000000000..76930e5e4f --- /dev/null +++ b/test/typeparam/issue49497.go @@ -0,0 +1,7 @@ +// rundir -G=3 + +// 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 From 96c94c2c831a5c074d33e2b7b553e91eb602e6bd Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 10 Nov 2021 12:11:03 -0800 Subject: [PATCH 087/752] cmd/compile/internal/types2: slightly relax notion of structural type If we have all channel types in a constraint, there is no structural type if they don't all have the same channel direction (and identical element types, of course). By allowing different channel types for the purposes of the structural type, as long as there is not a send-only _and_ a receive- only channel in the type set, we make it possible to find a useful, if restricted by channel direction, structural type where before there was none. So if we have unrestricted and send-only channels, the structural type is the send-only channel, and vice versa. For all operations on channels that rely on a structural type, it's always ok to have an unrestricted channel, so this is not affecting their behavior. But it makes those operations more flexible in the presence of type parameters containing mixed channel types. For constraint type inference, where we currently may not infer a channel at all, this change allows us to infer a more restricted channel (send- or receive-only). If the inferred channel type is a valid type argument we win; if not we haven't lost anything. Use structuralType for send and receive operations and adjust related error messages (the error message that change are the ones involving type parameters, so historic error messages are preserved). Fixes #45920. Change-Id: If3a64d29c37e7734d3163df330f8b02dd032bc60 Reviewed-on: https://go-review.googlesource.com/c/go/+/363075 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley --- .../internal/types2/compilersupport.go | 10 ++-- src/cmd/compile/internal/types2/expr.go | 34 ++++++------ src/cmd/compile/internal/types2/stmt.go | 32 +++++------ .../types2/testdata/check/typeparams.go2 | 2 +- .../types2/testdata/fixedbugs/issue43671.go2 | 6 +-- .../types2/testdata/fixedbugs/issue45920.go2 | 17 ++++++ .../types2/testdata/fixedbugs/issue47115.go2 | 4 +- src/cmd/compile/internal/types2/type.go | 53 ++++++++++++++++--- 8 files changed, 102 insertions(+), 56 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2 diff --git a/src/cmd/compile/internal/types2/compilersupport.go b/src/cmd/compile/internal/types2/compilersupport.go index 1e79bbf9be..31112d4e41 100644 --- a/src/cmd/compile/internal/types2/compilersupport.go +++ b/src/cmd/compile/internal/types2/compilersupport.go @@ -25,10 +25,12 @@ func AsTypeParam(t Type) *TypeParam { return u } -// If t is a type parameter, StructuralType returns the single underlying -// type of all types in the type parameter's type constraint if it exists, -// or nil otherwise. If t is not a type parameter, StructuralType returns -// the underlying type of t. +// If typ is a type parameter, structuralType returns the single underlying +// type of all types in the corresponding type constraint if it exists, or +// nil otherwise. If the type set contains only unrestricted and restricted +// channel types (with identical element types), the single underlying type +// is the restricted channel type if the restrictions are always the same. +// If typ is not a type parameter, structuralType returns the underlying type. func StructuralType(t Type) Type { return structuralType(t) } diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index 169417016f..0b3fe23e80 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -187,29 +187,25 @@ func (check *Checker) unary(x *operand, e *syntax.Operation) { return case syntax.Recv: - var elem Type - if !underIs(x.typ, func(u Type) bool { - ch, _ := u.(*Chan) - if ch == nil { - check.errorf(x, invalidOp+"cannot receive from non-channel %s", x) - return false - } - if ch.dir == SendOnly { - check.errorf(x, invalidOp+"cannot receive from send-only channel %s", x) - return false - } - if elem != nil && !Identical(ch.elem, elem) { - check.errorf(x, invalidOp+"channels of %s must have the same element type", x) - return false - } - elem = ch.elem - return true - }) { + u := structuralType(x.typ) + if u == nil { + check.errorf(x, invalidOp+"cannot receive from %s: no structural type", x) + x.mode = invalid + return + } + ch, _ := u.(*Chan) + if ch == nil { + check.errorf(x, invalidOp+"cannot receive from non-channel %s", x) + x.mode = invalid + return + } + if ch.dir == SendOnly { + check.errorf(x, invalidOp+"cannot receive from send-only channel %s", x) x.mode = invalid return } x.mode = commaok - x.typ = elem + x.typ = ch.elem check.hasCallOrRecv = true return } diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go index 2d41489152..f9c07e38cd 100644 --- a/src/cmd/compile/internal/types2/stmt.go +++ b/src/cmd/compile/internal/types2/stmt.go @@ -408,27 +408,21 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) { if ch.mode == invalid || val.mode == invalid { return } - var elem Type - if !underIs(ch.typ, func(u Type) bool { - uch, _ := u.(*Chan) - if uch == nil { - check.errorf(s, invalidOp+"cannot send to non-channel %s", &ch) - return false - } - if uch.dir == RecvOnly { - check.errorf(s, invalidOp+"cannot send to receive-only channel %s", &ch) - return false - } - if elem != nil && !Identical(uch.elem, elem) { - check.errorf(s, invalidOp+"channels of %s must have the same element type", &ch) - return false - } - elem = uch.elem - return true - }) { + u := structuralType(ch.typ) + if u == nil { + check.errorf(s, invalidOp+"cannot send to %s: no structural type", &ch) return } - check.assignment(&val, elem, "send") + uch, _ := u.(*Chan) + if uch == nil { + check.errorf(s, invalidOp+"cannot send to non-channel %s", &ch) + return + } + if uch.dir == RecvOnly { + check.errorf(s, invalidOp+"cannot send to receive-only channel %s", &ch) + return + } + check.assignment(&val, uch.elem, "send") case *syntax.AssignStmt: lhs := unpackExpr(s.Lhs) diff --git a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 index 9e7960a474..b1d02efdb5 100644 --- a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 +++ b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 @@ -210,7 +210,7 @@ func _[ for _, _ /* ERROR permits only one iteration variable */ = range c1 {} var c2 C2 - for range c2 /* ERROR cannot range over c2.*no structural type */ {} + for range c2 {} var c3 C3 for range c3 /* ERROR receive from send-only channel */ {} diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43671.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43671.go2 index 6cc3801cc9..46ac51ebdd 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43671.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43671.go2 @@ -12,11 +12,11 @@ type C4 interface{ chan int | chan<- int } type C5[T any] interface{ ~chan T | <-chan T } func _[T any](ch T) { - <-ch // ERROR cannot receive from non-channel + <-ch // ERROR cannot receive from ch .* no structural type } func _[T C0](ch T) { - <-ch // ERROR cannot receive from non-channel + <-ch // ERROR cannot receive from non-channel ch } func _[T C1](ch T) { @@ -28,7 +28,7 @@ func _[T C2](ch T) { } func _[T C3](ch T) { - <-ch // ERROR channels of ch .* must have the same element type + <-ch // ERROR cannot receive from ch .* no structural type } func _[T C4](ch T) { diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2 new file mode 100644 index 0000000000..ef9ca9fede --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2 @@ -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 p + +func f1[T any, C chan T | <-chan T](ch C) {} + +func _(ch chan int) { f1(ch) } +func _(ch <-chan int) { f1(ch) } +func _(ch chan<- int) { f1( /* ERROR chan<- int does not satisfy chan T\|<-chan T */ ch) } + +func f2[T any, C chan T | chan<- T](ch C) {} + +func _(ch chan int) { f2(ch) } +func _(ch <-chan int) { f2( /* ERROR <-chan int does not satisfy chan T\|chan<- T */ ch) } +func _(ch chan<- int) { f2(ch) } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47115.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47115.go2 index 00828eb997..83a8f3a5da 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47115.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47115.go2 @@ -12,7 +12,7 @@ type C4 interface{ chan int | chan<- int } type C5[T any] interface{ ~chan T | chan<- T } func _[T any](ch T) { - ch /* ERROR cannot send to non-channel */ <- 0 + ch /* ERROR cannot send to ch .* no structural type */ <- 0 } func _[T C0](ch T) { @@ -28,7 +28,7 @@ func _[T C2](ch T) { } func _[T C3](ch T) { - ch /* ERROR channels of ch .* must have the same element type */ <- 0 + ch /* ERROR cannot send to ch .* no structural type */ <- 0 } func _[T C4](ch T) { diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go index 64f25c6dac..316e834a77 100644 --- a/src/cmd/compile/internal/types2/type.go +++ b/src/cmd/compile/internal/types2/type.go @@ -27,17 +27,51 @@ func under(t Type) Type { return t } +// If x and y are identical, match returns x. +// If x and y are identical channels but for their direction +// and one of them is unrestricted, match returns the channel +// with the restricted direction. +// In all other cases, match returns nil. +func match(x, y Type) Type { + // Common case: we don't have channels. + if Identical(x, y) { + return x + } + + // We may have channels that differ in direction only. + if x, _ := x.(*Chan); x != nil { + if y, _ := y.(*Chan); y != nil && Identical(x.elem, y.elem) { + // We have channels that differ in direction only. + // If there's an unrestricted channel, select the restricted one. + switch { + case x.dir == SendRecv: + return y + case y.dir == SendRecv: + return x + } + } + } + + // types are different + return nil +} + // If typ is a type parameter, structuralType returns the single underlying // type of all types in the corresponding type constraint if it exists, or -// nil otherwise. If typ is not a type parameter, structuralType returns -// the underlying type. +// nil otherwise. If the type set contains only unrestricted and restricted +// channel types (with identical element types), the single underlying type +// is the restricted channel type if the restrictions are always the same. +// If typ is not a type parameter, structuralType returns the underlying type. func structuralType(typ Type) Type { var su Type if underIs(typ, func(u Type) bool { - if su != nil && !Identical(su, u) { - return false + if su != nil { + u = match(su, u) + if u == nil { + return false + } } - // su == nil || Identical(su, u) + // su == nil || match(su, u) != nil su = u return true }) { @@ -55,10 +89,13 @@ func structuralString(typ Type) Type { if isString(u) { u = NewSlice(universeByte) } - if su != nil && !Identical(su, u) { - return false + if su != nil { + u = match(su, u) + if u == nil { + return false + } } - // su == nil || Identical(su, u) + // su == nil || match(su, u) != nil su = u return true }) { From 23f653df963ddf3ae618290edbb0c55530fcf483 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 10 Nov 2021 13:36:23 -0800 Subject: [PATCH 088/752] cmd/compile/internal/types2: remove structuralString in favor of inlined code structuralString was used only in one place (for built-in copy). Remove it in favor of custom and more efficient inlined code. Follow-up on feedback received for CL 363075. Change-Id: Ic5857c47255c5c712be7971aae4542fef9960fe6 Reviewed-on: https://go-review.googlesource.com/c/go/+/363154 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Go Bot --- src/cmd/compile/internal/types2/builtins.go | 21 +++++++++++++++++- src/cmd/compile/internal/types2/type.go | 24 --------------------- 2 files changed, 20 insertions(+), 25 deletions(-) diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go index fa0fc1e5e6..2bc084038f 100644 --- a/src/cmd/compile/internal/types2/builtins.go +++ b/src/cmd/compile/internal/types2/builtins.go @@ -334,7 +334,26 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( if y.mode == invalid { return } - src, _ := structuralString(y.typ).(*Slice) + // src, _ := structuralType(y.typ).(*Slice); but also accepts strings + var src *Slice + var elem Type // == src.elem if valid + if underIs(y.typ, func(u Type) bool { + switch u := u.(type) { + case *Basic: + if isString(u) && (elem == nil || Identical(elem, universeByte)) { + elem = universeByte + return true + } + case *Slice: + if elem == nil || Identical(elem, u.elem) { + elem = u.elem + return true + } + } + return false + }) { + src = NewSlice(elem) + } if dst == nil || src == nil { check.errorf(x, invalidArg+"copy expects slice arguments; found %s and %s", x, &y) diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go index 316e834a77..c8c0f36e5c 100644 --- a/src/cmd/compile/internal/types2/type.go +++ b/src/cmd/compile/internal/types2/type.go @@ -80,30 +80,6 @@ func structuralType(typ Type) Type { return nil } -// structuralString is like structuralType but also considers []byte -// and string as "identical". In this case, if successful, the result -// is always []byte. -func structuralString(typ Type) Type { - var su Type - if underIs(typ, func(u Type) bool { - if isString(u) { - u = NewSlice(universeByte) - } - if su != nil { - u = match(su, u) - if u == nil { - return false - } - } - // su == nil || match(su, u) != nil - su = u - return true - }) { - return su - } - return nil -} - // If t is a defined type, asNamed returns that type (possibly after resolving it), otherwise it returns nil. func asNamed(t Type) *Named { e, _ := t.(*Named) From 4d0683965bd05aee6845bf6849c85c4bf2bb10d4 Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Fri, 5 Nov 2021 13:02:09 +0100 Subject: [PATCH 089/752] net: do more faithful conversion from AddrPort to UDPAddr A UDPAddr with a nil IP is a valid state, representing an AF-agnostic unspecified address, so checking for addr.IsValid() isn't correct; remove that, as it's only needed in the UDP rx path where it can be added. Secondly, forcing everything to be IPv6 also is not correct, and was likely done when the missing .AsSlice() made doing the right thing less ergonomic. Fix this by using .AsSlice(), which properly preserves IP version. Change-Id: Idd1eaecd4076f32a843f859a0a9802ef98f956d3 Reviewed-on: https://go-review.googlesource.com/c/go/+/361478 Trust: Jason A. Donenfeld Trust: Josh Bleecher Snyder Run-TryBot: Jason A. Donenfeld TryBot-Result: Go Bot Reviewed-by: Russ Cox --- src/net/udpsock.go | 16 +++++++--------- src/net/udpsock_test.go | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 39 insertions(+), 9 deletions(-) diff --git a/src/net/udpsock.go b/src/net/udpsock.go index 622b1f83fb..6d29a39edf 100644 --- a/src/net/udpsock.go +++ b/src/net/udpsock.go @@ -99,16 +99,12 @@ func ResolveUDPAddr(network, address string) (*UDPAddr, error) { return addrs.forResolve(network, address).(*UDPAddr), nil } -// UDPAddrFromAddrPort returns addr as a UDPAddr. -// -// If addr is not valid, it returns nil. +// UDPAddrFromAddrPort returns addr as a UDPAddr. If addr.IsValid() is false, +// then the returned UDPAddr will contain a nil IP field, indicating an +// address family-agnostic unspecified address. func UDPAddrFromAddrPort(addr netip.AddrPort) *UDPAddr { - if !addr.IsValid() { - return nil - } - ip16 := addr.Addr().As16() return &UDPAddr{ - IP: IP(ip16[:]), + IP: addr.Addr().AsSlice(), Zone: addr.Addr().Zone(), Port: int(addr.Port()), } @@ -189,7 +185,9 @@ func (c *UDPConn) ReadFromUDPAddrPort(b []byte) (n int, addr netip.AddrPort, err func (c *UDPConn) ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr *UDPAddr, err error) { var ap netip.AddrPort n, oobn, flags, ap, err = c.ReadMsgUDPAddrPort(b, oob) - addr = UDPAddrFromAddrPort(ap) + if ap.IsValid() { + addr = UDPAddrFromAddrPort(ap) + } return } diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go index 9fe74f47a2..01b8d39216 100644 --- a/src/net/udpsock_test.go +++ b/src/net/udpsock_test.go @@ -603,3 +603,35 @@ func BenchmarkWriteToReadFromUDPAddrPort(b *testing.B) { } } } + +func TestUDPIPVersionReadMsg(t *testing.T) { + conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)}) + if err != nil { + t.Fatal(err) + } + defer conn.Close() + daddr := conn.LocalAddr().(*UDPAddr).AddrPort() + buf := make([]byte, 8) + _, err = conn.WriteToUDPAddrPort(buf, daddr) + if err != nil { + t.Fatal(err) + } + _, _, _, saddr, err := conn.ReadMsgUDPAddrPort(buf, nil) + if err != nil { + t.Fatal(err) + } + if !saddr.Addr().Is4() { + t.Error("returned AddrPort is not IPv4") + } + _, err = conn.WriteToUDPAddrPort(buf, daddr) + if err != nil { + t.Fatal(err) + } + _, _, _, soldaddr, err := conn.ReadMsgUDP(buf, nil) + if err != nil { + t.Fatal(err) + } + if len(soldaddr.IP) != 4 { + t.Error("returned UDPAddr is not IPv4") + } +} From 3949faf72e8285622ebfdf3bd573125dcd5453d2 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 10 Nov 2021 16:06:18 -0800 Subject: [PATCH 090/752] test: add test that was miscompiled by gccgo For #49512 Change-Id: Ic08652a4ec611b27150bf10b1118c1395715e5d0 Reviewed-on: https://go-review.googlesource.com/c/go/+/363156 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Go Bot Reviewed-by: Cherry Mui Reviewed-by: Than McIntosh --- test/fixedbugs/issue49512.go | 54 ++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 test/fixedbugs/issue49512.go diff --git a/test/fixedbugs/issue49512.go b/test/fixedbugs/issue49512.go new file mode 100644 index 0000000000..597aec8486 --- /dev/null +++ b/test/fixedbugs/issue49512.go @@ -0,0 +1,54 @@ +// 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 + +type S struct{ + m1Called, m2Called bool +} + +func (s *S) M1(int) (int, int) { + s.m1Called = true + return 0, 0 +} + +func (s *S) M2(int) (int, int) { + s.m2Called = true + return 0, 0 +} + +type C struct { + calls []func(int) (int, int) +} + +func makeC() Funcs { + return &C{} +} + +func (c *C) Add(fn func(int) (int, int)) Funcs { + c.calls = append(c.calls, fn) + return c +} + +func (c *C) Call() { + for _, fn := range c.calls { + fn(0) + } +} + +type Funcs interface { + Add(func(int) (int, int)) Funcs + Call() +} + +func main() { + s := &S{} + c := makeC().Add(s.M1).Add(s.M2) + c.Call() + if !s.m1Called || !s.m2Called { + panic("missed method call") + } +} From d5a5a13ad987db9bcdda8c6cecb84ed8583ea68d Mon Sep 17 00:00:00 2001 From: Changkun Ou Date: Mon, 26 Jul 2021 10:56:30 +0200 Subject: [PATCH 091/752] sync: clarify the validity to call Map methods inside Range This change clarifies that calling all Map methods inside the callback of Range is allowed. For further assurance, a nested range call test is also added. Fixes #46399 Change-Id: I0a766a5c1470e6b573ec35df1ccd62b2e46f1561 Reviewed-on: https://go-review.googlesource.com/c/go/+/337389 Reviewed-by: Bryan C. Mills Run-TryBot: Bryan C. Mills TryBot-Result: Go Bot Trust: Ian Lance Taylor --- src/sync/map.go | 5 +++-- src/sync/map_test.go | 50 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 53 insertions(+), 2 deletions(-) diff --git a/src/sync/map.go b/src/sync/map.go index dfb62dd3e8..7a6c82e5c3 100644 --- a/src/sync/map.go +++ b/src/sync/map.go @@ -311,8 +311,9 @@ func (e *entry) delete() (value interface{}, ok bool) { // // Range does not necessarily correspond to any consistent snapshot of the Map's // contents: no key will be visited more than once, but if the value for any key -// is stored or deleted concurrently, Range may reflect any mapping for that key -// from any point during the Range call. +// is stored or deleted concurrently (including by f), Range may reflect any +// mapping for that key from any point during the Range call. Range does not +// block other methods on the receiver; even f itself may call any method on m. // // Range may be O(N) with the number of elements in the map even if f returns // false after a constant number of calls. diff --git a/src/sync/map_test.go b/src/sync/map_test.go index 7f163caa5c..c4a8f8b99a 100644 --- a/src/sync/map_test.go +++ b/src/sync/map_test.go @@ -195,3 +195,53 @@ func TestIssue40999(t *testing.T) { runtime.GC() } } + +func TestMapRangeNestedCall(t *testing.T) { // Issue 46399 + var m sync.Map + for i, v := range [3]string{"hello", "world", "Go"} { + m.Store(i, v) + } + m.Range(func(key, value interface{}) bool { + m.Range(func(key, value interface{}) bool { + // We should be able to load the key offered in the Range callback, + // because there are no concurrent Delete involved in this tested map. + if v, ok := m.Load(key); !ok || !reflect.DeepEqual(v, value) { + t.Fatalf("Nested Range loads unexpected value, got %+v want %+v", v, value) + } + + // We didn't keep 42 and a value into the map before, if somehow we loaded + // a value from such a key, meaning there must be an internal bug regarding + // nested range in the Map. + if _, loaded := m.LoadOrStore(42, "dummy"); loaded { + t.Fatalf("Nested Range loads unexpected value, want store a new value") + } + + // Try to Store then LoadAndDelete the corresponding value with the key + // 42 to the Map. In this case, the key 42 and associated value should be + // removed from the Map. Therefore any future range won't observe key 42 + // as we checked in above. + val := "sync.Map" + m.Store(42, val) + if v, loaded := m.LoadAndDelete(42); !loaded || !reflect.DeepEqual(v, val) { + t.Fatalf("Nested Range loads unexpected value, got %v, want %v", v, val) + } + return true + }) + + // Remove key from Map on-the-fly. + m.Delete(key) + return true + }) + + // After a Range of Delete, all keys should be removed and any + // further Range won't invoke the callback. Hence length remains 0. + length := 0 + m.Range(func(key, value interface{}) bool { + length++ + return true + }) + + if length != 0 { + t.Fatalf("Unexpected sync.Map size, got %v want %v", length, 0) + } +} From 4b27d40b508a1d37ffcd84a411408309804d2a2a Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 10 Nov 2021 09:35:59 -0800 Subject: [PATCH 092/752] misc/cgo/testshared: correct test of gccgo version number We still don't run the gccgo tests, because they don't run in module mode. But now we at least get the version number check right. Change-Id: Ifde4512c30605d1cb7e3a521f381a05c783549b7 Reviewed-on: https://go-review.googlesource.com/c/go/+/362996 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor Reviewed-by: Than McIntosh TryBot-Result: Go Bot --- misc/cgo/testshared/shared_test.go | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/misc/cgo/testshared/shared_test.go b/misc/cgo/testshared/shared_test.go index 672811fe0e..d5d018f151 100644 --- a/misc/cgo/testshared/shared_test.go +++ b/misc/cgo/testshared/shared_test.go @@ -20,6 +20,7 @@ import ( "regexp" "runtime" "sort" + "strconv" "strings" "testing" "time" @@ -694,7 +695,15 @@ func requireGccgo(t *testing.T) { if err != nil { t.Fatalf("%s -dumpversion failed: %v\n%s", gccgoPath, err, output) } - if string(output) < "5" { + dot := bytes.Index(output, []byte{'.'}) + if dot > 0 { + output = output[:dot] + } + major, err := strconv.Atoi(string(output)) + if err != nil { + t.Skipf("can't parse gccgo version number %s", output) + } + if major < 5 { t.Skipf("gccgo too old (%s)", strings.TrimSpace(string(output))) } From 99fa49e4b7f74fb21cc811270fe42c9b7fa99668 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 9 Nov 2021 16:17:50 -0800 Subject: [PATCH 093/752] lib/time, time/tzdata: update to 2021e Doing this a little early in the release cycle as there have been some changes in the handling of old timezones. They should continue to work as expected, but more testing time may be useful. For #22487 Change-Id: I3686fed79a052c46112445055044cff5842f2a45 Reviewed-on: https://go-review.googlesource.com/c/go/+/362874 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Go Bot Reviewed-by: Tobias Klauser --- lib/time/update.bash | 4 +- lib/time/zoneinfo.zip | Bin 424214 -> 425837 bytes src/time/tzdata/zipdata.go | 13815 ++++++++++++++++++----------------- 3 files changed, 6923 insertions(+), 6896 deletions(-) diff --git a/lib/time/update.bash b/lib/time/update.bash index e088ea6b90..feb95e2e53 100755 --- 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=2021a -DATA=2021a +CODE=2021e +DATA=2021e set -e rm -rf work diff --git a/lib/time/zoneinfo.zip b/lib/time/zoneinfo.zip index d32fbba5175174b72ca42df853941f5a7122fad6..a859b4113b75fdc2f6e1685a13a80a85bffc03bd 100644 GIT binary patch delta 74247 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 diff --git a/src/time/tzdata/zipdata.go b/src/time/tzdata/zipdata.go index 60c0784008..09ca148770 100644 --- a/src/time/tzdata/zipdata.go +++ b/src/time/tzdata/zipdata.go @@ -16,375 +16,454 @@ package tzdata -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+\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#\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\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\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" + +const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Africa/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x0f\x00\x1c\x00Africa/GaboroneUT\t\x00\x03\x82\x0f\x8ba\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" + + "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\f\x00\x1c\x00A" + + "frica/DakarUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#" + + "\x82iS\xaa\x81\t\x03\xa0\x00\x00\x00\xa0\x00\x00\x00\x0f\x00\x1c\x00Africa/NdjamenaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\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#\x82iS\xf1\b{\x87" + + "\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x1c\x00Africa/AbidjanUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\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#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/HarareUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" + + "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x1c\x00Afri" + + "ca/OuagadougouUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSd\x01\x05\x89\u007f\a\x00\x00\u007f\a\x00\x00\x11\x00\x1c\x00Africa/CasablancaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\\\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\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\x8b" + + "l\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\xa0S" + + "F \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\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x14\x00\x1c\x00Africa/Dar_es_SalaamUT\t\x00" + + "\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00" + + "\x00\x11\x00\x1c\x00Africa/Porto-NovoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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" + + "#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x0f\x00\x1c\x00Africa/KinshasaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" + "\x00\x00\x00\x00\x00\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\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\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" + + "-1\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x12\x00\x1c\x00Africa/BrazzavilleUT\t\x00\x03\x82\x0f\x8ba" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" + + "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xab" + + "p\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\x00GM" + + "T\x00+0030\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x10\x00\x1c\x00Africa/Moga" + + "dishuUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xc1\n" + + "\x8a\x84\xad\x00\x00\x00\xad\x00\x00\x00\x0f\x00\x1c\x00Africa/Sao_TomeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\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" + + "#\x82iS\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\x13\x00\x1c\x00Africa/JohannesburgUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x04" + + "LMT\x00SAST\x00\nSAST-2\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSm)\xb8P~\x02\x00\x00~\x02\x00\x00\x0f\x00\x1c\x00Africa/Windho" + + "ekUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x1c\x00Africa/NiameyUT\t\x00\x03\x82\x0f\x8ba" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" + + "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xab" + + "p\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\x00GM" + + "T\x00+0030\x00WAT\x00\nWAT-1\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0e\x00\x1c\x00Africa/Nair" + + "obiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS)\xae\x8eo" + + "&\a\x00\x00&\a\x00\x00\x0f\x00\x1c\x00Africa/El_AaiunUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + - "\x00\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\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\fa" + + "G\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\\\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`r" + + "X \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\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\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\xed" + + "X\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\xe7" + + "\x9c\xa0\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\b" + + "LMT\x00-01\x00+01\x00+00\x00\n<+01>-1\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Afric" + + "a/LusakaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82i" + + "S\x93\xf4\x94\v\xc1\x01\x00\x00\xc1\x01\x00\x00\f\x00\x1c\x00Africa/TunisUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\x00" + + "I\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\x00CET\x00\nCET-1\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\r\x00\x1c\x00Afri" + + "ca/MaseruUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82i" + + "S\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\v\x00\x1c\x00Africa/LomeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x1c\x00Africa/DoualaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" + + "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x10\x00\x1c\x00Africa/Bujumb" + + "uraUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSV\xadD\xef" + + "\xca\x01\x00\x00\xca\x01\x00\x00\x0f\x00\x1c\x00Africa/KhartoumUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\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\x86" + + "sP\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\x80" + + "E \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#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\r" + + "\x00\x1c\x00Africa/AsmaraUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x1c\x00Africa/ConakryUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82iSÊ\x0e\xc0\xd6\x01\x00\x00\xd6\x01\x00\x00\x0e\x00\x1c\x00Africa/Algier" + + "sUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00W" + + "ET\x00CEST\x00CET\x00\nCET-1\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x1c\x00Africa/Bang" + + "uiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x11\x00\x1c\x00" + + "Africa/LibrevilleUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x14" + + "\xcf\x10n\xca\x01\x00\x00\xca\x01\x00\x00\v\x00\x1c\x00Africa/JubaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x86s" + + "P\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#\x82iS6\x99rU\xa4\x00\x00\x00\xa4\x00\x00\x00\x0f\x00" + + "\x1c\x00Africa/MonroviaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0f\x00\x1c\x00A" + + "frica/DjiboutiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x1c\x00Africa/TimbuktuUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x1c\x00Africa/MalaboU" + + "T\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x1c\x00Afr" + + "ica/FreetownUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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" + + "#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\r\x00\x1c\x00Africa/BanjulUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\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#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x1c\x00Africa/KigaliUT\t\x00\x03\x82" + + "\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xca>\xd5\xe0\x95\x00\x00\x00\x95\x00\x00\x00\r" + + "\x00\x1c\x00Africa/BissauUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\x0e\x00\x1c\x00Africa/MbabaneUT\t" + + "\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x9f\x1b\xeb\xdd2\x02\x00\x002\x02\x00" + + "\x00\f\x00\x1c\x00Africa/CeutaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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" + + "#" + + "\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\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#\x82iS_\u007f2[\xaf\x01\x00\x00\xaf\x01" + + "\x00\x00\x0e\x00\x1c\x00Africa/TripoliUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\nP" + + "K\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x11\x00\x1c\x00Africa/NouakchottUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" + + "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0e\x00\x1c\x00Africa" + + "/KampalaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82i" + + "S\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x1c\x00America/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00" + + "\x00\x00\x00#\x82iS\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x0f\x00\x1c\x00America/TijuanaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00PWT\x00PPT\x00\nPST8PDT,M3.2" + + ".0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x14\x00\x1c\x00America/Blanc-Sablo" + + "nUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xb4\x82s\x1dT\x01\x00\x00T\x01\x00\x00\x11\x00\x1c\x00Amer" + + "ica/ChihuahuaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\nMS" + + "T7MDT,M4.1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x10\x00\x1c\x00America/A" + + "tikokanUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\nE" + + "ST5\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS?_p\x99\x0e\x05\x00\x00\x0e\x05\x00\x00\x10\x00\x1c\x00America/WinnipegUT\t\x00\x03\x82\x0f\x8ba\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" + + "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xe4\xb0" + + "\x94\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\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\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#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\r\x00\x1c\x00America/ArubaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\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\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSJtZ\x8c\x01\x03\x00\x00\x01\x03\x00\x00\x13\x00\x1c\x00America/PangnirtungUT\t\x00\x03\x82\x0f\x8ba\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" + + "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00" + + "1gg\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" + + "\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\x00ADDT\x00ADT\x00EDT\x00EST\x00CST\x00CDT\x00\nEST5EDT,M3.2.0,M1" + + "1.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x12\x00\x1c\x00America/MontserratUT\t\x00\x03\x82" + + "\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x12\x00\x1c\x00America/Kra" + + "lendijkUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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" + + "\xd5\xd0\x01\b\xff\xff\xd5\xd0\x01\fLMT\x00AST\x00APT\x00AWT\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xf6\"\x12\xfe\x0e\x05\x00\x00\x0e\x05\x00\x00\x13\x00" + + "\x1c\x00America/Los_AngelesUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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" + + "\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\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 \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\n" + + "PST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x10\x00\x1c\x00America" + + "/St_KittsUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xbf\x03u\xf3\xe4\x01\x00\x00\xe4\x01\x00\x00" + + "\x0e\x00\x1c\x00America/RecifeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xd2" + + "\xb0\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\xe9\x0f\xa0\x00\x00\x00\x00;\xc8\xff\xb0\x00\x00\x00\x003\nPK\x03\x04\n\x00\x00\x00\x00\x00" + + "#\x82iS\xd6\xfe\xf3%\xb4\x02\x00\x00\xb4\x02\x00\x00\x10\x00\x1c\x00America/ResoluteUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\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" + @@ -393,97 +472,40 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\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" + + "\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\x00" + + "CST\x00CDT\x00EST\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02" + + "\x00\x00\x11\x00\x1c\x00America/CatamarcaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x9c" + + "50\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#\x82iS\xae,\xa44\xc9\x03\x00" + + "\x00\xc9\x03\x00\x00\f\x00\x1c\x00America/AtkaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x003\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\x003\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" + + "\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\x00" + + "4S\"\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\x00" + + "BO\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\x19" + + "LMT\x00NST\x00NWT\x00NPT\x00BST\x00BDT\x00AHST\x00HDT\x00\nHST10HDT,M3.2.0,M11.1.0\nPK" + + "\x03\x04\n\x00\x00\x00\x00\x00#\x82iS.\xbe\x1a>\xe7\x03\x00\x00\xe7\x03\x00\x00\r\x00\x1c\x00America/BoiseUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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" + @@ -499,296 +521,191 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\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\x00N\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" + + "PDT\x00PST\x00MWT\x00MPT\x00MST\x00MDT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82" + + "iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x1c\x00America/North_Dakota/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSR\x1b\x8b(\xde\x03\x00\x00\xde\x03\x00\x00\x1e\x00\x1c\x00America/North_Dakota/Ne" + + "w_SalemUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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#\x82iSH\xeam\xef\xde\x03\x00\x00\xde\x03\x00\x00\x1b\x00\x1c\x00America/North_Dakota/Cent" + + "erUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#\xf4" + + "p\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\xde" + + "\x80\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,M11.1.0\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xb7.\xb6*\x13\x04\x00\x00\x13\x04\x00\x00\x1b\x00\x1c\x00America/North_Dakota/BeulahUT\t" + + "\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00" + + "2s\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\x14" + + "LMT\x00MDT\x00MST\x00MWT\x00MPT\x00CST\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82" + + "iSa\xcb'\xe9\x9c\x01\x00\x00\x9c\x01\x00\x00\x0e\x00\x1c\x00America/ManausUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\xde" + + "\x9b\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#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x15\x00\x1c\x00America/Port_of_SpainUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" + + "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xf6" + + "2\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\x00AW" + + "T\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSŒZ\x8c\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x1c\x00America/MendozaUT\t\x00\x03\x82\x0f" + + "\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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#\x82iS\xac\x8a\x83S\xd4\x00\x00\x00\xd4\x00\x00\x00\x11\x00\x1c\x00America/GuatemalaUT\t\x00" + + "\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00D" + + "TR`\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#\x82iSU!\x12f\xd9\x02\x00\x00\xd9\x02\x00\x00\x13\x00\x1c\x00America/YellowknifeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" + + "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x003\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\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\x00Q3\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@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\nM" + + "ST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xe90T\x16\xd1\x01\x00\x00\xd1\x01\x00\x00\f\x00\x1c\x00America/" + + "NuukUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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#3<-02>,M3.5" + + ".0/-2,M10.5.0/-1\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x15\x00\x1c\x00America/St_Ba" + + "rthelemyUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS:\x9a1T\xdf\x01\x00\x00\xdf\x01\x00\x00\x14" + + "\x00\x1c\x00America/ScoresbysundUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#1<+00>,M3.5.0/0,M10.5.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00" + + "#\x82iS\x9d?\xdfڸ\x03\x00\x00\xb8\x03\x00\x00\x11\x00\x1c\x00America/Sao_PauloUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00" + + "48T0\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\x00N\xf0\xa0\x00\x00\x00\x00?\x91\xfe0\x00\x00\x00\x00@.Ҡ\x00\x00\x00\x00A\x86\xf80\x00\x00\x00\x00" + + "B\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\x00" + + "P\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#\x82iS\x82\x13z\xe2\xc2\x00\x00\x00\xc2\x00\x00\x00\x13\x00\x1c\x00America/TegucigalpaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" + + "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSM\x94\xc7Kp\x03\x00\x00p\x03\x00\x00\x11\x00\x1c\x00Am" + + "erica/Glace_BayUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\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\x00APT\x00\n" + + "AST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x8f\x19Ԇ\x12\x02\x00\x00\x12\x02\x00\x00\x16\x00\x1c\x00America" + + "/Bahia_BanderasUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\nCST6CDT,M4.1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f" + + "\x00\x1c\x00America/RosarioUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x81{\xc1\x92\xbc\x03\x00\x00\xbc\x03\x00\x00" + + "\r\x00\x1c\x00America/SitkaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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" + @@ -804,1420 +721,570 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00 "\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]\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\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" + + "\x00YST\x00AKDT\x00AKST\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS):\x17-\x88" + + "\x06\x00\x00\x88\x06\x00\x00\x0f\x00\x1c\x00America/HalifaxUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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'!\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" + - "\x00N\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\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\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\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\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#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\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" + + "\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\xfe" + + "0\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߉V" + + "P\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\xc1" + + "P\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\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\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\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\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" + + "\x02\x01\x02\x01\x02\x01\x02\x01\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#\x82iS" + + "\xc1Ȇ\x90\x05\x04\x00\x00\x05\x04\x00\x00\x12\x00\x1c\x00America/WhitehorseUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\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\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\x00Q4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSc)\xf6)\xb3\x00\x00\x00\xb3\x00" + + "\x00\x00\x0e\x00\x1c\x00America/BogotaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82i" + + "S8O:\xbf\x95\x03\x00\x00\x95\x03\x00\x00\x11\x00\x1c\x00America/MenomineeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\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\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\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\"7" + + "p\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\xea" + + "p\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\nCST6" + + "CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS<\xb9\x18\x87\xe4\x02\x00\x00\xe4\x02\x00\x00\x0f\x00\x1c\x00America/Iqa" + + "luitUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x00E" + + "PT\x00EST\x00EDDT\x00EDT\x00EWT\x00CST\x00CDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00" + + "\x00\x00#\x82iS\xad`\x12\xe9\xaa\x00\x00\x00\xaa\x00\x00\x00\x0e\x00\x1c\x00America/La_PazUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" + + "\x00\x00\x00\x00\x00\x00\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-04\x00\n<-04>4\nPK\x03\x04\n\x00" + + "\x00\x00\x00\x00#\x82iS\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\f\x00\x1c\x00America/AdakUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" + + "\x00\x00\x00\x00\x00\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\xcb" + + "\x89D\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\x002" + + "s@\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\nHST10HDT,M3" + + ".2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xea$\xc1\xbf\xb0\x00\x00\x00\xb0\x00\x00\x00\x13\x00\x1c\x00America/El_Salvad" + + "orUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x15\x00\x1c\x00Amer" + + "ica/Coral_HarbourUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00" + + "CMT\x00EST\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x1c\x00America/Kentucky" + + "/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x03\x1a|J\xcc\x03\x00\x00\xcc\x03\x00\x00\x1b\x00\x1c\x00A" + + "merica/Kentucky/MonticelloUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\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\x00CPT\x00EDT\x00EST\x00\nEST5EDT,M3.2.0,M1" + + "1.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xdf\xe5\x8d\xc4\xda\x04\x00\x00\xda\x04\x00\x00\x1b\x00\x1c\x00America/Kentucky/Louisvi" + + "lleUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xe1i" + + "Tp\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\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\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\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#\x82iS3\x9aG\xc8\xd0\x06\x00\x00\xd0\x06\x00\x00\x10\x00\x1c\x00America/New_YorkU" + + "T\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xde" + + "\x87\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\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\x00E" + + "WT\x00EPT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSl=\xad\xbe\x16\x01\x00\x00\x16\x01\x00\x00\x10\x00\x1c" + + "\x00America/BarbadosUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x04\x00\x00\x00\x12\xff\xff\xff\xff\x92@\xa9e\xff\xff\xff\xff\xcb\xe3\xcb\xd0\xff\xff\xff\xff̔\x82\xe0\xff\xff\xff\xff\xcd\xd6\"\xd0\xff\xff\xff\xff\xce|M\xe0" + + "\xff\xff\xff\xffϛ\xa6\xd0\xff\xff\xff\xff\xd0ej`\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\x02\x01\x02\x01\x02\x03\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\xc8\x1b\x00\x00\xff\xff\xd5\xd0\x01\x04\xff\xff\xc7\xc0\x00\b\xff\xff\xce\xc8\x01\fL" + + "MT\x00ADT\x00AST\x00-0330\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x13\x00\x1c\x00America" + + "/Puerto_RicoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1" + + "\x00\x00\x00\x10\x00\x1c\x00America/AnguillaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82" + + "iS,\xdb~\xab\xb2\x03\x00\x00\xb2\x03\x00\x00\x0f\x00\x1c\x00America/YakutatUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" + - "\x00\x00\x00\x00\x00\x00\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@" + + "\x00\x00\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\x00Y" + + "WT\x00YPT\x00YDT\x00AKDT\x00AKST\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82i" + + "SV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x10\x00\x1c\x00America/ShiprockUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" + + "\x00\x00\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\n" + + "MST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x1c\x00America" + + "/Argentina/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSR\xc8\xd9\xf6\xc4\x02\x00" + + "\x00\xc4\x02\x00\x00\x1b\x00\x1c\x00America/Argentina/CatamarcaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xf6" + + "2\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#\x82iSR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00 \x00\x1c\x00America/Argentina/ComodRivadaviaUT\t\x00\x03\x82" + + "\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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-0" + + "2\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSŒZ\x8c\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x1c\x00America/Argentina/Me" + + "ndozaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x8b}\xb6\x1e\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x1c\x00America/A" + + "rgentina/UshuaiaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSm\aD\x0e\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00" + + "\x1c\x00America/Argentina/La_RiojaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\fLMT\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00" + + "\x00\x00\x00#\x82iSutZ\x1a\xb2\x02\x00\x00\xb2\x02\x00\x00\x17\x00\x1c\x00America/Argentina/JujuyUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" + + "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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'*W\xc0\x00\x00\x00\x00'\xe2۰\x00\x00\x00\x00(\xee\x8a@\x00\x00\x00\x00)\xb0:\xa0\x00\x00\x00\x00*\xe0\xd3" + + "0\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#\x82iS\x1c\x80" + + "\xb9\\\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x1c\x00America/Argentina/San_LuisUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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;\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%\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#\x82iS\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x1e\x00\x1c\x00America/Argentina/Buenos_" + + "AiresUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x8ep\xb4c\xc4\x02\x00\x00\xc4\x02\x00\x00\x1e\x00\x1c\x00America/A" + + "rgentina/Rio_GallegosUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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ɰ\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@\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#\x82iS\xfcz=\xe1\xcd\x02\x00\x00\xcd" + + "\x02\x00\x00\x1a\x00\x1c\x00America/Argentina/San_JuanUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\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'\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'*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\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\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\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\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\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\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\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\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\"" + - "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\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#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" + + "\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#\x82iS\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x1c\x00America/Argentina/CordobaUT\t\x00\x03\x82\x0f" + + "\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00" + + "I\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#\x82iSY\xd8֭\xd6\x02\x00\x00\xd6\x02\x00\x00\x19\x00\x1c\x00America/Argentina/Tuc" + + "umanUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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#\x82iSt*\x9b!\xb2\x02\x00\x00" + + "\xb2\x02\x00\x00\x17\x00\x1c\x00America/Argentina/SaltaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\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\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 \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#\x82iSp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x14\x00\x1c\x00A" + + "merica/IndianapolisUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSq\xc9*;\xb1\x00\x00\x00" + + "\xb1\x00\x00\x00\x10\x00\x1c\x00America/DominicaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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-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\x002\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\x00N\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#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\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\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\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\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\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\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\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" + - "\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\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#" + + "\x82iS\x9bܩ=\xda\x06\x00\x00\xda\x06\x00\x00\x0f\x00\x1c\x00America/ChicagoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\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\xf9" + + "p\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\xc2" + + "p\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\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#\x82iS\x1c\xd8\x19\x9dp\x01\x00\x00p\x01\x00\x00\x15\x00\x1c\x00America/Swift_" + + "CurrentUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x1e+}" + + "\x15\xb4\x02\x00\x00\xb4\x02\x00\x00\x14\x00\x1c\x00America/Rankin_InletUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\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\x00" + + "62\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\x00" + + "D/\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#\x82iSԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x0e" + + "\x00\x1c\x00America/PanamaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00" + + "CMT\x00EST\x00\nEST5\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xe90T\x16\xd1\x01\x00\x00\xd1\x01\x00\x00\x0f\x00\x1c\x00America/GodthabU" + + "T\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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#3<-02>,M3.5.0/-2" + + ",M10.5.0/-1\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x89غ\xee\x15\x04\x00\x00\x15\x04\x00\x00\x0e\x00\x1c\x00America/BelizeUT\t\x00" + + "\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xc1" + + "x\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ڙ\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\xf2" + + "c\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\x00CDT\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00#" + + "\x82iS\xd7\b\\\xc6&\x02\x00\x00&\x02\x00\x00\x10\x00\x1c\x00America/MiquelonUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82iSB\xa0=:\x1e\x01\x00\x00\x1e\x01\x00\x00\x12\x00\x1c\x00America/Hermosill" + + "oUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00" + + "62ڀ\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\x00MST\x00CST" + + "\x00PST\x00MDT\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\x0f\x00\x1c\x00America/Detroit" + + "UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x003" + + "GI\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\x00E" + + "DT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xb4\x11Z\xde\xe4\x01\x00\x00\xe4\x01\x00\x00\x11\x00\x1c\x00Ame" + + "rica/FortalezaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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=\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\x00N\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\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\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\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\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!\x81i" + + "0\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\x003\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS" + + "$\r\x89l\xe4\x01\x00\x00\xe4\x01\x00\x00\x0f\x00\x1c\x00America/OjinagaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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#\x82iS5\x11Q\x06\xd1\x03\x00\x00\xd1\x03\x00\x00\x11\x00\x1c\x00America/AnchorageUT\t\x00\x03\x82\x0f\x8ba\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" + "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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" + @@ -2233,1853 +1300,310 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\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\"\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#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\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" + + "KDT\x00AKST\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSU9#\xbe2\x05\x00\x002\x05\x00" + + "\x00\x11\x00\x1c\x00America/VancouverUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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#\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-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\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\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" + + "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\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\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x1c\x00America/Porto_AcreUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" + + "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xdc" + + "\xb9u@\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-0" + + "4\x00-05\x00\n<-05>5\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSd\xa9y\x9at\x03\x00\x00t\x03\x00\x00\x10\x00\x1c\x00America/Asuncion" + + "UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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Ȱ\x00\x00\x00\x00\x14" + + "8\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\x000" + + "n\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#\x82iS?\xc9\x1c\xd4\xc6\x03\x00\x00\xc6\x03\x00\x00\x0e\x00\x1c\x00America/JuneauUT\t\x00" + + "\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\x00PST\x00PWT\x00PPT\x00PDT\x00YDT\x00YST\x00AKDT\x00A" + + "KST\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xf6@\rm\xa8\x05\x00\x00\xa8\x05\x00\x00\x13\x00\x1c\x00" + + "America/Fort_NelsonUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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" + - "\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\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" + + "\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\xe1i" + + "p\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\xc8" + + "H\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\xe0" + + "\xaf\xa0\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\x02" + + "5\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\x00Q3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSV\x80\x94@\x12\x04" + + "\x00\x00\x12\x04\x00\x00\x0e\x00\x1c\x00America/DenverUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xd2" + + "a\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\x04" + + "a\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\x12" + + "ye\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,M" + + "3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x12\x00\x1c\x00America/Fort_Way" + + "neUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x1c\x00America/R" + + "io_BrancoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x1e\xfbn۸\x03\x00\x00\xb8\x03\x00" + + "\x00\x14\x00\x1c\x00America/Campo_GrandeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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" + + "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\x00" + + "Jڒ\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\x00" + + "X\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#\x82iS{" + + "\a\a\xdc\xca\x03\x00\x00\xca\x03\x00\x00\x10\x00\x1c\x00America/EdmontonUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\nMST7MDT,M3.2.0" + + ",M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x11\x00\x1c\x00America/St_ThomasUT\t\x00" + + "\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\fL" + + "MT\x00AST\x00APT\x00AWT\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x0e\x00\x1c\x00America/V" + + "irginUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSMv\xa1\x0f%\x01\x00\x00%\x01\x00\x00\x11\x00\x1c\x00" + + "America/MonterreyUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00" + + "9\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#\x82iS\xb4T\xbd\xeb5\x02\x00\x00" + + "5\x02\x00\x00\x16\x00\x1c\x00America/Port-au-PrinceUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\x94" + + "P\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" + + "\x00CdE@\x00\x00\x00\x00D/ZP\x00\x00\x00\x00ED'@\x00\x00\x00\x00O\\Mp\x00\x00\x00\x00P\x96\x04`\x00\x00\x00\x00Q4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x12\x00\x1c\x00America/St_Vince" + + "ntUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x10\x00\x1c\x00Ame" + + "rica/EnsenadaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\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" + + "\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\x00" + + "1g\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\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\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" + + "\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\x14LM" + + "T\x00MST\x00PST\x00PDT\x00PWT\x00PPT\x00\nPST8PDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS" + + "\xb1݂x\xe8\x00\x00\x00\xe8\x00\x00\x00\x12\x00\x1c\x00America/Costa_RicaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\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#\x82iS\xa2\x81\xbfyS\x02\x00\x00S\x02\x00\x00\x12\x00\x1c\x00America/MetlakatlaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01" + + "\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xce" + + "\x90\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\x81" + + "p\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#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x0f\x00\x1c\x00America/CuracaoUT\t\x00\x03\x82\x0f\x8ba\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" + + "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xe6\x95" + + "\xb9\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#\x82iS\xa7\x17jҲ\x00\x00\x00\xb2\x00\x00\x00\x12\x00\x1c\x00America/Martini" + + "queUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x10\x00\x1c\x00A" + + "merica/St_JohnsUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\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\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\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\"\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" + + "\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#\x82iSutZ\x1a\xb2\x02\x00\x00\xb2\x02\x00\x00\r\x00\x1c\x00America/JujuyUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" + + "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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'*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#\x82iSP\x0f(\b" + + "=\x01\x00\x00=\x01\x00\x00\x15\x00\x1c\x00America/Santo_DomingoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" + - "\x00\x00\x00\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\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\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#\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#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#\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#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\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" + - "ǁ\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\x00C" + - "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\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\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\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\x00N\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'\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\x002\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\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)" + - "\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\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" + - "\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\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\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\x00ES" + + "T\x00-0430\x00AST\x00\nAST4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\u0096dK~\x02\x00\x00~\x02\x00\x00\x0e\x00\x1c\x00America/Regi" + + "naUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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" + @@ -4090,40 +1614,436 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00 "\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#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\xfb" + - "0\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\xae" + - "0\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\x03\x02\x03\x02\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" + + "T\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSp\x1b\xceRC\x03\x00\x00C\x03\x00\x00\x0f\x00\x1c\x00America/NipigonUT\t\x00\x03\x82\x0f" + + "\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xff" + + "r\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\x00" + + "9\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\x00EST\x00EWT\x00EPT\x00\nEST5EDT" + + ",M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSo_\x00v/\x01\x00\x00/\x01\x00\x00\x0e\x00\x1c\x00America/Merida" + + "UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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\x00E" + + "ST\x00CDT\x00\nCST6CDT,M4.1.0,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSn\xab\xd5\xf9\xcf\x03\x00\x00\xcf\x03\x00\x00\f\x00\x1c" + + "\x00America/NomeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x003G\x820\x00\x00\x00\x004S\x14\xa0\x00\x00\x00\x00" + + "5'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\x00" + + "Cd\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\xff" + + "d\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\x00" + + "NWT\x00NPT\x00BST\x00BDT\x00YST\x00AKDT\x00AKST\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04" + + "\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x1c\x00America/Indiana/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01" + + "\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSصK\xa6\n\x02\x00\x00\n\x02\x00\x00\x19\x00\x1c\x00America/Indiana/Tell" + + "_CityUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00" + + "E\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#\x82iSp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x1c\x00\x1c\x00America/Indiana" + + "/IndianapolisUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00" + + "D/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\x00" + + "EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSM/U\x9f7\x02\x00\x007\x02\x00\x00\x17\x00" + + "\x1c\x00America/Indiana/MarengoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00" + + "E\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\nEST" + + "5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\r\xedsp.\x02\x00\x00.\x02\x00\x00\x19\x00\x1c\x00America/In" + + "diana/VincennesUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00CST\x00CWT\x00CPT\x00EST\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0" + + "\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x01\xd8N\x8c\xab\x02\x00\x00\xab\x02\x00\x00\x1a\x00\x1c\x00America/Indiana/PetersburgUT\t" + + "\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\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\x14" + + "LMT\x00CDT\x00CST\x00CWT\x00CPT\x00EST\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82" + + "iSK-E\xfad\x02\x00\x00d\x02\x00\x00\x17\x00\x1c\x00America/Indiana/WinamacUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\nES" + + "T5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS \x17\x89}q\x01\x00\x00q\x01\x00\x00\x15\x00\x1c\x00America/I" + + "ndiana/VevayUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xcb" + + "\x88\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#" + + "\x82iS$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x14\x00\x1c\x00America/Indiana/KnoxUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82iSԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x0e\x00\x1c\x00America/CaymanUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" + + "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xe9\x8c" + + "\xb4$q\x03\x00\x00q\x03\x00\x00\x13\x00\x1c\x00America/Thunder_BayUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" + + "\x00\x00\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\x00" + + "1gg\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\x00CS" + + "T\x00EST\x00EWT\x00EPT\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS8\xcdZ\x05" + + "o\x01\x00\x00o\x01\x00\x00\x10\x00\x1c\x00America/MazatlanUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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#\x82iS\xb7-2f\xe4\x01\x00\x00\xe4\x01\x00\x00\x0f\x00\x1c\x00America/NoronhaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" + + "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xdc" + + "\xb9K\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\b" + + "LMT\x00-01\x00-02\x00\n<-02>2\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x14\x00\x1c\x00America/Bu" + + "enos_AiresUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xd4p" + + "0\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\xd3" + + "0\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\fLM" + + "T\x00CMT\x00-04\x00-03\x00-02\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x0f\x00\x1c\x00Amer" + + "ica/TortolaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xa1'\a\xbd\x97\x00\x00\x00\x97\x00" + + "\x00\x00\x0f\x00\x1c\x00America/CayenneUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\b" + + "LMT\x00-04\x00-03\x00\n<-03>3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x10\x00\x1c\x00America/St" + + "_LuciaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSk\xc2\rx\xbf\x01\x00\x00\xbf\x01\x00\x00\x14\x00\x1c" + + "\x00America/DanmarkshavnUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xfe7\xa1\x87\x1b\x01\x00" + + "\x00\x1b\x01\x00\x00\f\x00\x1c\x00America/LimaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xac\x8e\xee\x13\xbe\x00\x00\x00\xbe\x00\x00\x00\x0f\x00" + + "\x1c\x00America/CaracasUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00\x0f\x00\x1c\x00America/PhoenixUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00MW" + + "T\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS<\x01V\rP\x02\x00\x00P\x02\x00\x00\x11\x00\x1c\x00America/AraguainaUT\t\x00\x03" + + "\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x0048" + + "T0\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\x00N\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#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x15\x00\x1c\x00America/Lower_P" + + "rincesUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSk^2S\xb9\x04\x00\x00\xb9\x04\x00\x00\x14\x00\x1c" + + "\x00America/Punta_ArenasUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#\x82iS\x1d`̟\x00\x03\x00\x00\x00\x03\x00\x00\x15\x00\x1c\x00America/Cambridge_BayUT\t\x00\x03\x82\x0f\x8ba\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" + + "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00" + + "1g\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#\x82iSӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x10\x00\x1c\x00America/MontrealUT\t\x00\x03\x82\x0f\x8ba" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" + + "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xee" + + "x\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\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#\x82iS\x04,2h\x99\x01\x00\x00\x99\x01\x00\x00\x10\x00\x1c\x00America/SantaremUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01" + + "\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\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\nP" + + "K\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xf2\x04\xde\xdd\x11\x02\x00\x00\x11\x02\x00\x00\x0e\x00\x1c\x00America/CancunUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" + + "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00I\xd8e\x00\x00\x00\x00\x00J\xe3\xf7p\x00\x00\x00\x00K\xb8" + + "G\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\x00EDT\x00EST\x00CDT\x00\nEST5\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSU\xactA\xb5\x01\x00\x00\xb5\x01\x00\x00\x11\x00\x1c\x00America/MatamorosUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" + + "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00" + + "CST\x00CDT\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSs\xb0\xeau\xb4\x01\x00\x00\xb4\x01\x00\x00\x10\x00" + + "\x1c\x00America/EirunepeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x14\x00\x1c\x00America/Santa_IsabelUT\t\x00\x03\x82\x0f\x8b" + + "a\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" + + "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x0f\x00\x1c\x00Ameri" + + "ca/GrenadaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00" + + "\x00\x0f\x00\x1c\x00America/MarigotUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xf7" + + "\xe9 y\xbd\x02\x00\x00\xbd\x02\x00\x00\x0e\x00\x1c\x00America/InuvikUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\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\x00PDD" + + "T\x00PST\x00MST\x00MDT\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xe5s\xb3\\'\x01\x00\x00" + + "'\x01\x00\x00\x0f\x00\x1c\x00America/ManaguaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00EST\x00CDT\x00\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS" + + "\xfe\xe6\xf5J\x05\x04\x00\x00\x05\x04\x00\x00\x0e\x00\x1c\x00America/DawsonUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\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#\x82iS[Sp\x90\x02\x05\x00\x00\x02\x05\x00\x00\x10\x00\x1c\x00America/SantiagoU" + + "T\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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" + @@ -4144,1198 +2064,2918 @@ const zipdata = "PK\x03\x04\n\x00\x00\x00\x00\x00\xf1c9R\x00\x00\x00\x00\x00\x00 "\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" + + "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#" + + "\x82iSø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00\x0f\x00\x1c\x00America/CrestonUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\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\nMST" + + "7\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x1c\x00America/CordobaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" + + "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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#\x82iS%J\xd5\xebS\x01\x00\x00S\x01\x00\x00\x0f\x00\x1c\x00America/JamaicaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" + + "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS挋\x92\xf6\x01\x00\x00\xf6\x01\x00\x00\x0e\x00\x1c\x00America/MaceioUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x003\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS+\x10`ȫ\x02\x00\x00\xab\x02\x00\x00\x14\x00\x1c\x00A" + + "merica/Dawson_CreekUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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#\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\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" + + "\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\xe1i" + + "p\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\xc8" + + "H\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\x00" + + "MST\x00\nMST7\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0f\x00\x1c\x00America/TorontoUT\t\x00\x03" + + "\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xb2g" + + "J`\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\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\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" + + "\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\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\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xd6\xe1Հ\x9c\x01\x00\x00\x9c\x01\x00\x00\x13\x00\x1c\x00America/Mexico_CityUT\t\x00\x03\x82\x0f\x8ba\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" + + "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00" + + "9\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#\x82iSӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0e\x00\x1c\x00America/NassauUT\t\x00\x03\x82\x0f" + + "\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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#\x82iS\u007f$*\xa0\xa6\x03\x00\x00\xa6\x03\x00\x00\x0e\x00\x1c\x00America/CuiabaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01" + + "\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" + + "\x00TZif2\x00\x00\x00\x00\x00\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\x06x" + + "0\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\x00N\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[\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\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#\x82iSq\xc9" + + "*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x12\x00\x1c\x00America/GuadeloupeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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" + + "\x00\x00\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#\x82iS\x1d\xf7\a ,\x06\x00\x00,\x06\x00\x00\x11\x00\x1c\x00America/Goose_BayUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" + + "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xde" + + "\xbeVX\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\xec" + + "\xb1\xb7\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\x16" + + "8\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\x002" + + "r\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\x00A" + + "ST\x00ADDT\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xdf\xe5\x8d\xc4\xda\x04\x00\x00\xda\x04\x00\x00\x12\x00" + + "\x1c\x00America/LouisvilleUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\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\a" + + "0\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\x15" + + "I)\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\x001" + + "gg\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\x00ES" + + "T\x00EDT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x1b\vKdC\x03\x00\x00C\x03\x00\x00\x13\x00\x1c\x00" + + "America/Rainy_RiverUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\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\x10LM" + + "T\x00CDT\x00CST\x00CWT\x00CPT\x00\nCST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xc0\x98\x00\b" + + "\xc9\x03\x00\x00\xc9\x03\x00\x00\x12\x00\x1c\x00America/MontevideoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\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\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\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\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\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\xc6" + + "0\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\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\xda" + + "\x98\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#\x82iS$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x0f\x00\x1c\x00America/Knox_INUT\t\x00\x03\x82\x0f\x8b" + + "a\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" + + "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xe3\xc9I\xd0U\x03\x00\x00U\x03\x00\x00\x12\x00\x1c\x00America/Grand_" + + "TurkUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x15" + + "I)\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\x001" + + "gg\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\x00Q5\nP" + + "K\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x01\x05\xf3\x89\xb5\x00\x00\x00\xb5\x00\x00\x00\x0e\x00\x1c\x00America/GuyanaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" + + "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x92\x1d\x0f\x87\xff\xff\xff\xff\x98\xd9" + + "{@\x00\x00\x00\x00\n\u007f\x05\xbc\x00\x00\x00\x00)\xd5@\xc0\x01\x02\x03\x01\xff\xff\xc9y\x00\x00\xff\xff\xc7\xc0\x00\x04\xff\xff\xcbD\x00\b\xff\xff\xd5\xd0\x00\x0eLMT\x00-04\x00-0345\x00" + + "-03\x00\n<-04>4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\a\x1c\x9e\x9a]\x04\x00\x00]\x04\x00\x00\x0e\x00\x1c\x00America/HavanaUT\t\x00" + + "\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xca" + + "\xbcm\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\nCST5CDT,M3.2.0/0,M11.1.0/1" + + "\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSOKjǪ\x02\x00\x00\xaa\x02\x00\x00\r\x00\x1c\x00America/BahiaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" + + "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00N\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#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00" + + "\x0f\x00\x1c\x00America/AntiguaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSU\r" + + "\xf7\xd3\xc7\x01\x00\x00\xc7\x01\x00\x00\r\x00\x1c\x00America/ThuleUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + - "\x00\x00\x00\x00\x00\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\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\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\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\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" + + "\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\x00AD" + + "T\x00AST\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\v\x00\x1c\x00" + + "Antarctica/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xcfׇ\xe1\x85\x00\x00" + + "\x00\x85\x00\x00\x00\x10\x00\x1c\x00Antarctica/SyowaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xc2\v\xae\b\x85\x00\x00\x00\x85\x00\x00\x00\x11\x00\x1c\x00Antarctica/VostokUT\t\x00\x03\x82\x0f" + + "\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x95\xea\x06\xd3\xc5\x00\x00\x00\xc5\x00\x00\x00" + + "\x10\x00\x1c\x00Antarctica/DavisUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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<+0" + + "7>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x12\x00\x1c\x00Antarctica/McMurdoUT\t\x00\x03\x82\x0f" + + "\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff" + + "A\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\x00" + + "46K\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\x00" + + "B<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\x00" + + "NZST\x00NZMT\x00NZDT\x00\nNZST-12NZDT,M9.5.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x95{" + + "\xf3\xa9w\x03\x00\x00w\x03\x00\x00\x11\x00\x1c\x00Antarctica/PalmerUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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" + + "\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\x8c" + + "4@\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#\x82iS" + + ":\xc8P7\xb1\x00\x00\x00\xb1\x00\x00\x00\x10\x00\x1c\x00Antarctica/TrollUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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-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\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#\x82iSƉ\xf71\x84\x00\x00\x00\x84\x00\x00\x00\x12\x00\x1c\x00Antarctica/RotheraUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" + + "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSn\x04\x19y\x9a\x00\x00\x00\x9a\x00\x00\x00\x19\x00\x1c\x00Antar" + + "ctica/DumontDUrvilleUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\tL" + + "MT\x00PMMT\x00+10\x00\n<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x15\x00\x1c\x00Antarcti" + + "ca/South_PoleUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\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\x00" + + "8Ӌ\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\x00" + + "F\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#\x82iS\xb2\x84J]\xd0\x03\x00\x00\xd0\x03\x00\x00\x14\x00\x1c\x00Antarctica/MacquarieUT\t\x00\x03\x82" + + "\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00AE" + + "ST\x00AEDT\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xd7N\xab\x8b\x98\x00\x00\x00" + + "\x98\x00\x00\x00\x11\x00\x1c\x00Antarctica/MawsonUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00" + + "FP\x00\b-00\x00+06\x00+05\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xddzAh\xf3\x00\x00\x00\xf3\x00\x00\x00\x10\x00\x1c\x00Antar" + + "ctica/CaseyUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Arctic/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82i" + + "S\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\x13\x00\x1c\x00Arctic/LongyearbyenUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xf1" + + "X\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#\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\x00" + + "BE\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#\x82iS\xee\xf0BB\xff\x01\x00\x00\xff\x01\x00\x00\v\x00\x1c\x00Asia/TaipeiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" + + "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc3U" + + "I\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#\x82iS\x9a\x1a\xdc\xca" + + "\xdc\x00\x00\x00\xdc\x00\x00\x00\r\x00\x1c\x00Asia/CalcuttaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSS\xa5\x81e\xf7\x00\x00\x00\xf7\x00\x00\x00\x0e" + + "\x00\x1c\x00Asia/PontianakUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xdb\xfa\xb5\xbeg\x02\x00\x00g\x02\x00\x00\v\x00\x1c\x00Asia/AqtobeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" + + "\x00\x00\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\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\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#\x82iS\x9a\x1a\xdc\xca\xdc\x00\x00\x00\xdc\x00\x00\x00\f\x00\x1c\x00Asia/KolkataUT" + + "\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x87\xbd\xedL\xf1\x02\x00\x00\xf1\x02\x00\x00\f\x00\x1c\x00Asia/BarnaulUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" + + "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\x00C" + + "c\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\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\x00bp\x01\fLMT\x00+06\x00+08\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00#" + + "\x82iS\xa7f^]@\x01\x00\x00@\x01\x00\x00\f\x00\x1c\x00Asia/KuchingUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\x01" + + "G\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\x14LMT\x00+0730\x00+082" + + "0\x00+08\x00+09\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSǯ\xdf\x1c\xee\x00\x00\x00\xee\x00\x00\x00\v\x00\x1c\x00Asia/Manila" + + "UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS?\xa7^\xfah\x02\x00\x00h\x02\x00\x00\v\x00\x1c\x00Asia" + + "/AtyrauUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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 l" + + "9\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\x00" + + "T`\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#\x82iS\x1d?v\f\x17\x03\x00\x00\x17\x03\x00\x00\n\x00\x1c\x00Asia/MacaoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\xd6t" + + "L\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\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\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\x12o" + + "l\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\x00C" + + "DT\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xdav\x19z\x98\x00\x00\x00\x98\x00\x00\x00\n\x00\x1c\x00Asia/QatarUT\t\x00\x03\x82\x0f\x8ba\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" + + "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x9d" + + "0\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" + + "#\x82iS\xf9l\x03\x12\xf8\x02\x00\x00\xf8\x02\x00\x00\f\x00\x1c\x00Asia/IrkutskUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\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\x00E" + + "C\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#\x82iS\xe8\xf0\xdeV\xe0\x04" + + "\x00\x00\xe0\x04\x00\x00\v\x00\x1c\x00Asia/HebronUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\x00w\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Щ\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\x00" + + "0H\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\x00J\xa0<`\x00\x00\x00\x00" + + "K\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\x00" + + "X\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`" + + "\x00\x00\x00\x00_\x93R`\x00\x00\x00\x00`^Y`\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\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\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\x00ID" + + "T\x00IST\x00\nEET-2EEST,M3.4.4/48,M10.5.5/1\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS]S\xbb\x12\xac\x03\x00\x00\xac" + + "\x03\x00\x00\x0e\x00\x1c\x00Asia/FamagustaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00" + + "6\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\x00" + + "EC\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\x00" + + "S7l\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\n" + + "EET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x84)\r\xbd\xec\x00\x00\x00\xec\x00\x00\x00\v\x00\x1c\x00A" + + "sia/SaigonUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00" + + "\v\x00\x1c\x00Asia/HarbinUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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(\a" + + "G \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#\x82iS\xba\xa3b\xc1R\x02\x00\x00R\x02\x00\x00\t\x00\x1c\x00Asia/HovdUT\t\x00\x03" + + "\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#\x82iS\xa9z\xc8\x1f\xce\x04\x00\x00\xce\x04\x00\x00\t\x00\x1c\x00Asia/GazaUT\t\x00" + + "\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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ͬ\xfe\x00\xff\xff\xff\xff\xce\xc7\x1f\x00\xff\xff\xff\xff\xcf" + + "\x8f\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\xf0" + + "y%\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\x002" + + "A\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\x00La\xbd\xd0\x00\x00\x00\x00M\x94\xf9\x9c\x00\x00\x00\x00N" + + "5\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`\x00\x00\x00\x00_\x93R`\x00\x00\x00\x00`^Y`\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\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 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.5.5/1\nPK\x03\x04\n\x00" + + "\x00\x00\x00\x00#\x82iS:\x11\xea\xa2\xe5\x02\x00\x00\xe5\x02\x00\x00\t\x00\x1c\x00Asia/OmskUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" + + "\x00\x00\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\x00" + + "8\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\x00" + + "F\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#\x82iS?Y\xaf\x19\xe7\x00\x00\x00\xe7\x00\x00\x00\n\x00\x1c\x00Asia/Dac" + + "caUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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<\xd8" + + "\x90\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+0" + + "530\x00+06\x00+07\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSB\x1d\xc6\x1b\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Asia/Urum" + + "qiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS?Y\xaf" + + "\x19\xe7\x00\x00\x00\xe7\x00\x00\x00\n\x00\x1c\x00Asia/DhakaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSE\t\xfa-" + + "\a\x03\x00\x00\a\x03\x00\x00\x0e\x00\x1c\x00Asia/Hong_KongUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xcbKq" + + "x\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߶\xf5" + + "8\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\xc7" + + "8\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#" + + "\x82iS\\\x91\x87\xbb\xf7\x00\x00\x00\xf7\x00\x00\x00\f\x00\x1c\x00Asia/ColomboUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\x00" + + "MX\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#\x82iS\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0e\x00\x1c\x00Asia/VientianeUT\t\x00\x03\x82\x0f\x8ba\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" + + "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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" + + "#\x82iSB\x1d\xc6\x1b\x85\x00\x00\x00\x85\x00\x00\x00\f\x00\x1c\x00Asia/KashgarUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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#\x82iS)p\x1cX\xf1\x02\x00\x00\xf1\x02\x00\x00\x10\x00\x1c\x00Asia/NovosibirskU" + + "T\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\x03" + + "z\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\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xe4_P\x18\xef\x02\x00\x00\xef\x02\x00\x00\f\x00\x1c\x00Asia/MagadanUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01" + + "\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" + + "\x00TZif2\x00\x00\x00\x00\x00\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\xc7" + + "p\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\x1d" + + "p\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#\x82iS\x8bSnT\xa1" + + "\x00\x00\x00\xa1\x00\x00\x00\x0e\x00\x1c\x00Asia/KathmanduUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00" + + "\f\x00\x1c\x00Asia/BangkokUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00B" + + "MT\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Asia/RiyadhUT\t" + + "\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSΒ\x1a\x8c\xaa\x00\x00\x00" + + "\xaa\x00\x00\x00\t\x00\x1c\x00Asia/DiliUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSL\xe0\x91y\xe5\x02\x00\x00\xe5\x02\x00" + + "\x00\x10\x00\x1c\x00Asia/KrasnoyarskUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00" + + "2r_\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\x00" + + "TK\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#\x82iS\x83g\x95M\a\x03\x00\x00\a\x03\x00\x00\r\x00\x1c\x00Asia/KhandygaUT\t\x00\x03\x82\x0f" + + "\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\x00" + + "I\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#\x82iS\x81z&\x80k\x02\x00\x00k\x02\x00\x00\x0f\x00\x1c\x00Asia/Choibalsa" + + "nUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00" + + "2M/`\x00\x00\x00\x003=.p\x00\x00\x00\x004-\x11`\x00\x00\x00\x005\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\x00" + + "D$%\x90\x00\x00\x00\x00E\x1dC\x00\x00\x00\x00\x00G\xef\xaa\xf0\x00\x00\x00\x00U\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#\x82" + + "iSw\x86\x8d^\x03\x03\x00\x00\x03\x03\x00\x00\r\x00\x1c\x00Asia/Ust-NeraUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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)\xd4" + + "\x89\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<+10>-10\nPK\x03\x04\n\x00\x00\x00\x00\x00" + + "#\x82iSe\x1bb2w\x01\x00\x00w\x01\x00\x00\x0e\x00\x1c\x00Asia/AshkhabadUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\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#\x82iS'\xe2\\\xff\x9f\x00\x00\x00\x9f\x00\x00\x00\n\x00\x1c\x00Asia/KabulUT\t" + + "\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xa1\xfax\x98g\x02\x00\x00g\x02\x00\x00\r\x00\x1c\x00Asia/QostanayUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" + + "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xcc" + + "w\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\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#\x82iS\xb2\xe27Yn\x01\x00\x00n\x01\x00\x00\r\x00\x1c\x00" + + "Asia/TashkentUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00" + + "FP\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#\x82i" + + "S*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\r\x00\x1c\x00Asia/ShanghaiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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#\x82iS\xdav\x19z\x98\x00\x00\x00\x98\x00\x00\x00\f\x00\x1c" + + "\x00Asia/BahrainUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSʇ{_\xbb\x00\x00\x00\xbb\x00\x00\x00\f\x00\x1c\x00Asia/RangoonUT\t\x00\x03" + + "\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x0eLM" + + "T\x00RMT\x00+0630\x00+09\x00\n<+0630>-6:30\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x0e\x00\x1c\x00" + + "Asia/ChungkingUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00" + + "CDT\x00CST\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS;\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\v\x00\x1c\x00Asia/TehranUT\t\x00" + + "\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x12" + + "EJ\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\x003" + + "2\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\x00A" + + "O/\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]\x86z8\x00\x00\x00\x00^u'\xc8\x00\x00\x00\x00_g\xad\xb8\x00\x00\x00\x00`W\xac\xc8\x00\x00\x00\x00a" + + "J2\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\x00o" + + "b\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+0" + + "5\x00+04\x00+0430\x00\n<+0330>-3:30<+0430>,J79/24,J263/24\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82" + + "iS\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\r\x00\x1c\x00Asia/IstanbulUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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 l" + + "U\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\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\nP" + + "K\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xed\x8c\xf1\x91\x85\x00\x00\x00\x85\x00\x00\x00\n\x00\x1c\x00Asia/DubaiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82iSb\xadű\xf8\x00\x00\x00\xf8\x00\x00\x00\f\x00\x1c\x00Asia/Jakar" + + "taUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x1cL" + + "MT\x00BMT\x00+0720\x00+0730\x00+09\x00+08\x00WIB\x00\nWIB-7\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xed\x8c\xf1\x91\x85\x00\x00\x00" + + "\x85\x00\x00\x00\v\x00\x1c\x00Asia/MuscatUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xef\\\xf4q\x17\x04\x00\x00\x17\x04\x00\x00\r\x00\x1c\x00Asia/DamascusUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" + + "\x00\x00TZif2\x00\x00\x00\x00\x00\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\xff" + + "6\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\"\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\xd6" + + "TP\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\xf5" + + "S`\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\x00E" + + "EST\x00EET\x00\nEET-2EEST,M3.5.5/0,M10.5.5/0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSO\xb0\x03\xe9\xe5\x02\x00\x00" + + "\xe5\x02\x00\x00\f\x00\x1c\x00Asia/YakutskUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x002" + + "rC\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\x00T" + + "K\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#\x82iSj$\xcd\xf4\x9a\x00\x00\x00\x9a\x00\x00\x00\f\x00\x1c\x00Asia/ThimphuUT\t\x00\x03\x82\x0f\x8ba" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" + + "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSw\rD\an\x01\x00\x00n\x01\x00\x00\x0e\x00\x1c\x00Asia/SamarkandUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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+0" + + "6\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSV\xe0\xe7!\xe7\x02\x00\x00\xe7\x02\x00\x00\v\x00\x1c\x00Asia/AnadyrUT\t\x00\x03\x82\x0f\x8b" + + "a\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" + + "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSd%\x05" + + "\xd8\xe6\x02\x00\x00\xe6\x02\x00\x00\x10\x00\x1c\x00Asia/VladivostokUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\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\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\x00" + + "M\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#\x82iSj$\xcd\xf4\x9a\x00\x00\x00\x9a\x00\x00\x00\v\x00\x1c\x00Asia/Thimbu" + + "UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS恸\x1e\x00\x01\x00\x00\x00\x01\x00\x00\x11\x00\x1c\x00Asia/Kuala_LumpurUT\t\x00\x03\x82\x0f\x8ba\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" + + "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x06\xaa>\xa8\x00\x01\x00\x00\x00\x01\x00\x00\x0e" + + "\x00\x1c\x00Asia/SingaporeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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#\x82iS[u\x99q\xf1\x02\x00\x00\xf1\x02\x00\x00\n\x00\x1c\x00Asia/TomskUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x00" + + "6\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\x00" + + "D%\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\x00bp\x01\fLMT\x00+06\x00+08\x00+07\x00\n<+07>-7\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSe\x1bb2" + + "w\x01\x00\x00w\x01\x00\x00\r\x00\x1c\x00Asia/AshgabatUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSʇ{_\xbb\x00\x00\x00\xbb\x00\x00\x00\v\x00\x1c\x00Asia/YangonUT\t\x00\x03\x82\x0f\x8ba\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" + + "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x8a\xc1\x1eB\xb7\x00\x00\x00\xb7\x00\x00\x00\x0e\x00\x1c\x00Asia/P" + + "yongyangUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x9a\xea\x18\xd4\xf8\x02\x00" + + "\x00\xf8\x02\x00\x00\x12\x00\x1c\x00Asia/YekaterinburgUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x000d" + + "uP\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\xcc" + + "\x87P\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#\x82iS\x02\xf4\xaeg\xd5\x00\x00\x00\xd5\x00\x00" + + "\x00\n\x00\x1c\x00Asia/TokyoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xb2\xb9\xf4\xb6R\x02\x00\x00R\x02\x00\x00\x10\x00\x1c\x00Asia/Ulaanbaat" + + "arUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\fL" + + "MT\x00+07\x00+09\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS9Y\xb7\xf1\n\x01\x00\x00\n\x01\x00\x00\f\x00\x1c\x00Asia/K" + + "arachiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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\nPKT-5\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xab\xcd\xdf\x05\xee\x02\x00\x00\xee\x02\x00\x00\n\x00\x1c\x00Asia/ChitaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00E" + + "C\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#\x82iS\xf0\x9cf>\xd7\x02\x00\x00" + + "\xd7\x02\x00\x00\x0e\x00\x1c\x00Asia/KamchatkaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x03R\xda\xedU\x02\x00\x00U\x02\x00\x00\f\x00\x1c\x00Asia/NicosiaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82iS`\xc9\xd4\\\xbe\x00\x00\x00\xbe\x00\x00\x00\r\x00\x1c\x00Asia/MakassarUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00" + + "\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00" + + "MMT\x00+08\x00+09\x00WITA\x00\nWITA-8\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS0]*\x1bj\x02\x00\x00j\x02\x00\x00\f\x00\x1c\x00Asia/" + + "BishkekUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00" + + "E\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#\x82iS\xd5ΜGp\x02\x00\x00p\x02\x00\x00\x0e\x00\x1c\x00Asia/QyzylordaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x00" + + "0duP\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\x00" + + "FP\x01\bLMT\x00+04\x00+05\x00+06\x00\n<+05>-5\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x02\x95-\xad\xc4\x02\x00\x00\xc4\x02\x00\x00\f\x00\x1c\x00A" + + "sia/YerevanUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0062" + + "M\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̕`\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<+04>-4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xa4Zߐ\xe6\x02\x00\x00\xe6\x02\x00\x00\x12\x00\x1c\x00Asi" + + "a/SrednekolymskUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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+\xb4" + + "k\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\xee" + + "Yp\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\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+12\x00+11\x00\n<+11" + + ">-11\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\t\x00\x1c\x00Asia/AdenUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" + + "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x0e\x00\x1c\x00Asia/" + + "ChongqingUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00C" + + "ST\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xb2\xb9\xf4\xb6R\x02\x00\x00R\x02\x00\x00\x0f\x00\x1c\x00Asia/Ulan_BatorUT\t\x00\x03" + + "\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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+\xb4" + + "z\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#\x82iS\x17✳2\x04\x00\x002\x04\x00\x00\x0e\x00\x1c\x00Asia/Jerusale" + + "mUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\x00" + + "G\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\x00IDT\x00IST\x00IDDT\x00\nIST-" + + "2IDT,M3.4.4/26,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xc7\x11\xe1[\xdc\x02\x00\x00\xdc\x02\x00\x00\v\x00\x1c\x00Asia/Be" + + "irutUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x06" + + "C\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#\x82iS`\xc9" + + "\xd4\\\xbe\x00\x00\x00\xbe\x00\x00\x00\x12\x00\x1c\x00Asia/Ujung_PandangUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\x00WIT" + + "A\x00\nWITA-8\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x9e\x88|`\x9a\x03\x00\x00\x9a\x03\x00\x00\n\x00\x1c\x00Asia/AmmanUT\t\x00\x03\x82\x0f\x8ba\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" + + "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\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\x00B" + + "MT\x00+03\x00+04\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS.>[K\xab\x00\x00\x00\xab\x00\x00\x00\r\x00\x1c\x00Asia/Jayap" + + "uraUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x0eLMT" + + "\x00+09\x00+0930\x00WIT\x00\nWIT-9\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iST\x81\x18G^\x02\x00\x00^\x02\x00\x00\n\x00\x1c\x00Asia/Aqt" + + "auUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xfc" + + "P\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#\x82iS)\x15II\xf3\x02\x00\x00\xf3\x02" + + "\x00\x00\r\x00\x1c\x00Asia/SakhalinUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\b" + + "j\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\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#\x82iS\x03\x87\xb3<\xe8\x02\x00\x00\xe8\x02\x00\x00\t\x00\x1c\x00Asia/Bak" + + "uUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00" + + "4R\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\x00" + + "BE\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\x00" + + "P\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#\x82iS&\xe9\xd1\xd8q\x02\x00\x00q\x02\x00\x00\t\x00\x1c\x00Asia/OralUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\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#\x82iS\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0f\x00\x1c\x00Asia/" + + "Phnom_PenhUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS's\x96\x1en\x01\x00\x00n\x01\x00\x00\r\x00\x1c\x00Asia/DushanbeUT\t\x00\x03\x82\x0f" + + "\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x84)\r\xbd\xec\x00\x00\x00\xec\x00\x00\x00\x10\x00\x1c\x00Asi" + + "a/Ho_Chi_MinhUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xc7X,Y\x9f\x01\x00\x00\x9f" + + "\x01\x00\x00\n\x00\x1c\x00Asia/SeoulUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x8bSnT\xa1\x00" + + "\x00\x00\xa1\x00\x00\x00\r\x00\x1c\x00Asia/KatmanduUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSS\xdd\\2a\x02\x00\x00a\x02\x00\x00\v\x00" + + "\x1c\x00Asia/AlmatyUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00" + + "3=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\x00" + + "A\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\fLMT\x00+05\x00+07\x00+06\x00\n<+06>-6\nPK\x03\x04\n\x00\x00\x00\x00\x00" + + "#\x82iSy\x19\xe0N\x9a\x00\x00\x00\x9a\x00\x00\x00\v\x00\x1c\x00Asia/BruneiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\x00" + + "ix\x00\x04\x00\x00p\x80\x00\nLMT\x00+0730\x00+08\x00\n<+08>-8\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x17✳2\x04\x00\x002\x04\x00\x00\r" + + "\x00\x1c\x00Asia/Tel_AvivUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\xd3" + + "e\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\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\x00JMT\x00IDT" + + "\x00IST\x00IDDT\x00\nIST-2IDT,M3.4.4/26,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x1d?v\f\x17\x03\x00\x00" + + "\x17\x03\x00\x00\n\x00\x1c\x00Asia/MacauUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\xe5B" + + "8\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#\x82iS\x8a\x9a\x90\xf7\xd6\x02\x00\x00\xd6\x02\x00\x00\x11\x00\x1c\x00Asia/NovokuznetskUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" + + "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Asia/KuwaitU" + + "T\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\t\x00\x1c\x00Atlantic/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82i" + + "Sm\xbd\x10k\xf1\x02\x00\x00\xf1\x02\x00\x00\x12\x00\x1c\x00Atlantic/ReykjavikUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" + + "\x00\x00\x00\x00\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\xd1" + + "\x88\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#\x82iS\xb7\x0e\xbdm\xb9\x01\x00\x00\xb9\x01" + + "\x00\x00\x0f\x00\x1c\x00Atlantic/FaeroeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\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\xc58" + + "M\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\xcfu" + + "3\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\xdaٓ@\xff\xff\xff\xff\xdbɄ@\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\v" + + "6@\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#1<+00>,M3.5.0/0,M10.5.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\u0097N\xad\xaf\x00\x00\x00\xaf\x00" + + "\x00\x00\x13\x00\x1c\x00Atlantic/Cape_VerdeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82" + + "iSl&\x04\x99\x00\x04\x00\x00\x00\x04\x00\x00\x10\x00\x1c\x00Atlantic/BermudaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\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\xb7K" + + "6\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\xd1U[`\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\xe4" + + "P\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\xe77\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\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\xfd" + + "P\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\xb0" + + "P\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,M1" + + "1.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xb7\x0e\xbdm\xb9\x01\x00\x00\xb9\x01\x00\x00\x0e\x00\x1c\x00Atlantic/FaroeUT\t\x00\x03\x82\x0f\x8ba\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" + + "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xa4" + + "X\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#\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#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x1c\x00Atlantic/St_HelenaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" + + "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xaf|7\xb3\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x1c\x00Atl" + + "antic/CanaryUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#2\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x1c\x00Australia/UT\t\x00\x03\x82\x0f\x8ba\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS?\x95\xbd\x12E\x01\x00\x00E\x01\x00\x00\x12\x00\x1c\x00Australia/Li" + + "ndemanUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\nP" + + "K\x03\x04\n\x00\x00\x00\x00\x00#\x82iS3\xba\xde\xd3!\x01\x00\x00!\x01\x00\x00\x14\x00\x1c\x00Australia/QueenslandUT\t\x00\x03\x82\x0f\x8ba\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" + + "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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\nAE" + + "ST-10\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSϻ\xca\x1a2\x01\x00\x002\x01\x00\x00\x0e\x00\x1c\x00Australia/WestUT\t\x00\x03\x82\x0f\x8ba\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" + + "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xa2ܺ\xca:\x01\x00\x00:\x01\x00\x00\x0f\x00\x1c\x00Austra" + + "lia/EuclaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00" + + "Eq\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#\x82iS\x9b\xe1\xc1\xa9\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x1c\x00Australia/VictoriaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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#\x82iSX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00\x00\x10\x00\x1c\x00Australia/SydneyUT\t" + + "\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00" + + "9\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\x00" + + "G\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\n" + + "AEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSE\xf2\xe6Z\xeb\x03\x00\x00\xeb\x03\x00\x00\x10\x00\x1c\x00A" + + "ustralia/HobartUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x03" + + "O\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\nAES" + + "T-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS3\xba\xde\xd3!\x01\x00\x00!\x01\x00\x00\x12\x00\x1c\x00Aust" + + "ralia/BrisbaneUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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#\x82iSo3\xdaR\xb4\x02\x00\x00\xb4\x02\x00\x00\x13\x00\x1c" + + "\x00Australia/Lord_HoweUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x004" + + "R\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\x00B" + + "Ex\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#\x82iSE\xf2\xe6Z\xeb\x03\x00\x00\xeb\x03\x00\x00\x10\x00\x1c\x00Australia/" + + "CurrieUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x8ff~ՙ\x03\x00\x00\x99\x03\x00\x00\x0f\x00\x1c\x00Australia/Sou" + + "thUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#\x82iSX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x1c\x00Australia/CanberraUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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#\x82iS\x8ff~ՙ\x03\x00\x00\x99\x03\x00\x00\x12\x00\x1c\x00Australia/AdelaideU" + + "T\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#\x82" + + "iS\xc8R\x1a\x1b\xea\x00\x00\x00\xea\x00\x00\x00\x0f\x00\x1c\x00Australia/NorthUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" + + "\x00\x00\x00\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#\x82iSϻ\xca\x1a2\x01\x00\x002\x01\x00\x00\x0f\x00\x1c\x00Australia/PerthUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82iS\xbd\xca#\u007f\xad\x03\x00\x00\xad\x03\x00\x00\x15\x00\x1c\x00Australia/Broken" + + "_HillUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00" + + "6\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\x00" + + "EC\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#\x82iSX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00\x00\r\x00\x1c\x00Australia/ACTUT\t" + + "\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00" + + "9\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\x00" + + "G\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\n" + + "AEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xbd\xca#\u007f\xad\x03\x00\x00\xad\x03\x00\x00\x14\x00\x1c\x00A" + + "ustralia/YancowinnaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xbc" + + "6\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\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#\x82iS\xc8R\x1a\x1b\xea\x00\x00\x00\xea\x00\x00\x00\x10\x00\x1c\x00Au" + + "stralia/DarwinUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSE\xf2\xe6Z\xeb\x03\x00\x00\xeb\x03" + + "\x00\x00\x12\x00\x1c\x00Australia/TasmaniaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xce" + + "\xa0s\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\x16" + + "8H\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\x002" + + "V\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\x00" + + "AEST\x00\nAEST-10AEDT,M10.1.0,M4.1.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x9b\xe1\xc1\xa9\x88\x03\x00\x00\x88\x03\x00" + + "\x00\x13\x00\x1c\x00Australia/MelbourneUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\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#\x82iSo3\xdaR\xb4\x02\x00\x00\xb4\x02\x00\x00\r\x00\x1c\x00Australia/LHIUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x87" + + "0h\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*\xe9" + + "k\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+11" + + "\x00\n<+1030>-10:30<+11>-11,M10.1.0,M4.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSX\xb9\x9ap\x88\x03\x00" + + "\x00\x88\x03\x00\x00\r\x00\x1c\x00Australia/NSWUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xce" + + "\x80\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#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Brazil/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x03\x04\n\x00\x00\x00\x00\x00#\x82iSa\xcb'\xe9\x9c\x01\x00\x00\x9c\x01\x00\x00\v\x00\x1c\x00Brazil/WestUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x1e" + + "x\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\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xb7-2f\xe4\x01\x00\x00\xe4\x01\x00\x00\x10\x00\x1c\x00Brazil/DeNoronhaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00" + + "\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x002\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\v\x00\x1c\x00Brazil/AcreU" + + "T\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x05" + + "z@\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#\x82iS\x9d?\xdfڸ\x03\x00\x00\xb8\x03\x00\x00\v\x00\x1c\x00Brazi" + + "l/EastUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\t" + + "0\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\xc8" + + "\xa0\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\x80y" + + "0\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\x00N\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#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Cana" + + "da/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS{\a\a\xdc\xca\x03\x00\x00\xca\x03\x00\x00\x0f\x00\x1c" + + "\x00Canada/MountainUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00E" + + "D_\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#\x82iS~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x13\x00\x1c\x00Canada/NewfoundlandUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" + + "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xcf" + + "b\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\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\xf5O" + + "cX\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\x89" + + "P\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-\x9e" + + "8t\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;\xdb" + + "m\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\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\x00NDD" + + "T\x00\nNST3:30NDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS):\x17-\x88\x06\x00\x00\x88\x06\x00\x00\x0f\x00\x1c\x00C" + + "anada/AtlanticUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x80" + + "0\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\"\x1b" + + "P\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\xce" + + "P\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\x00AS" + + "T\x00AWT\x00APT\x00\nAST4ADT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xc1Ȇ\x90\x05\x04\x00\x00\x05\x04\x00\x00" + + "\f\x00\x1c\x00Canada/YukonUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x14" + + "YU\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\x8f\xd0p\x00\x00\x00\x00?\x9bb\xe0\x00\x00\x00\x00@o\xb2p\x00\x00\x00\x00A\x84\u007f`\x00\x00\x00\x00" + + "BO\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\x10LM" + + "T\x00EDT\x00EST\x00EWT\x00EPT\x00\nEST5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSU9#\xbe" + + "2\x05\x00\x002\x05\x00\x00\x0e\x00\x1c\x00Canada/PacificUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xce" + + "\x90\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#\x82iS?_p\x99\x0e\x05\x00\x00\x0e\x05\x00\x00\x0e\x00\x1c\x00Canada/CentralUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" + + "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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" + + "#\x82iS\u0096dK~\x02\x00\x00~\x02\x00\x00\x13\x00\x1c\x00Canada/SaskatchewanUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x0e" + + "0p\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\nCST6\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xe6" + + "\x9aM\xbem\x02\x00\x00m\x02\x00\x00\x03\x00\x1c\x00CETUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#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\x03" + + "0\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\xcc" + + "0\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\xaa" + + "0\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\x00S" + + "MT\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#\x82" + + "iS\xee\xd0\x1cYN\x04\x00\x00N\x04\x00\x00\x12\x00\x1c\x00Chile/EasterIslandUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\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\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\x03\x02\x03\x02\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\x99" + + "x\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#\x82iS<\x8b\x99\x1e\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x1c\x00CST6" + + "CDTUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\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\nC" + + "ST6CDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\a\x1c\x9e\x9a]\x04\x00\x00]\x04\x00\x00\x04\x00\x1c\x00CubaUT\t\x00" + + "\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xca" + + "\xbcm\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\nCST5CDT,M3.2.0/0,M11.1.0/1" + + "\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS`l\x8d~\xf1\x01\x00\x00\xf1\x01\x00\x00\x03\x00\x1c\x00EETUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\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#\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\xe0\x00\x00\x00\x00E\x12\xfd" + + "P\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" + + "\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#\x82iS\x9a\v\xf9/\xd8\x05\x00\x00" + + "\xd8\x05\x00\x00\x04\x00\x1c\x00EireUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xd4" + + "I\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\xe2" + + "kt \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\x03" + + "p\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\x11" + + "Q\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\x00" + + "BST\x00GMT\x00\nIST-1GMT0,M10.5.0,M3.5.0/1\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iStX\xbe\xe4o\x00\x00\x00o\x00" + + "\x00\x00\x03\x00\x1c\x00ESTUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xe7/\xebT\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x1c\x00ES" + + "T5EDTUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\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#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x1c\x00Etc/UT" + + "\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xb2\xab\xd1Is\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/" + + "GMT-11UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xa9{\xa2qq\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00E" + + "tc/GMT+2UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\a\x00\x1c\x00E" + + "tc/UCTUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xf7\x1ac\xc3r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/G" + + "MT-1UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x1c\x00Etc/" + + "GMT+0UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\"\xf8\x8f/q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GM" + + "T+8UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xd4X\x9b\xf3q\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GM" + + "T+5UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\b\x00\x1c\x00Etc/Zu" + + "luUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSJ0p-r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GMT-7" + + "UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xd0\xfaFDq\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Etc/GMT+" + + "4UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xf7\x19s\x81s\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/GMT-" + + "12UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\r\x00\x1c\x00Etc/U" + + "niversalUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x9c\xfcm\x99r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc" + + "/GMT-3UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\a\x00\x1c\x00Et" + + "c/GMTUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xfc\x19@\xb9r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Etc/GM" + + "T-9UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xd9|\xbd7s\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00Etc/G" + + "MT-10UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x84\x19\xb3\tq\x00\x00\x00q\x00\x00\x00\t\x00\x1c\x00Et" + + "c/GMT+9UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS!\xd6~wr\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00Et" + + "c/GMT-5UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSj\xd5d\xb0r\x00\x00\x00r\x00\x00\x00\t\x00\x1c\x00E" + + "tc/GMT-6UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x90`N\xe8s\x00\x00\x00s\x00\x00\x00\n\x00\x1c\x00" + + "Etc/GMT-13UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\r" + + "\x00\x1c\x00Etc/GreenwichUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS5\xb8\xe8\x86q\x00\x00\x00q\x00\x00" + + "\x00\t\x00\x1c\x00Etc/GMT+1UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSe\xcb\xe9Qq\x00\x00\x00q\x00\x00" + + "\x00\t\x00\x1c\x00Etc/GMT+3UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00" + + "\x00\a\x00\x1c\x00Etc/UTCUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x8e\x1569r\x00\x00\x00r\x00\x00\x00\n\x00\x1c" + + "\x00Etc/GMT+10UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t" + + "\x00\x1c\x00Etc/GMT-0UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x84+\x9a$q\x00\x00\x00q\x00\x00\x00\t\x00\x1c" + + "\x00Etc/GMT+7UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xe5\xf38cr\x00\x00\x00r\x00\x00\x00\n\x00\x1c" + + "\x00Etc/GMT+12UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSH\x9b\xd1\x04q\x00\x00\x00q\x00\x00\x00\t" + + "\x00\x1c\x00Etc/GMT+6UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xc5\x18\xb6\xfbr\x00\x00\x00r\x00\x00\x00\t" + + "\x00\x1c\x00Etc/GMT-8UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS)\xb9\xbe\x9dr\x00\x00\x00r\x00\x00\x00" + + "\n\x00\x1c\x00Etc/GMT+11UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS,{\xdc;s\x00\x00\x00s\x00" + + "\x00\x00\n\x00\x1c\x00Etc/GMT-14UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSP\xda\xfa\x03o\x00\x00" + + "\x00o\x00\x00\x00\b\x00\x1c\x00Etc/GMT0UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSk\x19-4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xbc\x19y\x04r\x00\x00\x00r" + + "\x00\x00\x00\t\x00\x1c\x00Etc/GMT-2UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\a\x00\x1c\x00Europe/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x9a\v\xf9" + + "/\xd8\x05\x00\x00\xd8\x05\x00\x00\r\x00\x1c\x00Europe/DublinUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xd6" + + "\xa0\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\xcc" + + "\xa0\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\xde" + + "\xa0\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" + + "#\x82iSk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x0e\x00\x1c\x00Europe/BelfastUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\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\xd3" + + "\xa0\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\xcc" + + "\xa0\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\xde" + + "\xa0\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\x04LM" + + "T\x00BST\x00GMT\x00BDST\x00\nGMT0BST,M3.5.0/1,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSDd#\xc4\xf1" + + "\x01\x00\x00\xf1\x01\x00\x00\x0f\x00\x1c\x00Europe/BusingenUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\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\x00" + + "G\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\bLMT\x00+03\x00+" + + "04\x00+05\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSDd#\xc4\xf1\x01\x00\x00\xf1\x01\x00\x00\r\x00\x1c\x00Europe/ZurichU" + + "T\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\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\nP" + + "K\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x90\xa9\xf5ϕ\x02\x00\x00\x95\x02\x00\x00\x10\x00\x1c\x00Europe/BucharestUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" + + "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#\x82iS\x95\xb4\x9e\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\x0e\x00\x1c\x00Europe/VaticanUT" + + "\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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.W" + + "p\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#\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" + + "\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\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#\x82iSZk#V\x81\x03\x00\x00\x81\x03\x00\x00\r\x00\x1c\x00Europe/MadridUT\t\x00" + + "\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#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#\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\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" + - "#(\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#\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#\x82iSߜvυ\x01\x00\x00\x85\x01\x00\x00\x0e\x00\x1c\x00Europe/AndorraUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" + + "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\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#\x82iS\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\x0f\x00\x1c\x00Europe/IstanbulUT" + + "\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x86%p\x00\x00\x00\x00?\x9b\x00p\x00\x00\x00\x00@f\a" + + "p\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\x00" + + "EEST\x00EET\x00+03\x00+04\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSO+j\x94\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x1c\x00Euro" + + "pe/KaliningradUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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" + + "\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\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#\x82iS" + + "WI\xc3\u007f(\x03\x00\x00(\x03\x00\x00\f\x00\x1c\x00Europe/MinskUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\x00CES" + + "T\x00MSD\x00EEST\x00+03\x00\n<+03>-3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x1b8\xfel\xd6\x02\x00\x00\xd6\x02\x00\x00\x0e\x00\x1c\x00Europe" + + "/SaratovUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82iS\x92\xfc\f+" + + "o\x02\x00\x00o\x02\x00\x00\x11\x00\x1c\x00Europe/CopenhagenUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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#\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#\x82iS\x95\xb4\x9e" + + "\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\v\x00\x1c\x00Europe/RomeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xa3" + + "L\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\xf9" + + "3\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#" + "(\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#\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#\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\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#\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#(\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#\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#\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#\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\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#\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#\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\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#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\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" + + "]\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\x00RM" + + "T\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSN\xa5\xa5\xcb\x12\x02\x00" + + "\x00\x12\x02\x00\x00\x0f\x00\x1c\x00Europe/UzhgorodUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00M" + + "SK\x00EET\x00EEST\x00\nEET-2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSgp\xc0\xa7" + + "\xb6\x02\x00\x00\xb6\x02\x00\x00\v\x00\x1c\x00Europe/RigaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + - "\x00\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\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 l" + + "U\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\x00EEST\x00\nEET-" + + "2EEST,M3.5.0/3,M10.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xe1\xc1\xeb\x05\x8c\x03\x00\x00\x8c\x03\x00\x00\r\x00\x1c\x00Europ" + + "e/MoscowUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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\x15L" + + "MT\x00MMT\x00MST\x00MDST\x00MSD\x00MSK\x00+05\x00EET\x00EEST\x00\nMSK-3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x17S" + + "\x91\xb3\xc1\x02\x00\x00\xc1\x02\x00\x00\r\x00\x1c\x00Europe/BerlinUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\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\xd9" + + "\xae\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\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#\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\x00C" + + "EST\x00MSD\x00EEST\x00\nMSK-3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSIo\x11{\xd3\x02\x00\x00\xd3\x02\x00\x00\r\x00\x1c\x00Europe/Pra" + + "gueUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\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\x00" + + "EET\x00CET\x00CEST\x00MSD\x00MSK\x00\nEET-2EEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00#" + + "\x82iS>\xfe垛\x03\x00\x00\x9b\x03\x00\x00\r\x00\x1c\x00Europe/WarsawUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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#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" + + "10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x0f\x00\x1c\x00Europe/GuernseyUT\t\x00\x03\x82\x0f\x8b" + + "a\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" + + "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xb6" + + "0\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\xc4" + + "Q\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\xd2" + + "i\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\xde" + + "\xb4\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\nP" + + "K\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x03R\xda\xedU\x02\x00\x00U\x02\x00\x00\x0e\x00\x1c\x00Europe/NicosiaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" + + "\x00\x00TZif2\x00\x00\x00\x00\x00\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,M1" + + "0.5.0/4\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xc9\a\xa0\xe1/\x04\x00\x00/\x04\x00\x00\x10\x00\x1c\x00Europe/AmsterdamUT\t\x00\x03\x82" + + "\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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#\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#\x82iS\xea\xc48\xde\\\x02\x00\x00\\\x02\x00" + + "\x00\r\x00\x1c\x00Europe/TiraneUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#\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\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\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\xcd" + + "\xa9\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#" + + "\x82iSI\xb8\xbc\xd3\xf3\x02\x00\x00\xf3\x02\x00\x00\x0f\x00\x1c\x00Europe/TiraspolUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\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\x00MSK\x00\nEET-2EEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSh\xa5J[\xa0\x03\x00\x00\xa0" + + "\x03\x00\x00\f\x00\x1c\x00Europe/MaltaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#(\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\xfe" + + "p\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\x9cZ" + + "p\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\x1a" + + "p\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#\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\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" + + ",\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\t" + + "LMT\x00CEST\x00CET\x00\nCET-1CEST,M3.5.0,M10.5.0/3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xab\x80c$q" + + "\x00\x00\x00q\x00\x00\x00\a\x00\x1c\x00FactoryUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSk\xa4,\xb6?\x06\x00" + + "\x00?\x06\x00\x00\x02\x00\x1c\x00GBUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xc7" + + "l \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\xf1a" + + "I\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 l" + + "r\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#\x82iSk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\a\x00\x1c\x00GB-EireUT\t\x00\x03" + + "\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xa7" + + "N \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\xdb" + + "W \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\xf3J" + + "f \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\"L" + + "T\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#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00GMTUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x05\x00\x1c\x00GMT+0UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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#\x82" + + "iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x05\x00\x1c\x00GMT-0UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\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#\x82iSP\xda\xfa\x03" + + "o\x00\x00\x00o\x00\x00\x00\x04\x00\x1c\x00GMT0UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00" + + "\x00\t\x00\x1c\x00GreenwichUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSE\t\xfa-\a\x03\x00\x00\a\x03\x00\x00\b" + + "\x00\x1c\x00HongkongUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xbe" + + "A\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\xd6" + + "\xa98\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#\x82iS=\xf7\xfawp\x00\x00\x00p\x00\x00\x00" + + "\x03\x00\x1c\x00HSTUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iSm\xbd\x10k\xf1\x02\x00\x00\xf1\x02\x00\x00\a\x00\x1c\x00Ice" + + "landUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\xd1" + + "K\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\xdf" + + "\xae\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\n" + + "GMT0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x1c\x00Indian/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01" + + "\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSͲ\xfb\xf6\x8c\x00\x00\x00\x8c\x00\x00\x00\f\x00\x1c\x00Indian/CocosUT\t\x00\x03\x82\x0f\x8b" + + "a\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" + + "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xb4\x8d\x98ƿ\x00" + + "\x00\x00\xbf\x00\x00\x00\x13\x00\x1c\x00Indian/AntananarivoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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#\x82iSx\xb0W\x14\x98\x00\x00\x00\x98\x00\x00\x00\r\x00\x1c\x00Indian/ChagosUT\t\x00\x03\x82\x0f\x8ba" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" + + "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0e\x00\x1c\x00Indian/MayotteUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\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#\x82iS$l=҅\x00\x00\x00\x85\x00\x00\x00\x10\x00\x1c\x00Indian/Christmas" + + "UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xb9\xb2Z\xac\x98" + + "\x00\x00\x00\x98\x00\x00\x00\x0f\x00\x1c\x00Indian/MaldivesUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\r\x00\x1c\x00Indi" + + "an/ComoroUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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#\x82" + + "iS\x96\xed=\x98\xb3\x00\x00\x00\xb3\x00\x00\x00\x10\x00\x1c\x00Indian/MauritiusUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\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\xdbr" + + "0\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#\x82iSa\x85jo\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x1c\x00Indian/MaheUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01" + + "\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xb8K\xabυ\x00\x00\x00\x85\x00\x00\x00\x10\x00\x1c\x00Indian/" + + "KerguelenUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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" + + "#\x82iSy(\xb6\x8f\x85\x00\x00\x00\x85\x00\x00\x00\x0e\x00\x1c\x00Indian/ReunionUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS;\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\x04\x00\x1c\x00IranUT\t\x00\x03\x82\x0f\x8ba\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" + + "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x00" + + "4%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\x00" + + "B?.\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\x00" + + "T\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\x00" + + "b8\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\x00" + + "pU 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#\x82iS\x17✳2" + + "\x04\x00\x002\x04\x00\x00\x06\x00\x1c\x00IsraelUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\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\x00ID" + + "T\x00IST\x00IDDT\x00\nIST-2IDT,M3.4.4/26,M10.5.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS%J\xd5\xebS\x01\x00" + + "\x00S\x01\x00\x00\a\x00\x1c\x00JamaicaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x02\xf4\xaeg\xd5\x00\x00\x00\xd5\x00\x00\x00\x05\x00\x1c\x00JapanUT" + + "\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\nP" + + "K\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xf6\xe8]*\xdb\x00\x00\x00\xdb\x00\x00\x00\t\x00\x1c\x00KwajaleinUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82iS_" + + "\u007f2[\xaf\x01\x00\x00\xaf\x01\x00\x00\x05\x00\x1c\x00LibyaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\nP" + + "K\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xfe\x9d\x1b\xc9m\x02\x00\x00m\x02\x00\x00\x03\x00\x1c\x00METUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\xcf" + + "\x924\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#\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#\x82iS\xf5\x8d\x99\x92o\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00MSTUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\x9d\x90\x00\x00MST\x00\nMST7\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xe6h\xcac\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x1c\x00MST7MDTUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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#\x82iSV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x06\x00\x1c\x00NavajoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\x03" + + "q\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\nM" + + "ST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x02\x00\x1c\x00NZUT\t\x00\x03\x82" + + "\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xa9" + + "h\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#\x82iS\x96" + + "\xc5FF(\x03\x00\x00(\x03\x00\x00\a\x00\x1c\x00NZ-CHATUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x1c\x00Pacific/UT\t\x00" + + "\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x91\xd60\f\x9a\x00\x00\x00\x9a\x00\x00\x00\f\x00\x1c\x00Pacifi" + + "c/NiueUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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ߡjL\xff\xff\xff\xff\xf5\xa6\xb8`\x01\x02\xff\xff`\xb4\x00\x00\xff\xff`\xa0\x00\x04\xff\xffeP\x00\nLMT\x00-1120\x00-11\x00\n" + + "<-11>11\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\x0e\x00\x1c\x00Pacific/MidwayUT\t\x00\x03\x82\x0f\x8b" + + "a\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" + + "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS" + + "\x80\xf8vܔ\x00\x00\x00\x94\x00\x00\x00\r\x00\x1c\x00Pacific/PalauUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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#\x82iS\x97F\x91\xb3\xed\x00\x00\x00\xed\x00\x00\x00\x11\x00\x1c\x00Pacif" + + "ic/TongatapuUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xd2E\x9c@\xff\xff\xff\xff\xef\x11\xe0\x10\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-13\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xec =\x89\xac\x00\x00\x00\xac" + + "\x00\x00\x00\x11\x00\x1c\x00Pacific/EnderburyUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xc3,ۀ\x00\x00\x00\x00\x12V\x04\xc0\x00\x00\x00\x00/\x059\xb0\x01\x02\x03\x00\x00\x00\x00\x00\x00" + + "\xff\xffW@\x00\x04\xff\xffeP\x00\b\x00\x00\xb6\xd0\x00\f-00\x00-12\x00-11\x00+13\x00\n<+13>-13\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x9e\u007f" + + "\xab\x95V\x01\x00\x00V\x01\x00\x00\r\x00\x1c\x00Pacific/EfateUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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'\xeb" + + "C@\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#\x82iS\x8a|\xdcU\x99\x00\x00\x00\x99" + + "\x00\x00\x00\x0f\x00\x1c\x00Pacific/FakaofoUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xea\xc1\xdaυ\x00\x00\x00\x85\x00\x00\x00\x0e\x00\x1c\x00Pacific" + + "/TahitiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82" + + "iS߃\xa0_\x86\x00\x00\x00\x86\x00\x00\x00\f\x00\x1c\x00Pacific/WakeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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~6\x18\xcc\x01\x00\x00\x9c4\x00\x00\x00\x00\xa8\xc0\x00\x04LMT\x00+1" + + "2\x00\n<+12>-12\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\x11\x00\x1c\x00Pacific/Pago_PagoU" + + "T\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSa\vೆ\x00\x00\x00\x86\x00\x00\x00\x10\x00\x1c\x00Pacific/FunafutiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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~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#\x82iS6\xb7S{\x86\x00\x00\x00\x86\x00\x00\x00\x0e\x00\x1c\x00Pacific/T" + + "arawaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82i" + + "S\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\v\x00\x1c\x00Pacific/YapUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\xa0" + + "9\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#\x82iS\xb7\xef\x97\xc6\xc6\x00\x00\x00\xc6\x00\x00\x00\x0e\x00\x1c\x00Pacific/NoumeaUT\t\x00\x03" + + "\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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" + + "\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#\x82iSD6\x83\xa1\x8b" + + "\x00\x00\x00\x8b\x00\x00\x00\x11\x00\x1c\x00Pacific/MarquesasUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\n\xff\xff\xff\xff\x94PLH\x01\xff\xff}8\x00\x00\xff\xffzh\x00\x04LMT\x00-093" + + "0\x00\n<-0930>9:30\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSY5\x1a6\xf7\x00\x00\x00\xf7\x00\x00\x00\x0f\x00\x1c\x00Pacific/Norfolk" + + "UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x9d" + + "x\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#\x82iSY\xd2K|\x86\x00\x00\x00\x86\x00\x00" + + "\x00\x13\x00\x1c\x00Pacific/GuadalcanalUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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\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\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\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<+1" + + "1>-11\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x1c\x00Pacific/JohnstonUT\t\x00\x03\x82\x0f\x8b" + + "a\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" + + "\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xff" + + "l\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#\x82iS\u07b54-\xd6\x00\x00\x00\xd6\x00\x00\x00\x0e\x00\x1c\x00Pacific/PonapeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00" + + "\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x94" + + "T\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#\x82i" + + "S\xe2;Z\xf7\xb7\x00\x00\x00\xb7\x00\x00\x00\r\x00\x1c\x00Pacific/NauruUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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#\x82iSFI\xfe\x14^\x01\x00\x00^\x01\x00\x00\f\x00\x1c\x00Pacific/GuamUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00" + + "\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\r\x00\x1c\x00Pacific/SamoaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00" + + "\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x81\xe3w\n\xaf\x00\x00\x00" + + "\xaf\x00\x00\x00\x11\x00\x1c\x00Pacific/GalapagosUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82" + + "iS\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x1c\x00Pacific/HonoluluUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00" + + "\x00\x00\x00\x00\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!q" + + "X\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\xff" + + "zh\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#\x82iS\x97n7" + + "\x1a\xf2\x00\x00\x00\xf2\x00\x00\x00\x0e\x00\x1c\x00Pacific/KosraeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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\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\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-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\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" + - "\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#\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\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\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\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#\x82iS\xc23\xa0\xbc\x84\x00\x00\x00\x84\x00\x00\x00\x0f\x00\x1c\x00Pacific/GambierUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01" + + "\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xfa\x0fA\x05\x99\x00\x00\x00\x99\x00\x00\x00\x10\x00\x1c\x00Pacific/" + + "PitcairnUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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#\x82iScF/.\xac\x01\x00\x00\xac\x01\x00\x00\f\x00\x1c\x00Pacific/FijiUT\t\x00\x03\x82\x0f\x8ba" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\x1e\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`\x00\x00\x00\x00co\xa6\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\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#\x82iS\xec =\x89\xac\x00\x00\x00\xac\x00\x00\x00\x0e\x00\x1c\x00Pac" + + "ific/KantonUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xc3,ۀ\x00\x00\x00\x00\x12V\x04\xc0\x00\x00\x00\x00/\x059\xb0\x01\x02\x03\x00\x00\x00\x00\x00\x00\xff\xffW@\x00\x04\xff\xffeP\x00\b\x00" + + "\x00\xb6\xd0\x00\f-00\x00-12\x00-11\x00+13\x00\n<+13>-13\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\u07b54-\xd6\x00\x00\x00\xd6\x00\x00\x00\x0f\x00\x1c" + + "\x00Pacific/PohnpeiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\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" + + "\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#\x82iS\x9a\xf2:F\xc9\x00\x00\x00\xc9\x00\x00\x00\x14\x00\x1c\x00Pacific/Boug" + + "ainvilleUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xca\"\xb8i\xda\x00\x00\x00\xda\x00\x00\x00\x0e\x00\x1c\x00Pacific/MajuroUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82i" + + "Sb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x10\x00\x1c\x00Pacific/AucklandUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\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#\x82iS\xf6\xe8]*\xdb\x00\x00\x00\xdb\x00\x00\x00\x11\x00\x1c\x00Pacifi" + + "c/KwajaleinUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iSn\x04\x19y\x9a\x00\x00\x00\x9a\x00\x00\x00\x14\x00\x1c\x00Pacific/Port" + + "_MoresbyUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\r\x00\x1c\x00Pacific/ChuukUT\t\x00\x03\x82\x0f" + + "\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xcc\xf39a\xc3\x00\x00\x00\xc3\x00" + + "\x00\x00\f\x00\x1c\x00Pacific/TrukUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\xc8=ku\xae\x00\x00\x00\xae\x00\x00\x00\x12\x00\x1c\x00Pacific/KiritimatiUT\t\x00\x03\x82\x0f\x8ba\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" + + "\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS1\xce_(\x86\x00\x00\x00\x86\x00\x00\x00\x0e\x00\x1c\x00Pacific/WallisUT\t\x00\x03" + + "\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x96\xc5FF(\x03\x00\x00(" + + "\x03\x00\x00\x0f\x00\x1c\x00Pacific/ChathamUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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#\x82iSFI\xfe\x14^\x01\x00\x00^\x01\x00\x00\x0e\x00\x1c\x00Pacific/Saip" + + "anUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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+0" + + "9\x00GDT\x00ChST\x00\nChST-10\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xee\xd0\x1cYN\x04\x00\x00N\x04\x00\x00\x0e\x00\x1c\x00Pacific/Ea" + + "sterUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\x01" + + "uP\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\x0f" + + "h\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\x03\x02\x03\x02\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#\x82iS\xa8A\x15\xfe\x97\x01\x00\x00\x97\x01\x00\x00\f\x00\x1c\x00Pacific/ApiaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1a\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\xda" + + "b\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\x00\x00\x00\x00Pf\xfe\xe0\x00\x00\x00\x00Q`*`\x00" + + "\x00\x00\x00RF\xe0\xe0\x00\x00\x00\x00S@\f`\x00\x00\x00\x00T&\xc2\xe0\x00\x00\x00\x00U\x1f\xee`\x00\x00\x00\x00V\x06\xa4\xe0\x00\x00\x00\x00V\xff\xd0`\x00\x00\x00\x00W\xe6\x86\xe0\x00\x00\x00\x00X" + + "߲`\x00\x00\x00\x00Y\xc6h\xe0\x00\x00\x00\x00Z\xbf\x94`\x00\x00\x00\x00[\xaf\x85`\x00\x00\x00\x00\\\xa8\xb0\xe0\x00\x00\x00\x00]\x8fg`\x00\x00\x00\x00^\x88\x92\xe0\x00\x00\x00\x00_oI`\x00" + + "\x00\x00\x00`ht\xe0\x01\x02\x04\x03\x04\x03\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x06\x05\x00\x00\xb0\x80\x00\x00\xff\xff_\x00\x00\x00\xff\xff^H\x00\x04\xff\xffs`\x01\n\xff\xffe" + + "P\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\nPK\x03\x04\n\x00\x00\x00\x00" + + "\x00#\x82iS\x1c\xe3\xa3S\x96\x01\x00\x00\x96\x01\x00\x00\x11\x00\x1c\x00Pacific/RarotongaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x1c\x00\x00\x00\x05\x00\x00\x00\x14\xff\xff\xff\xff|L\xdc\xc8\xff\xff\xff\xffߡ`\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\xe8\x95" + + "\x98\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\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\x00\x00\xbb\xb8\x00\x00\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#\x82iS>\xfe垛\x03\x00\x00\x9b\x03\x00\x00\x06\x00\x1c\x00PolandUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\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\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\xd2" + + "\x8a\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\x12" + + "T\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#\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\x00CD" + + "T\x00CST\x00\nCST-8\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iSŭV\xad\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x1c\x00PST8PDTUT\t\x00\x03\x82\x0f\x8ba\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00" + + "\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\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#\x82iS\xee\xf0BB\xff\x01\x00\x00\xff\x01\x00\x00\x03\x00\x1c\x00ROCUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01" + + "\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00" + + "\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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ߵd" + + "p\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#\x82iS\xc7X,Y\x9f" + + "\x01\x00\x00\x9f\x01\x00\x00\x03\x00\x1c\x00ROKUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x06\xaa>\xa8\x00\x01\x00\x00\x00" + + "\x01\x00\x00\t\x00\x1c\x00SingaporeUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\x1cLMT\x00SMT\x00+07\x00+0720\x00+0730\x00+09\x00+08\x00\n<+08>-8\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\x06\x00\x1c\x00TurkeyUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" + + "\x00\x00\x00\x00\x00\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\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\x00C" + + "c\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\x00Q" + + "W\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#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00UCTUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x01\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00UTC\x00\nUTC0\nPK\x03\x04" + + "\n\x00\x00\x00\x00\x00#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\t\x00\x1c\x00UniversalUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x1c\x00US/UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x03\x04\n" + + "\x00\x00\x00\x00\x00#\x82iSV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\v\x00\x1c\x00US/MountainUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2" + + "\x00\x00\x00\x00\x00\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\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\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\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" + - "\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\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#\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\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\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" + "\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\x00MP" + + "T\x00\nMST7MDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS5\x11Q\x06\xd1\x03\x00\x00\xd1\x03\x00\x00\t\x00\x1c\x00US/A" + + "laskaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00" + + "62\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\x00" + + "D/\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\x00" + + "AHST\x00AHDT\x00YST\x00AKDT\x00AKST\x00\nAKST9AKDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00" + + "#\x82iSp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x0f\x00\x1c\x00US/East-IndianaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\v\x00\x1c\x00US/AleutianUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00" + + "\x00\x00\x00\x00\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\x00NPT\x00BST\x00BDT\x00AHST\x00HDT\x00\nHST10HDT,M3." + + "2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\t\x00\x1c\x00US/HawaiiUT\t\x00\x03\x82\x0f\x8ba" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" + + "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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\xe0" + + "p\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\n" + + "PK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS3\x9aG\xc8\xd0\x06\x00\x00\xd0\x06\x00\x00\n\x00\x1c\x00US/EasternUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xa6" + + "S\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\xb4" + + "G,`\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\xc2" + + "\x84}\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\xd5" + + "U\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\xe3" + + "I(`\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\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#\x82iS>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\v\x00\x1c\x00US/MichiganUT\t\x00\x03\x82\x0f" + + "\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\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\x00" + + "4R\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\x00" + + "BO\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\nEST" + + "5EDT,M3.2.0,M11.1.0\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\xf6\"\x12\xfe\x0e\x05\x00\x00\x0e\x05\x00\x00\n\x00\x1c\x00US/Pacific" + + "UT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xde" + + "\xbe\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\x003" + + "Gt \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#\x82iSt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\b\x00\x1c\x00US/SamoaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\x82iSø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00" + + "\n\x00\x1c\x00US/ArizonaUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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#\x82iS\x9bܩ=" + + "\xda\x06\x00\x00\xda\x06\x00\x00\n\x00\x1c\x00US/CentralUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\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'\x1c" + + "p\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\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#\x82iS$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x11\x00\x1c\x00US/Indiana-StarkeUT\t\x00\x03\x82\x0f\x8ba" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00" + + "\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x03\x00\x1c\x00UTCUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01" + + "\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS2\x91B\xc0\xee\x01\x00\x00\xee\x01\x00\x00\x03\x00\x1c\x00WETUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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#\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\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\x00E" + + "C\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\x00M" + + "DST\x00MSD\x00MSK\x00+05\x00EET\x00EEST\x00\nMSK-3\nPK\x03\x04\n\x00\x00\x00\x00\x00#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x04\x00" + + "\x1c\x00ZuluUT\t\x00\x03\x82\x0f\x8ba\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00TZif2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x10\x00\xe8A\x00\x00\x00\x00Africa/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS \x1b" + + "\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81A\x00\x00\x00Africa/GaboroneUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\r\x01\x00\x00Africa/" + + "DakarUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xaa\x81\t\x03\xa0\x00\x00\x00\xa0\x00\x00\x00\x0f\x00\x18" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd5\x01\x00\x00Africa/NdjamenaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03" + + "\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xbe\x02\x00\x00Africa/AbidjanUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "\x88\x03\x00\x00Africa/HarareUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{" + + "\x87\x82\x00\x00\x00\x82\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81R\x04\x00\x00Africa/OuagadougouUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSd\x01\x05\x89\u007f\a\x00\x00\u007f\a\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81 \x05\x00\x00Afric" + + "a/CasablancaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00" + + "\xbf\x00\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xea\f\x00\x00Africa/Dar_es_SalaamUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf7\r\x00\x00Africa/P" + + "orto-NovoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00" + + "\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf6\x0e\x00\x00Africa/KinshasaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK" + + "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf3\x0f\x00\x00Africa/Brazzavil" + + "leUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x10\x00\x18\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\xa0\x81\xf3\x10\x00\x00Africa/MogadishuUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00" + + "\x00\x00\x00\x00#\x82iS\xc1\n\x8a\x84\xad\x00\x00\x00\xad\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xfc\x11\x00\x00Africa/Sao_TomeUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf2" + + "\x12\x00\x00Africa/JohannesburgUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82" + + "iSm)\xb8P~\x02\x00\x00~\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xfd\x13\x00\x00Africa/WindhoekUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc4\x16\x00\x00Afr" + + "ica/NiameyUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00" + + "\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xbf\x17\x00\x00Africa/NairobiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK" + + "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS)\xae\x8eo&\a\x00\x00&\a\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc6\x18\x00\x00Africa/El_AaiunU" + + "T\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\xa0\x815 \x00\x00Africa/LusakaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82" + + "iS\x93\xf4\x94\v\xc1\x01\x00\x00\xc1\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xff \x00\x00Africa/TunisUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xcc\fTξ\x00\x00\x00\xbe\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x06#\x00\x00Africa" + + "/MaseruUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\v" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\v$\x00\x00Africa/LomeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00" + + "\x00\x00\x00\x00#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd2$\x00\x00Africa/DoualaUT\x05\x00\x03\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xcd%\x00" + + "\x00Africa/BujumburaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSV\xadD" + + "\xef\xca\x01\x00\x00\xca\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9a&\x00\x00Africa/KhartoumUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xad(\x00\x00Africa/A" + + "smaraUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0e\x00\x18" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb3)\x00\x00Africa/ConakryUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n" + + "\x00\x00\x00\x00\x00#\x82iSÊ\x0e\xc0\xd6\x01\x00\x00\xd6\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81}*\x00\x00Africa/AlgiersUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9b" + + ",\x00\x00Africa/BanguiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa7\x1d\xb3c" + + "\xb4\x00\x00\x00\xb4\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x96-\x00\x00Africa/LibrevilleUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x14\xcf\x10n\xca\x01\x00\x00\xca\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x95.\x00\x00Africa/" + + "JubaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS6\x99rU\xa4\x00\x00\x00\xa4\x00\x00\x00\x0f\x00\x18\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa40\x00\x00Africa/MonroviaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n" + + "\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x911\x00\x00Africa/DjiboutiUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "\x992\x00\x00Africa/TimbuktuUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa7" + + "\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81d3\x00\x00Africa/MalaboUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81_4\x00\x00Africa/F" + + "reetownUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\r" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81*5\x00\x00Africa/BanjulUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03" + + "\n\x00\x00\x00\x00\x00#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf35\x00\x00Africa/KigaliUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xca>\xd5\xe0\x95\x00\x00\x00\x95\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xbd" + + "6\x00\x00Africa/BissauUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xcc\fT\xce" + + "\xbe\x00\x00\x00\xbe\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x997\x00\x00Africa/MbabaneUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9f\x1b\xeb\xdd2\x02\x00\x002\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9f8\x00\x00Africa/Ceu" + + "taUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x0f\x00\x18\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\xa0\x81\x17;\x00\x00Africa/BlantyreUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00" + + "\x00\x00\x00#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe3;\x00\x00Africa/MaputoUT\x05\x00\x03\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xad<\x00\x00" + + "Africa/BamakoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa7\x1d\xb3c\xb4\x00\x00" + + "\x00\xb4\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81v=\x00\x00Africa/LagosUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81p>\x00\x00Africa/AsmeraUT" + + "\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\xa0\x81v?\x00\x00Africa/AccraUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS" + + "\xa7\x1d\xb3c\xb4\x00\x00\x00\xb4\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81>@\x00\x00Africa/LuandaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS \x1b\xb0_\x83\x00\x00\x00\x83\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x819A\x00\x00Africa/" + + "LubumbashiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00" + + "\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\aB\x00\x00Africa/Addis_AbabaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x12tnj\xfc\x04\x00\x00\xfc\x04\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x12C\x00\x00Africa/Cairo" + + "UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS_\u007f2[\xaf\x01\x00\x00\xaf\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\xa0\x81TH\x00\x00Africa/TripoliUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81KJ\x00\x00Africa/NouakchottUT\x05\x00\x03\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x18K\x00" + + "\x00Africa/KampalaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8A\x1fL\x00\x00America/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01" + + "\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81aL\x00\x00America/TijuanaUT" + + "\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\xa0\x81\xabP\x00\x00America/Blanc-SablonUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00" + + "\x00\x00\x00\x00#\x82iS\xb4\x82s\x1dT\x01\x00\x00T\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xaaQ\x00\x00America/ChihuahuaUT\x05\x00\x03" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0" + + "\x81IS\x00\x00America/AtikokanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82i" + + "S?_p\x99\x0e\x05\x00\x00\x0e\x05\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81(T\x00\x00America/WinnipegUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x80Y\x00\x00Ame" + + "rica/ArubaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSJtZ\x8c\x01\x03\x00\x00\x01\x03" + + "\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81xZ\x00\x00America/PangnirtungUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc6]\x00\x00America/Mon" + + "tserratUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x12" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc3^\x00\x00America/KralendijkUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf6\"\x12\xfe\x0e\x05\x00\x00\x0e\x05\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc0_\x00\x00America/Los_Ang" + + "elesUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x10\x00\x18\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1be\x00\x00America/St_KittsUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03" + + "\n\x00\x00\x00\x00\x00#\x82iS\xbf\x03u\xf3\xe4\x01\x00\x00\xe4\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x16f\x00\x00America/RecifeUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd6\xfe\xf3%\xb4\x02\x00\x00\xb4\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "Bh\x00\x00America/ResoluteUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS" + + "R\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81@k\x00\x00America/CatamarcaUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81On\x00\x00Ame" + + "rica/AtkaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS.\xbe\x1a>\xe7\x03\x00\x00\xe7\x03\x00" + + "\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81^r\x00\x00America/BoiseUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8A\x8cv\x00\x00America/North_Dako" + + "ta/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSR\x1b\x8b(\xde\x03\x00\x00\xde\x03\x00\x00\x1e\x00\x18\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xdbv\x00\x00America/North_Dakota/New_SalemUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSH\xeam\xef\xde\x03\x00\x00\xde\x03\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x11{\x00\x00America" + + "/North_Dakota/CenterUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS" + + "\xb7.\xb6*\x13\x04\x00\x00\x13\x04\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81D\u007f\x00\x00America/North_Dakota/BeulahUT\x05" + + "\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSa\xcb'\xe9\x9c\x01\x00\x00\x9c\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\xa0\x81\xac\x83\x00\x00America/ManausUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82i" + + "Sq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x90\x85\x00\x00America/Port_of_SpainUT\x05\x00\x03\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSŒZ\x8c\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x90\x86" + + "\x00\x00America/MendozaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xac\x8a\x83" + + "S\xd4\x00\x00\x00\xd4\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9d\x89\x00\x00America/GuatemalaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSU!\x12f\xd9\x02\x00\x00\xd9\x02\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xbc\x8a\x00\x00Americ" + + "a/YellowknifeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe90T\x16\xd1\x01\x00" + + "\x00\xd1\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe2\x8d\x00\x00America/NuukUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf9\x8f\x00\x00America/St_Bart" + + "helemyUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS:\x9a1T\xdf\x01\x00\x00\xdf\x01\x00\x00\x14\x00" + + "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf9\x90\x00\x00America/ScoresbysundUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00" + + "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9d?\xdfڸ\x03\x00\x00\xb8\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81&\x93\x00\x00America/Sao_Pa" + + "uloUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x82\x13z\xe2\xc2\x00\x00\x00\xc2\x00\x00\x00\x13\x00\x18\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\xa0\x81)\x97\x00\x00America/TegucigalpaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSM\x94\xc7Kp\x03\x00\x00p\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x818\x98\x00\x00America/Glace_BayU" + + "T\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x8f\x19Ԇ\x12\x02\x00\x00\x12\x02\x00\x00\x16\x00\x18\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\xa0\x81\xf3\x9b\x00\x00America/Bahia_BanderasUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e" + + "\x03\n\x00\x00\x00\x00\x00#\x82iS\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81U\x9e\x00\x00America/RosarioUT\x05\x00" + + "\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x81{\xc1\x92\xbc\x03\x00\x00\xbc\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\xa0\x81b\xa1\x00\x00America/SitkaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS)" + + ":\x17-\x88\x06\x00\x00\x88\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81e\xa5\x00\x00America/HalifaxUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc1Ȇ\x90\x05\x04\x00\x00\x05\x04\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x816\xac\x00\x00Americ" + + "a/WhitehorseUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf8Dz\x97\xae\x01\x00\x00" + + "\xae\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x87\xb0\x00\x00America/Boa_VistaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSc)\xf6)\xb3\x00\x00\x00\xb3\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x80\xb2\x00\x00America/Bog" + + "otaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS8O:\xbf\x95\x03\x00\x00\x95\x03\x00\x00\x11\x00\x18\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\xa0\x81{\xb3\x00\x00America/MenomineeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03" + + "\n\x00\x00\x00\x00\x00#\x82iS<\xb9\x18\x87\xe4\x02\x00\x00\xe4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81[\xb7\x00\x00America/IqaluitUT\x05\x00\x03" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xad`\x12\xe9\xaa\x00\x00\x00\xaa\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0" + + "\x81\x88\xba\x00\x00America/La_PazUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xae" + + ",\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81z\xbb\x00\x00America/AdakUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xea$\xc1\xbf\xb0\x00\x00\x00\xb0\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x89\xbf\x00\x00America/E" + + "l_SalvadorUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSԾ\xe7#\x95\x00\x00\x00\x95\x00" + + "\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x86\xc0\x00\x00America/Coral_HarbourUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8Aj\xc1\x00\x00America/K" + + "entucky/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x03\x1a|J\xcc\x03\x00\x00\xcc\x03\x00\x00" + + "\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb5\xc1\x00\x00America/Kentucky/MonticelloUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xdf\xe5\x8d\xc4\xda\x04\x00\x00\xda\x04\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd6\xc5\x00\x00Ameri" + + "ca/Kentucky/LouisvilleUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82" + + "iS3\x9aG\xc8\xd0\x06\x00\x00\xd0\x06\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x05\xcb\x00\x00America/New_YorkUT\x05\x00\x03\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSl=\xad\xbe\x16\x01\x00\x00\x16\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1f\xd2\x00\x00Am" + + "erica/BarbadosUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00" + + "\x00\x00\xb1\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\u007f\xd3\x00\x00America/Puerto_RicoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81}\xd4\x00\x00America" + + "/AnguillaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS,\xdb~\xab\xb2\x03\x00\x00\xb2\x03\x00" + + "\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81x\xd5\x00\x00America/YakutatUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK" + + "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81s\xd9\x00\x00America/Shiprock" + + "UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00" + + "\x00\x00\x10\x00\xe8A\xcf\xdd\x00\x00America/Argentina/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00" + + "\x00\x00\x00\x00#\x82iSR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00\x1b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1b\xde\x00\x00America/Argentina/Cata" + + "marcaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSR\xc8\xd9\xf6\xc4\x02\x00\x00\xc4\x02\x00\x00 \x00\x18" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x814\xe1\x00\x00America/Argentina/ComodRivadaviaUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSŒZ\x8c\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81R\xe4\x00\x00Ame" + + "rica/Argentina/MendozaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82" + + "iS\x8b}\xb6\x1e\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81i\xe7\x00\x00America/Argentina/UshuaiaUT\x05" + + "\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSm\aD\x0e\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\xa0\x81\x80\xea\x00\x00America/Argentina/La_RiojaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01" + + "\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSutZ\x1a\xb2\x02\x00\x00\xb2\x02\x00\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa1\xed\x00\x00America/Argentina" + + "/JujuyUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x1c\x80\xb9\\\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00" + + "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa4\xf0\x00\x00America/Argentina/San_LuisUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x1e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc5\xf3\x00\x00America/" + + "Argentina/Buenos_AiresUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82" + + "iS\x8ep\xb4c\xc4\x02\x00\x00\xc4\x02\x00\x00\x1e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe1\xf6\x00\x00America/Argentina/Rio_Galleg" + + "osUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xfcz=\xe1\xcd\x02\x00\x00\xcd\x02\x00\x00\x1a\x00\x18\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\xa0\x81\xfd\xf9\x00\x00America/Argentina/San_JuanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1e\xfd\x00\x00America/Arge" + + "ntina/CordobaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSY\xd8֭\xd6\x02\x00" + + "\x00\xd6\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x815\x00\x01\x00America/Argentina/TucumanUT\x05\x00\x03\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSt*\x9b!\xb2\x02\x00\x00\xb2\x02\x00\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81^\x03\x01\x00Am" + + "erica/Argentina/SaltaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82i" + + "Sp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81a\x06\x01\x00America/IndianapolisUT\x05\x00\x03\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc2\b\x01" + + "\x00America/DominicaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9bܩ" + + "=\xda\x06\x00\x00\xda\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xbd\t\x01\x00America/ChicagoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x1c\xd8\x19\x9dp\x01\x00\x00p\x01\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe0\x10\x01\x00America/" + + "Swift_CurrentUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x1e+}\x15\xb4\x02\x00" + + "\x00\xb4\x02\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9f\x12\x01\x00America/Rankin_InletUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa1\x15\x01\x00America" + + "/PanamaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe90T\x16\xd1\x01\x00\x00\xd1\x01\x00\x00\x0f" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81~\x16\x01\x00America/GodthabUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x89غ\xee\x15\x04\x00\x00\x15\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x98\x18\x01\x00America/BelizeUT\x05\x00" + + "\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd7\b\\\xc6&\x02\x00\x00&\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\xa0\x81\xf5\x1c\x01\x00America/MiquelonUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82" + + "iSB\xa0=:\x1e\x01\x00\x00\x1e\x01\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81e\x1f\x01\x00America/HermosilloUT\x05\x00\x03\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xcf \x01\x00" + + "America/DetroitUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb4\x11Z\xde\xe4" + + "\x01\x00\x00\xe4\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9b$\x01\x00America/FortalezaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS$\r\x89l\xe4\x01\x00\x00\xe4\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xca&\x01\x00America/" + + "OjinagaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS5\x11Q\x06\xd1\x03\x00\x00\xd1\x03\x00\x00\x11" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf7(\x01\x00America/AnchorageUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK" + + "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSU9#\xbe2\x05\x00\x002\x05\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x13-\x01\x00America/Vancouve" + + "rUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x81\x902\x01\x00America/Porto_AcreUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n" + + "\x00\x00\x00\x00\x00#\x82iSd\xa9y\x9at\x03\x00\x00t\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81~4\x01\x00America/AsuncionUT\x05\x00\x03" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS?\xc9\x1c\xd4\xc6\x03\x00\x00\xc6\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0" + + "\x81<8\x01\x00America/JuneauUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf6" + + "@\rm\xa8\x05\x00\x00\xa8\x05\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81J<\x01\x00America/Fort_NelsonUT\x05\x00\x03\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x85-\xb9\xf8\x8a\x01\x00\x00\x8a\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81?B\x01\x00Am" + + "erica/BelemUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSV\x80\x94@\x12\x04\x00\x00\x12" + + "\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x10D\x01\x00America/DenverUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81jH\x01\x00America/Fort_Wa" + + "yneUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSg\xf5K\x89\xa2\x01\x00\x00\xa2\x01\x00\x00\x12\x00\x18\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc9J\x01\x00America/Rio_BrancoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e" + + "\x03\n\x00\x00\x00\x00\x00#\x82iS\x1e\xfbn۸\x03\x00\x00\xb8\x03\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb7L\x01\x00America/Campo_Grand" + + "eUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS{\a\a\xdc\xca\x03\x00\x00\xca\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x81\xbdP\x01\x00America/EdmontonUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00" + + "\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd1T\x01\x00America/St_ThomasUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "\xcdU\x01\x00America/VirginUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSMv" + + "\xa1\x0f%\x01\x00\x00%\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc6V\x01\x00America/MonterreyUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb4T\xbd\xeb5\x02\x00\x005\x02\x00\x00\x16\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x816X\x01\x00Ameri" + + "ca/Port-au-PrinceUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x1b\x81-" + + "\xa9\x8a\x01\x00\x00\x8a\x01\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xbbZ\x01\x00America/Porto_VelhoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01" + + "\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x92\\\x01\x00Amer" + + "ica/St_VincentUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd0v\x01\x8a\x01\x04" + + "\x00\x00\x01\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8f]\x01\x00America/EnsenadaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb1݂x\xe8\x00\x00\x00\xe8\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xdaa\x01\x00America/Co" + + "sta_RicaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa2\x81\xbfyS\x02\x00\x00S\x02\x00\x00" + + "\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x0ec\x01\x00America/MetlakatlaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00" + + "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xade\x01\x00America/Curaca" + + "oUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa7\x17jҲ\x00\x00\x00\xb2\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x81\xa7f\x01\x00America/MartiniqueUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n" + + "\x00\x00\x00\x00\x00#\x82iS~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa5g\x01\x00America/St_JohnsUT\x05\x00\x03" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSutZ\x1a\xb2\x02\x00\x00\xb2\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0" + + "\x81Eo\x01\x00America/JujuyUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSP\x0f" + + "(\b=\x01\x00\x00=\x01\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81>r\x01\x00America/Santo_DomingoUT\x05\x00\x03\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\u0096dK~\x02\x00\x00~\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xcas\x01\x00A" + + "merica/ReginaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSp\x1b\xceRC\x03\x00" + + "\x00C\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x90v\x01\x00America/NipigonUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSo_\x00v/\x01\x00\x00/\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1cz\x01\x00America/Meri" + + "daUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSn\xab\xd5\xf9\xcf\x03\x00\x00\xcf\x03\x00\x00\f\x00\x18\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\xa0\x81\x93{\x01\x00America/NomeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8A\xa8\u007f\x01\x00America/Indiana/UT\x05\x00\x03\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSصK\xa6\n\x02\x00\x00\n\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf2\u007f\x01\x00" + + "America/Indiana/Tell_CityUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" + + "\x00#\x82iSp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x1c\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81O\x82\x01\x00America/Indiana/Indianapo" + + "lisUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSM/U\x9f7\x02\x00\x007\x02\x00\x00\x17\x00\x18\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb8\x84\x01\x00America/Indiana/MarengoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00" + + "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\r\xedsp.\x02\x00\x00.\x02\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81@\x87\x01\x00America/Indian" + + "a/VincennesUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x01\xd8N\x8c\xab\x02\x00\x00\xab" + + "\x02\x00\x00\x1a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc1\x89\x01\x00America/Indiana/PetersburgUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSK-E\xfad\x02\x00\x00d\x02\x00\x00\x17\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc0\x8c\x01\x00Ame" + + "rica/Indiana/WinamacUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS" + + " \x17\x89}q\x01\x00\x00q\x01\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81u\x8f\x01\x00America/Indiana/VevayUT\x05\x00\x03\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x815\x91\x01" + + "\x00America/Indiana/KnoxUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82i" + + "SԾ\xe7#\x95\x00\x00\x00\x95\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81{\x95\x01\x00America/CaymanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS錴$q\x03\x00\x00q\x03\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81X\x96\x01\x00Ameri" + + "ca/Thunder_BayUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS8\xcdZ\x05o\x01" + + "\x00\x00o\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x16\x9a\x01\x00America/MazatlanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb7-2f\xe4\x01\x00\x00\xe4\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81ϛ\x01\x00America/No" + + "ronhaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe0\xbf\xf5\xe5\xc4\x02\x00\x00\xc4\x02\x00\x00\x14\x00\x18" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xfc\x9d\x01\x00America/Buenos_AiresUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x0e\xa1\x01\x00America/Tortola" + + "UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa1'\a\xbd\x97\x00\x00\x00\x97\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\xa0\x81\b\xa2\x01\x00America/CayenneUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" + + "\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe8\xa2\x01\x00America/St_LuciaUT\x05\x00\x03\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSk\xc2\rx\xbf\x01\x00\x00\xbf\x01\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe3\xa3\x01" + + "\x00America/DanmarkshavnUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82i" + + "S\xf1\xf9\x1dɻ\x00\x00\x00\xbb\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf0\xa5\x01\x00America/ParamariboUT\x05\x00\x03\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xfe7\xa1\x87\x1b\x01\x00\x00\x1b\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf7\xa6\x01\x00A" + + "merica/LimaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xac\x8e\xee\x13\xbe\x00\x00\x00\xbe" + + "\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81X\xa8\x01\x00America/CaracasUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00" + + "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81_\xa9\x01\x00America/Phoeni" + + "xUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS<\x01V\rP\x02\x00\x00P\x02\x00\x00\x11\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x81\x98\xaa\x01\x00America/AraguainaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00" + + "\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x813\xad\x01\x00America/Lower_PrincesU" + + "T\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSk^2S\xb9\x04\x00\x00\xb9\x04\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\xa0\x813\xae\x01\x00America/Punta_ArenasUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n" + + "\x00\x00\x00\x00\x00#\x82iS\x1d`̟\x00\x03\x00\x00\x00\x03\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81:\xb3\x01\x00America/Cambridge_Bay" + + "UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\xa0\x81\x89\xb6\x01\x00America/MontrealUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" + + "\x00\x00#\x82iS\x04,2h\x99\x01\x00\x00\x99\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x88\xbd\x01\x00America/SantaremUT\x05\x00\x03\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf2\x04\xde\xdd\x11\x02\x00\x00\x11\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81k\xbf" + + "\x01\x00America/CancunUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSU\xactA" + + "\xb5\x01\x00\x00\xb5\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc4\xc1\x01\x00America/MatamorosUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSs\xb0\xeau\xb4\x01\x00\x00\xb4\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc4\xc3\x01\x00America" + + "/EirunepeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00" + + "\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc2\xc5\x01\x00America/Santa_IsabelUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x11\xca\x01\x00America/Gre" + + "nadaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x0f\x00\x18\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\v\xcb\x01\x00America/MarigotUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n" + + "\x00\x00\x00\x00\x00#\x82iS\xf7\xe9 y\xbd\x02\x00\x00\xbd\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x05\xcc\x01\x00America/InuvikUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe5s\xb3\\'\x01\x00\x00'\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\n" + + "\xcf\x01\x00America/ManaguaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xfe\xe6" + + "\xf5J\x05\x04\x00\x00\x05\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81z\xd0\x01\x00America/DawsonUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS.\xf9\xc0\x1e\xd5\x05\x00\x00\xd5\x05\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc7\xd4\x01\x00America/" + + "MonctonUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS[Sp\x90\x02\x05\x00\x00\x02\x05\x00\x00\x10" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe5\xda\x01\x00America/SantiagoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01" + + "\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x811\xe0\x01\x00America/CrestonUT" + + "\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xef\xf0R\x8a\xc4\x02\x00\x00\xc4\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\xa0\x81j\xe1\x01\x00America/CordobaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#" + + "\x82iS%J\xd5\xebS\x01\x00\x00S\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81w\xe4\x01\x00America/JamaicaUT\x05\x00\x03\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS挋\x92\xf6\x01\x00\x00\xf6\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x13\xe6\x01\x00Am" + + "erica/MaceioUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS+\x10`ȫ\x02\x00\x00" + + "\xab\x02\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81Q\xe8\x01\x00America/Dawson_CreekUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81J\xeb\x01\x00America/" + + "TorontoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd6\xe1Հ\x9c\x01\x00\x00\x9c\x01\x00\x00\x13" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81H\xf2\x01\x00America/Mexico_CityUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00" + + "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x811\xf4\x01\x00America/Nassau" + + "UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\u007f$*\xa0\xa6\x03\x00\x00\xa6\x03\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\xa0\x81.\xfb\x01\x00America/CuiabaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iSq\xc9*;\xb1\x00\x00\x00\xb1\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1c\xff\x01\x00America/GuadeloupeUT\x05\x00\x03\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x1d\xf7\a ,\x06\x00\x00,\x06\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x19\x00" + + "\x02\x00America/Goose_BayUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xdf" + + "\xe5\x8d\xc4\xda\x04\x00\x00\xda\x04\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x90\x06\x02\x00America/LouisvilleUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x1b\vKdC\x03\x00\x00C\x03\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb6\v\x02\x00Ame" + + "rica/Rainy_RiverUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc0\x98\x00\b" + + "\xc9\x03\x00\x00\xc9\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81F\x0f\x02\x00America/MontevideoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS$ \x873\xf8\x03\x00\x00\xf8\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81[\x13\x02\x00Americ" + + "a/Knox_INUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe3\xc9I\xd0U\x03\x00\x00U\x03\x00" + + "\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9c\x17\x02\x00America/Grand_TurkUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xcd\xc3v\xe3\xb3\x00\x00\x00\xb3\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81=\x1b\x02\x00America/Guaya" + + "quilUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x01\x05\xf3\x89\xb5\x00\x00\x00\xb5\x00\x00\x00\x0e\x00\x18\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81;\x1c\x02\x00America/GuyanaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00" + + "\x00\x00\x00\x00#\x82iS\a\x1c\x9e\x9a]\x04\x00\x00]\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x818\x1d\x02\x00America/HavanaUT\x05\x00\x03\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSOKjǪ\x02\x00\x00\xaa\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xdd!" + + "\x02\x00America/BahiaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSq\xc9*;\xb1" + + "\x00\x00\x00\xb1\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xce$\x02\x00America/AntiguaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSU\r\xf7\xd3\xc7\x01\x00\x00\xc7\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc8%\x02\x00America/Th" + + "uleUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\v\x00\x18\x00\x00" + + "\x00\x00\x00\x00\x00\x10\x00\xe8A\xd6'\x02\x00Antarctica/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iS\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1b(\x02\x00Antarctica/SyowaUT\x05\x00\x03\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc2\v\xae\b\x85\x00\x00\x00\x85\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xea(\x02\x00" + + "Antarctica/VostokUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x95\xea\x06" + + "\xd3\xc5\x00\x00\x00\xc5\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xba)\x02\x00Antarctica/DavisUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc9*\x02\x00Antarct" + + "ica/McMurdoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x95{\xf3\xa9w\x03\x00\x00w" + + "\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81(/\x02\x00Antarctica/PalmerUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS:\xc8P7\xb1\x00\x00\x00\xb1\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xea2\x02\x00Antarctica/T" + + "rollUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSƉ\xf71\x84\x00\x00\x00\x84\x00\x00\x00\x12\x00\x18\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe53\x02\x00Antarctica/RotheraUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSn\x04\x19y\x9a\x00\x00\x00\x9a\x00\x00\x00\x19\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb54\x02\x00Antarctica/DumontD" + + "UrvilleUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x15" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa25\x02\x00Antarctica/South_PoleUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb2\x84J]\xd0\x03\x00\x00\xd0\x03\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x04:\x02\x00Antarctica/M" + + "acquarieUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd7N\xab\x8b\x98\x00\x00\x00\x98\x00\x00\x00" + + "\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\">\x02\x00Antarctica/MawsonUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xddzAh\xf3\x00\x00\x00\xf3\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x05?\x02\x00Antarctica/Case" + + "yUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x10\x00\xe8AB@\x02\x00Arctic/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa5\x97" + + "\aĤ\x02\x00\x00\xa4\x02\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x83@\x02\x00Arctic/LongyearbyenUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8AtC\x02\x00Asi" + + "a/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSѾ\xa8\xc7u\x02\x00\x00u\x02\x00\x00\f\x00\x18\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\xa0\x81\xb3C\x02\x00Asia/TbilisiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iS\xee\xf0BB\xff\x01\x00\x00\xff\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81nF\x02\x00Asia/TaipeiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9a\x1a\xdc\xca\xdc\x00\x00\x00\xdc\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb2H\x02\x00Asia/" + + "CalcuttaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSS\xa5\x81e\xf7\x00\x00\x00\xf7\x00\x00\x00" + + "\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd5I\x02\x00Asia/PontianakUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xdb\xfa\xb5\xbeg\x02\x00\x00g\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x14K\x02\x00Asia/AqtobeUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9a\x1a\xdc\xca\xdc\x00\x00\x00\xdc\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc0" + + "M\x02\x00Asia/KolkataUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x87\xbd\xedL\xf1" + + "\x02\x00\x00\xf1\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe2N\x02\x00Asia/BarnaulUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa7f^]@\x01\x00\x00@\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x19R\x02\x00Asia/KuchingU" + + "T\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSǯ\xdf\x1c\xee\x00\x00\x00\xee\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\xa0\x81\x9fS\x02\x00Asia/ManilaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS" + + "?\xa7^\xfah\x02\x00\x00h\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd2T\x02\x00Asia/AtyrauUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x1d?v\f\x17\x03\x00\x00\x17\x03\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\u007fW\x02\x00Asia/Maca" + + "oUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xdav\x19z\x98\x00\x00\x00\x98\x00\x00\x00\n\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x81\xdaZ\x02\x00Asia/QatarUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82i" + + "S\xf9l\x03\x12\xf8\x02\x00\x00\xf8\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb6[\x02\x00Asia/IrkutskUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe8\xf0\xdeV\xe0\x04\x00\x00\xe0\x04\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf4^\x02\x00Asia/He" + + "bronUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS]S\xbb\x12\xac\x03\x00\x00\xac\x03\x00\x00\x0e\x00\x18\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x19d\x02\x00Asia/FamagustaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00" + + "\x00\x00\x00\x00#\x82iS\x84)\r\xbd\xec\x00\x00\x00\xec\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\rh\x02\x00Asia/SaigonUT\x05\x00\x03\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81>i\x02\x00A" + + "sia/HarbinUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xba\xa3b\xc1R\x02\x00\x00R\x02" + + "\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\fk\x02\x00Asia/HovdUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n" + + "\x00\x00\x00\x00\x00#\x82iS\xa9z\xc8\x1f\xce\x04\x00\x00\xce\x04\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa1m\x02\x00Asia/GazaUT\x05\x00\x03\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS:\x11\xea\xa2\xe5\x02\x00\x00\xe5\x02\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb2r\x02\x00As" + + "ia/OmskUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS?Y\xaf\x19\xe7\x00\x00\x00\xe7\x00\x00\x00\n" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xdau\x02\x00Asia/DaccaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00" + + "\x00\x00\x00#\x82iSB\x1d\xc6\x1b\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x05w\x02\x00Asia/UrumqiUT\x05\x00\x03\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS?Y\xaf\x19\xe7\x00\x00\x00\xe7\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xcfw\x02\x00As" + + "ia/DhakaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSE\t\xfa-\a\x03\x00\x00\a\x03\x00\x00" + + "\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xfax\x02\x00Asia/Hong_KongUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\\\x91\x87\xbb\xf7\x00\x00\x00\xf7\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81I|\x02\x00Asia/ColomboUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "\x86}\x02\x00Asia/VientianeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSB\x1d" + + "\xc6\x1b\x85\x00\x00\x00\x85\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81f~\x02\x00Asia/KashgarUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS)p\x1cX\xf1\x02\x00\x00\xf1\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x811\u007f\x02\x00Asia/Novos" + + "ibirskUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe4_P\x18\xef\x02\x00\x00\xef\x02\x00\x00\f\x00" + + "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81l\x82\x02\x00Asia/MagadanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00" + + "\x00\x00\x00\x00#\x82iS\x8bSnT\xa1\x00\x00\x00\xa1\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa1\x85\x02\x00Asia/KathmanduUT\x05\x00\x03\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8a\x86" + + "\x02\x00Asia/BangkokUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xcfׇ\xe1\x85\x00" + + "\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81h\x87\x02\x00Asia/RiyadhUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSΒ\x1a\x8c\xaa\x00\x00\x00\xaa\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x812\x88\x02\x00Asia/DiliUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSL\xe0\x91y\xe5\x02\x00\x00\xe5\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "\x1f\x89\x02\x00Asia/KrasnoyarskUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS" + + "\x83g\x95M\a\x03\x00\x00\a\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81N\x8c\x02\x00Asia/KhandygaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x81z&\x80k\x02\x00\x00k\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9c\x8f\x02\x00Asia/Ch" + + "oibalsanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSw\x86\x8d^\x03\x03\x00\x00\x03\x03\x00\x00" + + "\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81P\x92\x02\x00Asia/Ust-NeraUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e" + + "\x03\n\x00\x00\x00\x00\x00#\x82iSe\x1bb2w\x01\x00\x00w\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9a\x95\x02\x00Asia/AshkhabadUT\x05\x00\x03" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS'\xe2\\\xff\x9f\x00\x00\x00\x9f\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0" + + "\x81Y\x97\x02\x00Asia/KabulUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa1\xfax\x98g" + + "\x02\x00\x00g\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81<\x98\x02\x00Asia/QostanayUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb2\xe27Yn\x01\x00\x00n\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xea\x9a\x02\x00Asia/Tashken" + + "tUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00\r\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x81\x9f\x9c\x02\x00Asia/ShanghaiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iS\xdav\x19z\x98\x00\x00\x00\x98\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81o\x9e\x02\x00Asia/BahrainUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01" + + "\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSʇ{_\xbb\x00\x00\x00\xbb\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81M\x9f\x02\x00Asia" + + "/RangoonUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS*\xe4@\xa9\x89\x01\x00\x00\x89\x01\x00\x00" + + "\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81N\xa0\x02\x00Asia/ChungkingUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS;\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1f\xa2\x02\x00Asia/TehranUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x818" + + "\xaa\x02\x00Asia/IstanbulUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xed\x8c\xf1\x91" + + "\x85\x00\x00\x00\x85\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81/\xaf\x02\x00Asia/DubaiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00" + + "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSb\xadű\xf8\x00\x00\x00\xf8\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf8\xaf\x02\x00Asia/JakartaUT" + + "\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xed\x8c\xf1\x91\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\xa0\x816\xb1\x02\x00Asia/MuscatUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xef" + + "\\\xf4q\x17\x04\x00\x00\x17\x04\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x00\xb2\x02\x00Asia/DamascusUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSO\xb0\x03\xe9\xe5\x02\x00\x00\xe5\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81^\xb6\x02\x00Asia/Yak" + + "utskUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSj$\xcd\xf4\x9a\x00\x00\x00\x9a\x00\x00\x00\f\x00\x18\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x89\xb9\x02\x00Asia/ThimphuUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" + + "\x00\x00#\x82iSw\rD\an\x01\x00\x00n\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81i\xba\x02\x00Asia/SamarkandUT\x05\x00\x03\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSV\xe0\xe7!\xe7\x02\x00\x00\xe7\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1f\xbc\x02\x00" + + "Asia/AnadyrUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSd%\x05\xd8\xe6\x02\x00\x00\xe6" + + "\x02\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81K\xbf\x02\x00Asia/VladivostokUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSj$\xcd\xf4\x9a\x00\x00\x00\x9a\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81{\xc2\x02\x00Asia/ThimbuUT" + + "\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS恸\x1e\x00\x01\x00\x00\x00\x01\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\xa0\x81Z\xc3\x02\x00Asia/Kuala_LumpurUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" + + "\x00#\x82iS\x06\xaa>\xa8\x00\x01\x00\x00\x00\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa5\xc4\x02\x00Asia/SingaporeUT\x05\x00\x03\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS[u\x99q\xf1\x02\x00\x00\xf1\x02\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xed\xc5\x02\x00A" + + "sia/TomskUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSe\x1bb2w\x01\x00\x00w\x01\x00" + + "\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\"\xc9\x02\x00Asia/AshgabatUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSʇ{_\xbb\x00\x00\x00\xbb\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe0\xca\x02\x00Asia/YangonUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x8a\xc1\x1eB\xb7\x00\x00\x00\xb7\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe0" + + "\xcb\x02\x00Asia/PyongyangUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9a\xea\x18" + + "\xd4\xf8\x02\x00\x00\xf8\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xdf\xcc\x02\x00Asia/YekaterinburgUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x02\xf4\xaeg\xd5\x00\x00\x00\xd5\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81#\xd0\x02\x00Asia/" + + "TokyoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb2\xb9\xf4\xb6R\x02\x00\x00R\x02\x00\x00\x10\x00\x18" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81<\xd1\x02\x00Asia/UlaanbaatarUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e" + + "\x03\n\x00\x00\x00\x00\x00#\x82iS9Y\xb7\xf1\n\x01\x00\x00\n\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd8\xd3\x02\x00Asia/KarachiUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xab\xcd\xdf\x05\xee\x02\x00\x00\xee\x02\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81(" + + "\xd5\x02\x00Asia/ChitaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf0\x9cf>\xd7\x02\x00" + + "\x00\xd7\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81Z\xd8\x02\x00Asia/KamchatkaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x03R\xda\xedU\x02\x00\x00U\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81y\xdb\x02\x00Asia/NicosiaU" + + "T\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS`\xc9\xd4\\\xbe\x00\x00\x00\xbe\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\xa0\x81\x14\xde\x02\x00Asia/MakassarUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82" + + "iS0]*\x1bj\x02\x00\x00j\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x19\xdf\x02\x00Asia/BishkekUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd5ΜGp\x02\x00\x00p\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc9\xe1\x02\x00Asia/Q" + + "yzylordaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x02\x95-\xad\xc4\x02\x00\x00\xc4\x02\x00\x00" + + "\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x81\xe4\x02\x00Asia/YerevanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03" + + "\n\x00\x00\x00\x00\x00#\x82iS\xa4Zߐ\xe6\x02\x00\x00\xe6\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8b\xe7\x02\x00Asia/SrednekolymskUT" + + "\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\xa0\x81\xbd\xea\x02\x00Asia/AdenUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS*\xe4@" + + "\xa9\x89\x01\x00\x00\x89\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x85\xeb\x02\x00Asia/ChongqingUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb2\xb9\xf4\xb6R\x02\x00\x00R\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81V\xed\x02\x00Asia/Ulan" + + "_BatorUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x17✳2\x04\x00\x002\x04\x00\x00\x0e\x00" + + "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf1\xef\x02\x00Asia/JerusalemUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03" + + "\n\x00\x00\x00\x00\x00#\x82iS\xc7\x11\xe1[\xdc\x02\x00\x00\xdc\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81k\xf4\x02\x00Asia/BeirutUT\x05\x00\x03\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS`\xc9\xd4\\\xbe\x00\x00\x00\xbe\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8c\xf7\x02" + + "\x00Asia/Ujung_PandangUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9e" + + "\x88|`\x9a\x03\x00\x00\x9a\x03\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x96\xf8\x02\x00Asia/AmmanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd7e&uv\x02\x00\x00v\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81t\xfc\x02\x00Asia/Baghda" + + "dUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS.>[K\xab\x00\x00\x00\xab\x00\x00\x00\r\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x810\xff\x02\x00Asia/JayapuraUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iST\x81\x18G^\x02\x00\x00^\x02\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\"\x00\x03\x00Asia/AqtauUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS)\x15II\xf3\x02\x00\x00\xf3\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc4\x02\x03\x00Asia/S" + + "akhalinUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x03\x87\xb3<\xe8\x02\x00\x00\xe8\x02\x00\x00\t" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xfe\x05\x03\x00Asia/BakuUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" + + "\x00\x00#\x82iS&\xe9\xd1\xd8q\x02\x00\x00q\x02\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81)\t\x03\x00Asia/OralUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x88\xf6C\x84\x98\x00\x00\x00\x98\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xdd\v\x03\x00Asia/" + + "Phnom_PenhUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS's\x96\x1en\x01\x00\x00n\x01" + + "\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xbe\f\x03\x00Asia/DushanbeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01" + + "\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x84)\r\xbd\xec\x00\x00\x00\xec\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81s\x0e\x03\x00Asia/Ho_Chi_MinhU" + + "T\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc7X,Y\x9f\x01\x00\x00\x9f\x01\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\xa0\x81\xa9\x0f\x03\x00Asia/SeoulUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x8b" + + "SnT\xa1\x00\x00\x00\xa1\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8c\x11\x03\x00Asia/KatmanduUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSS\xdd\\2a\x02\x00\x00a\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81t\x12\x03\x00Asia/Alm" + + "atyUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSy\x19\xe0N\x9a\x00\x00\x00\x9a\x00\x00\x00\v\x00\x18\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1a\x15\x03\x00Asia/BruneiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iS\x17✳2\x04\x00\x002\x04\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf9\x15\x03\x00Asia/Tel_AvivUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x1d?v\f\x17\x03\x00\x00\x17\x03\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81r\x1a\x03\x00Asi" + + "a/MacauUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x8a\x9a\x90\xf7\xd6\x02\x00\x00\xd6\x02\x00\x00\x11" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xcd\x1d\x03\x00Asia/NovokuznetskUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK" + + "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xcfׇ\xe1\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xee \x03\x00Asia/KuwaitUT\x05\x00\x03" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8" + + "A\xb8!\x03\x00Atlantic/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSm\xbd\x10k\xf1\x02" + + "\x00\x00\xf1\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xfb!\x03\x00Atlantic/ReykjavikUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb7\x0e\xbdm\xb9\x01\x00\x00\xb9\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x818%\x03\x00Atlantic" + + "/FaeroeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe8\x8dY\x80\xad\x05\x00\x00\xad\x05\x00\x00\x0f" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81:'\x03\x00Atlantic/AzoresUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\u0097N\xad\xaf\x00\x00\x00\xaf\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x810-\x03\x00Atlantic/Cape_Verd" + + "eUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSl&\x04\x99\x00\x04\x00\x00\x00\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x81,.\x03\x00Atlantic/BermudaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00" + + "\x00\x00\x00#\x82iS\xb7\x0e\xbdm\xb9\x01\x00\x00\xb9\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81v2\x03\x00Atlantic/FaroeUT\x05\x00\x03\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS1)7\xad\xad\x05\x00\x00\xad\x05\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81w4\x03" + + "\x00Atlantic/MadeiraUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa5\x97\a" + + "Ĥ\x02\x00\x00\xa4\x02\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81n:\x03\x00Atlantic/Jan_MayenUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe7\xcf^\xb0\x15\x03\x00\x00\x15\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81^=\x03\x00Atlan" + + "tic/StanleyUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf1\b{\x87\x82\x00\x00\x00\x82" + + "\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xbd@\x03\x00Atlantic/St_HelenaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xaf|7\xb3\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8bA\x03\x00Atlantic/Ca" + + "naryUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x0f-\xadׄ\x00\x00\x00\x84\x00\x00\x00\x16\x00\x18\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb2C\x03\x00Atlantic/South_GeorgiaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00" + + "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8A\x86D\x03\x00Australia/UT\x05\x00" + + "\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS?\x95\xbd\x12E\x01\x00\x00E\x01\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\xa0\x81\xcaD\x03\x00Australia/LindemanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iS3\xba\xde\xd3!\x01\x00\x00!\x01\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81[F\x03\x00Australia/QueenslandUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSϻ\xca\x1a2\x01\x00\x002\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "\xcaG\x03\x00Australia/WestUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa2\xdc" + + "\xba\xca:\x01\x00\x00:\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81DI\x03\x00Australia/EuclaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9b\xe1\xc1\xa9\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc7J\x03\x00Austral" + + "ia/VictoriaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSX\xb9\x9ap\x88\x03\x00\x00\x88" + + "\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9bN\x03\x00Australia/SydneyUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSE\xf2\xe6Z\xeb\x03\x00\x00\xeb\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81mR\x03\x00Australia/Hob" + + "artUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS3\xba\xde\xd3!\x01\x00\x00!\x01\x00\x00\x12\x00\x18\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa2V\x03\x00Australia/BrisbaneUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e" + + "\x03\n\x00\x00\x00\x00\x00#\x82iSo3\xdaR\xb4\x02\x00\x00\xb4\x02\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x0fX\x03\x00Australia/Lord_Howe" + + "UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSE\xf2\xe6Z\xeb\x03\x00\x00\xeb\x03\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\xa0\x81\x10[\x03\x00Australia/CurrieUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" + + "\x00\x00#\x82iS\x8ff~ՙ\x03\x00\x00\x99\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81E_\x03\x00Australia/SouthUT\x05\x00\x03\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81'c\x03" + + "\x00Australia/CanberraUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x8f" + + "f~ՙ\x03\x00\x00\x99\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xfbf\x03\x00Australia/AdelaideUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc8R\x1a\x1b\xea\x00\x00\x00\xea\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe0j\x03\x00Aus" + + "tralia/NorthUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSϻ\xca\x1a2\x01\x00\x00" + + "2\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x13l\x03\x00Australia/PerthUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xbd\xca#\u007f\xad\x03\x00\x00\xad\x03\x00\x00\x15\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8em\x03\x00Australia/Bro" + + "ken_HillUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00\x00" + + "\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8aq\x03\x00Australia/ACTUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e" + + "\x03\n\x00\x00\x00\x00\x00#\x82iS\xbd\xca#\u007f\xad\x03\x00\x00\xad\x03\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81Yu\x03\x00Australia/Yancowinn" + + "aUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc8R\x1a\x1b\xea\x00\x00\x00\xea\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x81Ty\x03\x00Australia/DarwinUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00" + + "\x00\x00\x00#\x82iSE\xf2\xe6Z\xeb\x03\x00\x00\xeb\x03\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x88z\x03\x00Australia/TasmaniaUT\x05\x00\x03" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9b\xe1\xc1\xa9\x88\x03\x00\x00\x88\x03\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0" + + "\x81\xbf~\x03\x00Australia/MelbourneUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iSo3\xdaR\xb4\x02\x00\x00\xb4\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x94\x82\x03\x00Australia/LHIUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSX\xb9\x9ap\x88\x03\x00\x00\x88\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8f\x85\x03\x00Aus" + + "tralia/NSWUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8A^\x89\x03\x00Brazil/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00" + + "\x00\x00\x00#\x82iSa\xcb'\xe9\x9c\x01\x00\x00\x9c\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9f\x89\x03\x00Brazil/WestUT\x05\x00\x03\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb7-2f\xe4\x01\x00\x00\xe4\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x80\x8b\x03\x00Br" + + "azil/DeNoronhaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSg\xf5K\x89\xa2\x01" + + "\x00\x00\xa2\x01\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xae\x8d\x03\x00Brazil/AcreUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9d?\xdfڸ\x03\x00\x00\xb8\x03\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x95\x8f\x03\x00Brazil/EastUT\x05\x00" + + "\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00" + + "\xe8A\x92\x93\x03\x00Canada/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS{\a\a\xdc\xca\x03\x00" + + "\x00\xca\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81ӓ\x03\x00Canada/MountainUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS~\xb2\x0e\x19V\a\x00\x00V\a\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe6\x97\x03\x00Canada/Newfo" + + "undlandUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS):\x17-\x88\x06\x00\x00\x88\x06\x00\x00\x0f" + + "\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x89\x9f\x03\x00Canada/AtlanticUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc1Ȇ\x90\x05\x04\x00\x00\x05\x04\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81Z\xa6\x03\x00Canada/YukonUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSӿ\x92\xbc\xb5\x06\x00\x00\xb5\x06\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "\xa5\xaa\x03\x00Canada/EasternUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSU9" + + "#\xbe2\x05\x00\x002\x05\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa2\xb1\x03\x00Canada/PacificUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS?_p\x99\x0e\x05\x00\x00\x0e\x05\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1c\xb7\x03\x00Canada/C" + + "entralUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\u0096dK~\x02\x00\x00~\x02\x00\x00\x13\x00" + + "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81r\xbc\x03\x00Canada/SaskatchewanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe6\x9aM\xbem\x02\x00\x00m\x02\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81=\xbf\x03\x00CETUT\x05\x00\x03\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8A\xe7\xc1\x03\x00Ch" + + "ile/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS[Sp\x90\x02\x05\x00\x00\x02\x05\x00\x00\x11\x00\x18\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81'\xc2\x03\x00Chile/ContinentalUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e" + + "\x03\n\x00\x00\x00\x00\x00#\x82iS\xee\xd0\x1cYN\x04\x00\x00N\x04\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81t\xc7\x03\x00Chile/EasterIslandU" + + "T\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS<\x8b\x99\x1e\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\xa0\x81\x0e\xcc\x03\x00CST6CDTUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\a\x1c\x9e\x9a" + + "]\x04\x00\x00]\x04\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x06\xd0\x03\x00CubaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03" + + "\n\x00\x00\x00\x00\x00#\x82iS`l\x8d~\xf1\x01\x00\x00\xf1\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa1\xd4\x03\x00EETUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E" + + "\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x12tnj\xfc\x04\x00\x00\xfc\x04\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xcf\xd6\x03\x00EgyptUT" + + "\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9a\v\xf9/\xd8\x05\x00\x00\xd8\x05\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\xa0\x81\n\xdc\x03\x00EireUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iStX\xbe\xe4o\x00\x00\x00" + + "o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81 \xe2\x03\x00ESTUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" + + "\x00#\x82iS\xe7/\xebT\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xcc\xe2\x03\x00EST5EDTUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8A\xc4\xe6\x03\x00Etc/UT\x05\x00" + + "\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb2\xab\xd1Is\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\xa0\x81\x02\xe7\x03\x00Etc/GMT-11UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa9{\xa2q" + + "q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb9\xe7\x03\x00Etc/GMT+2UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81m\xe8\x03\x00Etc/UCTUT\x05\x00\x03\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf7\x1ac\xc3r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1d\xe9" + + "\x03\x00Etc/GMT-1UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSP\xda\xfa\x03o\x00\x00\x00o" + + "\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd2\xe9\x03\x00Etc/GMT+0UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03" + + "\n\x00\x00\x00\x00\x00#\x82iS\"\xf8\x8f/q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x84\xea\x03\x00Etc/GMT+8UT\x05\x00\x03\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd4X\x9b\xf3q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x818\xeb\x03\x00E" + + "tc/GMT+5UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00" + + "\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xec\xeb\x03\x00Etc/ZuluUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" + + "\x00\x00#\x82iSJ0p-r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9d\xec\x03\x00Etc/GMT-7UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd0\xfaFDq\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81R\xed\x03\x00Etc/G" + + "MT+4UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf7\x19s\x81s\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x06\xee\x03\x00Etc/GMT-12UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xbd\xee\x03\x00Etc/UniversalUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9c\xfcm\x99r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81s\xef\x03\x00Etc" + + "/GMT-3UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\a\x00" + + "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81(\xf0\x03\x00Etc/GMTUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#" + + "\x82iS\xfc\x19@\xb9r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd8\xf0\x03\x00Etc/GMT-9UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd9|\xbd7s\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8d\xf1\x03\x00Etc/GMT-" + + "10UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x84\x19\xb3\tq\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\xa0\x81D\xf2\x03\x00Etc/GMT+9UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82i" + + "S!\xd6~wr\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf8\xf2\x03\x00Etc/GMT-5UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSj\xd5d\xb0r\x00\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xad\xf3\x03\x00Etc/GMT-6U" + + "T\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x90`N\xe8s\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\xa0\x81b\xf4\x03\x00Etc/GMT-13UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSP" + + "\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x19\xf5\x03\x00Etc/GreenwichUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS5\xb8\xe8\x86q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xcf\xf5\x03\x00Etc/GMT+" + + "1UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSe\xcb\xe9Qq\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x81\x83\xf6\x03\x00Etc/GMT+3UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS" + + "\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x817\xf7\x03\x00Etc/UTCUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x8e\x1569r\x00\x00\x00r\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe7\xf7\x03\x00Etc/GMT+10UT\x05" + + "\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\xa0\x81\x9d\xf8\x03\x00Etc/GMT-0UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x84+\x9a$" + + "q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81O\xf9\x03\x00Etc/GMT+7UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00P" + + "K\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe5\xf38cr\x00\x00\x00r\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x03\xfa\x03\x00Etc/GMT+12UT\x05\x00\x03" + + "\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSH\x9b\xd1\x04q\x00\x00\x00q\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0" + + "\x81\xb9\xfa\x03\x00Etc/GMT+6UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc5\x18\xb6\xfbr\x00" + + "\x00\x00r\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81m\xfb\x03\x00Etc/GMT-8UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01" + + "\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS)\xb9\xbe\x9dr\x00\x00\x00r\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\"\xfc\x03\x00Etc/GMT+11UT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS,{\xdc;s\x00\x00\x00s\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd8" + + "\xfc\x03\x00Etc/GMT-14UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSP\xda\xfa\x03o\x00\x00" + + "\x00o\x00\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8f\xfd\x03\x00Etc/GMT0UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e" + + "\x03\n\x00\x00\x00\x00\x00#\x82iSk\x19\xfe垛\x03\x00\x00\x9b\x03\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81ـ\x04\x00E" + + "urope/WarsawUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSIo\x11{\xd3\x02\x00\x00" + + "\xd3\x02\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xbb\x84\x04\x00Europe/BratislavaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd9L\xf6\xf7\xf1\x01\x00\x00\xf1\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81ه\x04\x00Europe/Stoc" + + "kholmUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x12\x00\x18" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x14\x8a\x04\x00Europe/Isle_of_ManUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01" + + "\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9f\x90\x04\x00Europe/GuernseyUT" + + "\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x03R\xda\xedU\x02\x00\x00U\x02\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\xa0\x81'\x97\x04\x00Europe/NicosiaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82" + + "iS\xc9\a\xa0\xe1/\x04\x00\x00/\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81ę\x04\x00Europe/AmsterdamUT\x05\x00\x03\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSo\xbc\x831O\x04\x00\x00O\x04\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81=\x9e\x04\x00Eu" + + "rope/BrusselsUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe1C\xf9\xa1\xde\x01\x00" + + "\x00\xde\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81բ\x04\x00Europe/BelgradeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSZ\x05wג\x02\x00\x00\x92\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xfc\xa4\x04\x00Europe/Vienn" + + "aUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x81է\x04\x00Europe/SarajevoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" + + "\x00\x00#\x82iS\xcb*j\x8f\xaa\x02\x00\x00\xaa\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xfc\xa9\x04\x00Europe/AthensUT\x05\x00\x03\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc7\xf5\x94\xdaQ\x04\x00\x00Q\x04\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xed\xac\x04\x00E" + + "urope/ParisUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe0\xfe\x83\xe5\xcd\x02\x00\x00\xcd" + + "\x02\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x84\xb1\x04\x00Europe/KirovUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01" + + "\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xea\xc48\xde\\\x02\x00\x00\\\x02\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x97\xb4\x04\x00Europe/TiraneUT\x05\x00" + + "\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe1C\xf9\xa1\xde\x01\x00\x00\xde\x01\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\xa0\x81:\xb7\x04\x00Europe/PodgoricaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82" + + "iS\xe5\xc8X\xa7\xe1\x01\x00\x00\xe1\x01\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81b\xb9\x04\x00Europe/HelsinkiUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8c\xbb\x04\x00Eur" + + "ope/JerseyUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS&S\x03\t\xae\x05\x00\x00\xae\x05" + + "\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x12\xc2\x04\x00Europe/LisbonUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01" + + "\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS8I\xdeN%\x02\x00\x00%\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\a\xc8\x04\x00Europe/KievUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSI\xb8\xbc\xd3\xf3\x02\x00\x00\xf3\x02\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "q\xca\x04\x00Europe/TiraspolUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSh" + + "\xa5J[\xa0\x03\x00\x00\xa0\x03\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xad\xcd\x04\x00Europe/MaltaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x95\xb4\x9e\xe7\xb3\x03\x00\x00\xb3\x03\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x93\xd1\x04\x00Europe/Sa" + + "n_MarinoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe6Kf\xab\xfe\x02\x00\x00\xfe\x02\x00\x00" + + "\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x91\xd5\x04\x00Europe/BudapestUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01" + + "\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa5\x97\aĤ\x02\x00\x00\xa4\x02\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd8\xd8\x04\x00Europe/OsloUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xab\x80c$q\x00\x00\x00q\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "\xc1\xdb\x04\x00FactoryUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSk\xa4,\xb6?\x06\x00\x00?" + + "\x06\x00\x00\x02\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81s\xdc\x04\x00GBUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#" + + "\x82iSk\xa4,\xb6?\x06\x00\x00?\x06\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xee\xe2\x04\x00GB-EireUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81n\xe9\x04\x00GMTUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1a" + + "\xea\x04\x00GMT+0UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00" + + "\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc8\xea\x04\x00GMT-0UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#" + + "\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81v\xeb\x04\x00GMT0UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSP\xda\xfa\x03o\x00\x00\x00o\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81#\xec\x04\x00GreenwichUT\x05\x00" + + "\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSE\t\xfa-\a\x03\x00\x00\a\x03\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00" + + "\xa0\x81\xd5\xec\x04\x00HongkongUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS=\xf7\xfawp\x00" + + "\x00\x00p\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1e\xf0\x04\x00HSTUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00" + + "\x00\x00\x00#\x82iSm\xbd\x10k\xf1\x02\x00\x00\xf1\x02\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xcb\xf0\x04\x00IcelandUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8A\xfd\xf3\x04\x00Indian" + + "/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSͲ\xfb\xf6\x8c\x00\x00\x00\x8c\x00\x00\x00\f\x00\x18\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\xa0\x81>\xf4\x04\x00Indian/CocosUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#" + + "\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x10\xf5\x04\x00Indian/AntananarivoUT\x05\x00\x03\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSx\xb0W\x14\x98\x00\x00\x00\x98\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1c\xf6" + + "\x04\x00Indian/ChagosUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ" + + "\x00\x00\x00\xbf\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xfb\xf6\x04\x00Indian/MayotteUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S" + + "_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS$l=҅\x00\x00\x00\x85\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x02\xf8\x04\x00Indian/Chri" + + "stmasUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb9\xb2Z\xac\x98\x00\x00\x00\x98\x00\x00\x00\x0f\x00\x18" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd1\xf8\x04\x00Indian/MaldivesUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03" + + "\n\x00\x00\x00\x00\x00#\x82iS\xb4\x8d\x98ƿ\x00\x00\x00\xbf\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb2\xf9\x04\x00Indian/ComoroUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x96\xed=\x98\xb3\x00\x00\x00\xb3\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb8" + + "\xfa\x04\x00Indian/MauritiusUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSa" + + "\x85jo\x85\x00\x00\x00\x85\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb5\xfb\x04\x00Indian/MaheUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb8K\xabυ\x00\x00\x00\x85\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\u007f\xfc\x04\x00Indian/Ker" + + "guelenUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSy(\xb6\x8f\x85\x00\x00\x00\x85\x00\x00\x00\x0e\x00" + + "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81N\xfd\x04\x00Indian/ReunionUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03" + + "\n\x00\x00\x00\x00\x00#\x82iS;\u007fP\x8d\xd4\a\x00\x00\xd4\a\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1b\xfe\x04\x00IranUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14" + + "E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x17✳2\x04\x00\x002\x04\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81-\x06\x05\x00Israel" + + "UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS%J\xd5\xebS\x01\x00\x00S\x01\x00\x00\a\x00\x18\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\xa0\x81\x9f\n\x05\x00JamaicaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x02\xf4\xae" + + "g\xd5\x00\x00\x00\xd5\x00\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x813\f\x05\x00JapanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf6\xe8]*\xdb\x00\x00\x00\xdb\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81G\r\x05\x00KwajaleinUT\x05\x00\x03\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS_\u007f2[\xaf\x01\x00\x00\xaf\x01\x00\x00\x05\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81e\x0e\x05" + + "\x00LibyaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xfe\x9d\x1b\xc9m\x02\x00\x00m\x02\x00\x00\x03\x00" + + "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81S\x10\x05\x00METUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00" + + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8A\xfd\x12\x05\x00Mexico/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00" + + "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xd6\xe1Հ\x9c\x01\x00\x00\x9c\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81>\x13\x05\x00Mexico/General" + + "UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS8\xcdZ\x05o\x01\x00\x00o\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\xa0\x81\"\x15\x05\x00Mexico/BajaSurUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00" + + "#\x82iS\xd0v\x01\x8a\x01\x04\x00\x00\x01\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd9\x16\x05\x00Mexico/BajaNorteUT\x05\x00\x03\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf5\x8d\x99\x92o\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81$\x1b\x05\x00" + + "MSTUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe6h\xcac\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x18\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd0\x1b\x05\x00MST7MDTUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS" + + "V\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc8\x1f\x05\x00NavajoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00" + + "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x02\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1a$\x05\x00NZUT\x05\x00\x03\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x96\xc5FF(\x03\x00\x00(\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81i(\x05\x00NZ" + + "-CHATUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x18" + + "\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8A\xd2+\x05\x00Pacific/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#" + + "\x82iS\x91\xd60\f\x9a\x00\x00\x00\x9a\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x14,\x05\x00Pacific/NiueUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04" + + "\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf4,\x05\x00Pacif" + + "ic/MidwayUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x80\xf8vܔ\x00\x00\x00\x94\x00\x00" + + "\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xce-\x05\x00Pacific/PalauUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02" + + "\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x97F\x91\xb3\xed\x00\x00\x00\xed\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xa9.\x05\x00Pacific/TongatapuU" + + "T\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xec =\x89\xac\x00\x00\x00\xac\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\xa0\x81\xe1/\x05\x00Pacific/EnderburyUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" + + "\x00\x00#\x82iS\x9e\u007f\xab\x95V\x01\x00\x00V\x01\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd80\x05\x00Pacific/EfateUT\x05\x00\x03\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x8a|\xdcU\x99\x00\x00\x00\x99\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81u2\x05\x00P" + + "acific/FakaofoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xea\xc1\xdaυ\x00" + + "\x00\x00\x85\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81W3\x05\x00Pacific/TahitiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS߃\xa0_\x86\x00\x00\x00\x86\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81$4\x05\x00Pacific/Wake" + + "UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\xa0\x81\xf04\x05\x00Pacific/Pago_PagoUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00" + + "\x00\x00\x00#\x82iSa\vೆ\x00\x00\x00\x86\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xcd5\x05\x00Pacific/FunafutiUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS6\xb7S{\x86\x00\x00\x00\x86\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9d" + + "6\x05\x00Pacific/TarawaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xcc\xf39" + + "a\xc3\x00\x00\x00\xc3\x00\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81k7\x05\x00Pacific/YapUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xb7\xef\x97\xc6\xc6\x00\x00\x00\xc6\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81s8\x05\x00Pacific/Noum" + + "eaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSD6\x83\xa1\x8b\x00\x00\x00\x8b\x00\x00\x00\x11\x00\x18\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x00\xa0\x81\x819\x05\x00Pacific/MarquesasUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n" + + "\x00\x00\x00\x00\x00#\x82iSY5\x1a6\xf7\x00\x00\x00\xf7\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81W:\x05\x00Pacific/NorfolkUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSY\xd2K|\x86\x00\x00\x00\x86\x00\x00\x00\x13\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "\x97;\x05\x00Pacific/GuadalcanalUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#" + + "\x82iS\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81j<\x05\x00Pacific/JohnstonUT\x05\x00\x03\x82\x0f\x8baux" + + "\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\u07b54-\xd6\x00\x00\x00\xd6\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x91=\x05\x00P" + + "acific/PonapeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe2;Z\xf7\xb7\x00\x00" + + "\x00\xb7\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xaf>\x05\x00Pacific/NauruUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00" + + "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSFI\xfe\x14^\x01\x00\x00^\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xad?\x05\x00Pacific/GuamUT" + + "\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSt\xca{e\x92\x00\x00\x00\x92\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\xa0\x81QA\x05\x00Pacific/SamoaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82i" + + "S\x81\xe3w\n\xaf\x00\x00\x00\xaf\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81*B\x05\x00Pacific/GalapagosUT\x05\x00\x03\x82\x0f\x8baux\v" + + "\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81$C\x05\x00Pa" + + "cific/HonoluluUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x97n7\x1a\xf2\x00" + + "\x00\x00\xf2\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81KD\x05\x00Pacific/KosraeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_" + + "\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc23\xa0\xbc\x84\x00\x00\x00\x84\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x85E\x05\x00Pacific/Gamb" + + "ierUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xfa\x0fA\x05\x99\x00\x00\x00\x99\x00\x00\x00\x10\x00\x18\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\xa0\x81RF\x05\x00Pacific/PitcairnUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n" + + "\x00\x00\x00\x00\x00#\x82iScF/.\xac\x01\x00\x00\xac\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x815G\x05\x00Pacific/FijiUT\x05\x00\x03\x82\x0f\x8ba" + + "ux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xec =\x89\xac\x00\x00\x00\xac\x00\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81'I\x05" + + "\x00Pacific/KantonUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\u07b54-\xd6" + + "\x00\x00\x00\xd6\x00\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1bJ\x05\x00Pacific/PohnpeiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9a\xf2:F\xc9\x00\x00\x00\xc9\x00\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81:K\x05\x00Pacific/Bo" + + "ugainvilleUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xca\"\xb8i\xda\x00\x00\x00\xda\x00" + + "\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81QL\x05\x00Pacific/MajuroUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK" + + "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSb\xb2\xaf\xf7\x13\x04\x00\x00\x13\x04\x00\x00\x10\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81sM\x05\x00Pacific/Auckland" + + "UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf6\xe8]*\xdb\x00\x00\x00\xdb\x00\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\xa0\x81\xd0Q\x05\x00Pacific/KwajaleinUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00" + + "\x00\x00\x00#\x82iSn\x04\x19y\x9a\x00\x00\x00\x9a\x00\x00\x00\x14\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf6R\x05\x00Pacific/Port_MoresbyUT\x05" + + "\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\r\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00" + + "\x00\xa0\x81\xdeS\x05\x00Pacific/ChuukUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS" + + "\xcc\xf39a\xc3\x00\x00\x00\xc3\x00\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe8T\x05\x00Pacific/TrukUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00" + + "\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc8=ku\xae\x00\x00\x00\xae\x00\x00\x00\x12\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf1U\x05\x00Pacific/" + + "KiritimatiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS1\xce_(\x86\x00\x00\x00\x86\x00" + + "\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xebV\x05\x00Pacific/WallisUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK" + + "\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x96\xc5FF(\x03\x00\x00(\x03\x00\x00\x0f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb9W\x05\x00Pacific/ChathamU" + + "T\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSFI\xfe\x14^\x01\x00\x00^\x01\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\xa0\x81*[\x05\x00Pacific/SaipanUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#" + + "\x82iS\xee\xd0\x1cYN\x04\x00\x00N\x04\x00\x00\x0e\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xd0\\\x05\x00Pacific/EasterUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xa8A\x15\xfe\x97\x01\x00\x00\x97\x01\x00\x00\f\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81fa\x05\x00Pac" + + "ific/ApiaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x1c\xe3\xa3S\x96\x01\x00\x00\x96\x01\x00" + + "\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81Cc\x05\x00Pacific/RarotongaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00" + + "PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS>\xfe垛\x03\x00\x00\x9b\x03\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81$e\x05\x00PolandUT\x05\x00\x03\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS&S\x03\t\xae\x05\x00\x00\xae\x05\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xffh" + + "\x05\x00PortugalUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS*\xe4@\xa9\x89\x01\x00\x00\x89\x01" + + "\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xefn\x05\x00PRCUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#" + + "\x82iSŭV\xad\xb7\x03\x00\x00\xb7\x03\x00\x00\a\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb5p\x05\x00PST8PDTUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04" + + "S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xee\xf0BB\xff\x01\x00\x00\xff\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xadt\x05\x00ROCUT\x05\x00\x03\x82\x0f" + + "\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xc7X,Y\x9f\x01\x00\x00\x9f\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xe9" + + "v\x05\x00ROKUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x06\xaa>\xa8\x00\x01\x00\x00\x00\x01\x00\x00\t\x00" + + "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc5x\x05\x00SingaporeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00" + + "\x00#\x82iS\aW\x10Ѱ\x04\x00\x00\xb0\x04\x00\x00\x06\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\bz\x05\x00TurkeyUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00" + + "\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf8~\x05\x00UCTUT\x05\x00\x03\x82" + + "\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81" + + "\xa4\u007f\x05\x00UniversalUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x00\x00\x00\x00\x00\x00\x00" + + "\x00\x00\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x10\x00\xe8AV\x80\x05\x00US/UT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00" + + "\x00\x00#\x82iSV\x80\x94@\x12\x04\x00\x00\x12\x04\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x93\x80\x05\x00US/MountainUT\x05\x00\x03\x82\x0f\x8baux\v\x00" + + "\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS5\x11Q\x06\xd1\x03\x00\x00\xd1\x03\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xea\x84\x05\x00US/" + + "AlaskaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSp\xb6{\xc9\x13\x02\x00\x00\x13\x02\x00\x00\x0f\x00" + + "\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xfe\x88\x05\x00US/East-IndianaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e" + + "\x03\n\x00\x00\x00\x00\x00#\x82iS\xae,\xa44\xc9\x03\x00\x00\xc9\x03\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81Z\x8b\x05\x00US/AleutianUT\x05\x00\x03\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xeaK\x85v\xdd\x00\x00\x00\xdd\x00\x00\x00\t\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81h\x8f" + + "\x05\x00US/HawaiiUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS3\x9aG\xc8\xd0\x06\x00\x00\xd0" + + "\x06\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x88\x90\x05\x00US/EasternUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e" + + "\x03\n\x00\x00\x00\x00\x00#\x82iS>\x14\xe7\x03\x83\x03\x00\x00\x83\x03\x00\x00\v\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x9c\x97\x05\x00US/MichiganUT\x05\x00\x03\x82\x0f\x8b" + + "aux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xf6\"\x12\xfe\x0e\x05\x00\x00\x0e\x05\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81d\x9b" + + "\x05\x00US/PacificUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iSt\xca{e\x92\x00\x00\x00" + + "\x92\x00\x00\x00\b\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xb6\xa0\x05\x00US/SamoaUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03" + + "\n\x00\x00\x00\x00\x00#\x82iSø\xab\x9b\xf0\x00\x00\x00\xf0\x00\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x8a\xa1\x05\x00US/ArizonaUT\x05\x00\x03\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9bܩ=\xda\x06\x00\x00\xda\x06\x00\x00\n\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xbe\xa2\x05\x00" + + "US/CentralUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS$ \x873\xf8\x03\x00\x00\xf8\x03" + + "\x00\x00\x11\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81ܩ\x05\x00US/Indiana-StarkeUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01" + + "\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9f.\xe4xo\x00\x00\x00o\x00\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\x1f\xae\x05\x00UTCUT\x05\x00\x03\x82\x0f\x8bau" + + "x\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS2\x91B\xc0\xee\x01\x00\x00\xee\x01\x00\x00\x03\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81ˮ\x05\x00" + + "WETUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\xe1\xc1\xeb\x05\x8c\x03\x00\x00\x8c\x03\x00\x00\x04\x00\x18\x00\x00" + + "\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xf6\xb0\x05\x00W-SUUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x01\x02\x1e\x03\n\x00\x00\x00\x00\x00#\x82iS\x9f.\xe4" + + "xo\x00\x00\x00o\x00\x00\x00\x04\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x81\xc0\xb4\x05\x00ZuluUT\x05\x00\x03\x82\x0f\x8baux\v\x00\x01\x04\x14E\x00\x00\x04S_\x01\x00PK\x05\x06\x00" + + "\x00\x00\x00g\x02g\x02\xea\xc9\x00\x00m\xb5\x05\x00\x00\x00" From 1ec51087e57d242e5556210a426307984d9ef0b3 Mon Sep 17 00:00:00 2001 From: Dmitry Vyukov Date: Wed, 10 Nov 2021 19:51:34 +0100 Subject: [PATCH 094/752] cmd/link/internal/loadelf: better error message for ignored symbols Currently it's quite hard to debug these error messages about ignored symbols because there are only some numbers and no symbol name. Add symbol name. Before: 135029: sym#952: ignoring symbol in section 11 (type 0) After: 135029: sym#952 (_ZN11__sanitizer9SpinMutexC5Ev): ignoring symbol in section 11 (type 0) Change-Id: I7fec50b5798068c74827376613be529803838c5a Reviewed-on: https://go-review.googlesource.com/c/go/+/363034 Run-TryBot: Dmitry Vyukov TryBot-Result: Go Bot Reviewed-by: Ian Lance Taylor Trust: Dmitry Vyukov --- src/cmd/link/internal/loadelf/ldelf.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cmd/link/internal/loadelf/ldelf.go b/src/cmd/link/internal/loadelf/ldelf.go index b4f565a153..d05d8e3b4b 100644 --- a/src/cmd/link/internal/loadelf/ldelf.go +++ b/src/cmd/link/internal/loadelf/ldelf.go @@ -599,7 +599,7 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, f *bio.Reader, if strings.HasPrefix(elfsym.name, ".LASF") { // gcc on s390x does this continue } - return errorf("%v: sym#%d: ignoring symbol in section %d (type %d)", elfsym.sym, i, elfsym.shndx, elfsym.type_) + return errorf("%v: sym#%d (%s): ignoring symbol in section %d (type %d)", elfsym.sym, i, elfsym.name, elfsym.shndx, elfsym.type_) } s := elfsym.sym From a01a6d6efea52802f455849cd52ef7f8d049033a Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Wed, 10 Nov 2021 01:04:12 +0100 Subject: [PATCH 095/752] net: add conversion from AddrPort to TCPAddr to complement existing inverse We already have various member functions of TCPAddr that return an AddrPort, but we don't have a helper function to go from a AddrPort to a TCPAddr. UDP has this, but it was left out of TCP. This commit adds the corresponding function. Updates #49298. Change-Id: I85732cf34f47c792fe13a6b4af64fd4b0e85d06a Reviewed-on: https://go-review.googlesource.com/c/go/+/362596 Trust: Jason A. Donenfeld Run-TryBot: Jason A. Donenfeld TryBot-Result: Go Bot Reviewed-by: Brad Fitzpatrick --- src/net/tcpsock.go | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/net/tcpsock.go b/src/net/tcpsock.go index fddb018aab..6bad0e8f8b 100644 --- a/src/net/tcpsock.go +++ b/src/net/tcpsock.go @@ -96,6 +96,17 @@ func ResolveTCPAddr(network, address string) (*TCPAddr, error) { return addrs.forResolve(network, address).(*TCPAddr), nil } +// TCPAddrFromAddrPort returns addr as a TCPAddr. If addr.IsValid() is false, +// then the returned TCPAddr will contain a nil IP field, indicating an +// address family-agnostic unspecified address. +func TCPAddrFromAddrPort(addr netip.AddrPort) *TCPAddr { + return &TCPAddr{ + IP: addr.Addr().AsSlice(), + Zone: addr.Addr().Zone(), + Port: int(addr.Port()), + } +} + // TCPConn is an implementation of the Conn interface for TCP network // connections. type TCPConn struct { From e9ef931e0649563e800f0a284ad3606564a88b35 Mon Sep 17 00:00:00 2001 From: Than McIntosh Date: Mon, 8 Nov 2021 13:53:55 -0500 Subject: [PATCH 096/752] cmd/compile/internal/ssa: fix debug location gen issue with zero width ops Revamp the way that buildLocationLists() handles zero-width operations, to fix a couple of problems that result in bad debug locations. The problematic scenario in this specific bug is where you have a parameter arriving in a register X, then a spill of register X to memory as the first non-zero-width instruction in the function. Example: v68 = ArgIntReg {ctx+0} [1] : BX (ctx[unsafe.Pointer]) v67 = ArgIntReg {ctx+8} [2] : CX (ctx+8[unsafe.Pointer]) ... v281 = StoreReg v67 : ctx+8[unsafe.Pointer] The existing buildLocationLists implementation effectively buffers or bundles changes from zero-width instructions until it it sees a non-zero-width instruction, but doing that in this case winds up making it look as though the parameter is live into the function in memory, not in a register. The fix for this to separate out zero-width ops into two distinct categories: those that whose lifetimes begin at block start (ex: OpArg, Phi) and those whose effects are taking place at the nearest non-zero-width instruction (ex: OpSelect0). In this patch we now handle the first category of ops in an initial pre-pass for each block, and leave the second category for the main pass through the block. See the notes on the issue below for a more detailed explanation of the failure mode. Fixes #46845. Change-Id: I27488d4c041019d5a0b897b7cf53000f63aab1cf Reviewed-on: https://go-review.googlesource.com/c/go/+/362244 Trust: Than McIntosh Run-TryBot: Than McIntosh TryBot-Result: Go Bot Reviewed-by: David Chase --- src/cmd/compile/internal/ssa/debug.go | 89 +++++++++++++++++++-------- 1 file changed, 64 insertions(+), 25 deletions(-) diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go index e78eb5c0e4..fed152efba 100644 --- a/src/cmd/compile/internal/ssa/debug.go +++ b/src/cmd/compile/internal/ssa/debug.go @@ -1120,54 +1120,93 @@ func (state *debugState) buildLocationLists(blockLocs []*BlockDebug) { v.Op == OpArgIntReg || v.Op == OpArgFloatReg } + blockPrologComplete := func(v *Value) bool { + if b.ID != state.f.Entry.ID { + return !opcodeTable[v.Op].zeroWidth + } else { + return v.Op == OpInitMem + } + } + + // Examine the prolog portion of the block to process special + // zero-width ops such as Arg, Phi, LoweredGetClosurePtr (etc) + // whose lifetimes begin at the block starting point. In an + // entry block, allow for the possibility that we may see Arg + // ops that appear _after_ other non-zero-width operations. + // Example: + // + // v33 = ArgIntReg {foo+0} [0] : AX (foo) + // v34 = ArgIntReg {bar+0} [0] : BX (bar) + // ... + // v77 = StoreReg v67 : ctx+8[unsafe.Pointer] + // v78 = StoreReg v68 : ctx[unsafe.Pointer] + // v79 = Arg <*uint8> {args} : args[*uint8] (args[*uint8]) + // v80 = Arg {args} [8] : args+8[int] (args+8[int]) + // ... + // v1 = InitMem + // + // We can stop scanning the initial portion of the block when + // we either see the InitMem op (for entry blocks) or the + // first non-zero-width op (for other blocks). + for idx := 0; idx < len(b.Values); idx++ { + v := b.Values[idx] + if blockPrologComplete(v) { + break + } + // Consider only "lifetime begins at block start" ops. + if !mustBeFirst(v) && v.Op != OpArg { + continue + } + slots := state.valueNames[v.ID] + reg, _ := state.f.getHome(v.ID).(*Register) + changed := state.processValue(v, slots, reg) // changed == added to state.changedVars + if changed { + for _, varID := range state.changedVars.contents() { + state.updateVar(VarID(varID), v.Block, BlockStart) + } + state.changedVars.clear() + } + } + + // Now examine the block again, handling things other than the + // "begins at block start" lifetimes. zeroWidthPending := false - blockPrologComplete := false // set to true at first non-zero-width op - apcChangedSize := 0 // size of changedVars for leading Args, Phi, ClosurePtr + prologComplete := false // expect to see values in pattern (apc)* (zerowidth|real)* for _, v := range b.Values { + if blockPrologComplete(v) { + prologComplete = true + } slots := state.valueNames[v.ID] reg, _ := state.f.getHome(v.ID).(*Register) changed := state.processValue(v, slots, reg) // changed == added to state.changedVars if opcodeTable[v.Op].zeroWidth { + if prologComplete && mustBeFirst(v) { + panic(fmt.Errorf("Unexpected placement of op '%s' appearing after non-pseudo-op at beginning of block %s in %s\n%s", v.LongString(), b, b.Func.Name, b.Func)) + } if changed { if mustBeFirst(v) || v.Op == OpArg { - // These ranges begin at true beginning of block, not after first instruction - if blockPrologComplete && mustBeFirst(v) { - panic(fmt.Errorf("Unexpected placement of op '%s' appearing after non-pseudo-op at beginning of block %s in %s\n%s", v.LongString(), b, b.Func.Name, b.Func)) - } - apcChangedSize = len(state.changedVars.contents()) - // Other zero-width ops must wait on a "real" op. - zeroWidthPending = true + // already taken care of above continue } + zeroWidthPending = true } continue } - if !changed && !zeroWidthPending { continue } - // Not zero-width; i.e., a "real" instruction. + // Not zero-width; i.e., a "real" instruction. zeroWidthPending = false - blockPrologComplete = true - for i, varID := range state.changedVars.contents() { - if i < apcChangedSize { // buffered true start-of-block changes - state.updateVar(VarID(varID), v.Block, BlockStart) - } else { - state.updateVar(VarID(varID), v.Block, v) - } + for _, varID := range state.changedVars.contents() { + state.updateVar(VarID(varID), v.Block, v) } state.changedVars.clear() - apcChangedSize = 0 } - for i, varID := range state.changedVars.contents() { - if i < apcChangedSize { // buffered true start-of-block changes - state.updateVar(VarID(varID), b, BlockStart) - } else { - state.updateVar(VarID(varID), b, BlockEnd) - } + for _, varID := range state.changedVars.contents() { + state.updateVar(VarID(varID), b, BlockEnd) } prevBlock = b From 79e03a9281ba03f9f79904f074e2e343f2140bdd Mon Sep 17 00:00:00 2001 From: Than McIntosh Date: Wed, 10 Nov 2021 10:44:00 -0500 Subject: [PATCH 097/752] cmd/compile: include register-resident output params in DWARF-gen During the register ABI work, a change was made in CL 302071 to "stackframe" to treat register-resident output parameter (PARAMOUT) variables that same as locals, which meant that if they were unused, we'd delete them from the "Dcl" slice. This has the effect of making them invisible to DWARF generation later on in the pipeline, meaning that we don't get DIEs for them in the debug info. This patch fixes the problem by capturing these params prior to optimization and then adding them back in for consideration when we're processing the params/locals of a function during DWARF generation. Fixes #48573. Change-Id: I2b32882911c18f91c3e3d009486517522d262685 Reviewed-on: https://go-review.googlesource.com/c/go/+/362618 Trust: Than McIntosh Run-TryBot: Than McIntosh TryBot-Result: Go Bot Reviewed-by: David Chase --- src/cmd/compile/internal/dwarfgen/dwarf.go | 13 + src/cmd/compile/internal/ssa/debug.go | 40 ++-- src/cmd/compile/internal/ssagen/ssa.go | 19 +- src/cmd/link/internal/ld/dwarf_test.go | 266 +++++++++++++++++---- 4 files changed, 268 insertions(+), 70 deletions(-) diff --git a/src/cmd/compile/internal/dwarfgen/dwarf.go b/src/cmd/compile/internal/dwarfgen/dwarf.go index 3007262db9..e249a52e57 100644 --- a/src/cmd/compile/internal/dwarfgen/dwarf.go +++ b/src/cmd/compile/internal/dwarfgen/dwarf.go @@ -150,6 +150,19 @@ func createDwarfVars(fnsym *obj.LSym, complexOK bool, fn *ir.Func, apDecls []*ir dcl := apDecls if fnsym.WasInlined() { dcl = preInliningDcls(fnsym) + } else { + // The backend's stackframe pass prunes away entries from the + // fn's Dcl list, including PARAMOUT nodes that correspond to + // output params passed in registers. Add back in these + // entries here so that we can process them properly during + // DWARF-gen. See issue 48573 for more details. + debugInfo := fn.DebugInfo.(*ssa.FuncDebug) + for _, n := range debugInfo.RegOutputParams { + if n.Class != ir.PPARAMOUT || !n.IsOutputParamInRegisters() { + panic("invalid ir.Name on debugInfo.RegOutputParams list") + } + dcl = append(dcl, n) + } } // If optimization is enabled, the list above will typically be diff --git a/src/cmd/compile/internal/ssa/debug.go b/src/cmd/compile/internal/ssa/debug.go index fed152efba..aad59fa24e 100644 --- a/src/cmd/compile/internal/ssa/debug.go +++ b/src/cmd/compile/internal/ssa/debug.go @@ -34,6 +34,9 @@ type FuncDebug struct { VarSlots [][]SlotID // The location list data, indexed by VarID. Must be processed by PutLocationList. LocationLists [][]byte + // Register-resident output parameters for the function. This is filled in at + // SSA generation time. + RegOutputParams []*ir.Name // Filled in by the user. Translates Block and Value ID to PC. GetPC func(ID, ID) int64 @@ -548,10 +551,10 @@ func PopulateABIInRegArgOps(f *Func) { f.Entry.Values = append(newValues, f.Entry.Values...) } -// BuildFuncDebug returns debug information for f. +// BuildFuncDebug debug information for f, placing the results in "rval". // f must be fully processed, so that each Value is where it will be when // machine code is emitted. -func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset func(LocalSlot) int32) *FuncDebug { +func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset func(LocalSlot) int32, rval *FuncDebug) { if f.RegAlloc == nil { f.Fatalf("BuildFuncDebug on func %v that has not been fully processed", f) } @@ -661,12 +664,11 @@ func BuildFuncDebug(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset fu blockLocs := state.liveness() state.buildLocationLists(blockLocs) - return &FuncDebug{ - Slots: state.slots, - VarSlots: state.varSlots, - Vars: state.vars, - LocationLists: state.lists, - } + // Populate "rval" with what we've computed. + rval.Slots = state.slots + rval.VarSlots = state.varSlots + rval.Vars = state.vars + rval.LocationLists = state.lists } // liveness walks the function in control flow order, calculating the start @@ -1593,7 +1595,7 @@ func isNamedRegParam(p abi.ABIParamAssignment) bool { return true } -// BuildFuncDebugNoOptimized constructs a FuncDebug object with +// BuildFuncDebugNoOptimized populates a FuncDebug object "rval" with // entries corresponding to the register-resident input parameters for // the function "f"; it is used when we are compiling without // optimization but the register ABI is enabled. For each reg param, @@ -1601,8 +1603,7 @@ func isNamedRegParam(p abi.ABIParamAssignment) bool { // the input register, and the second element holds the stack location // of the param (the assumption being that when optimization is off, // each input param reg will be spilled in the prolog. -func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset func(LocalSlot) int32) *FuncDebug { - fd := FuncDebug{} +func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, stackOffset func(LocalSlot) int32, rval *FuncDebug) { pri := f.ABISelf.ABIAnalyzeFuncType(f.Type.FuncType()) @@ -1616,7 +1617,7 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta } } if numRegParams == 0 { - return &fd + return } state := debugState{f: f} @@ -1626,7 +1627,7 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta } // Allocate location lists. - fd.LocationLists = make([][]byte, numRegParams) + rval.LocationLists = make([][]byte, numRegParams) // Locate the value corresponding to the last spill of // an input register. @@ -1642,10 +1643,10 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta n := inp.Name.(*ir.Name) sl := LocalSlot{N: n, Type: inp.Type, Off: 0} - fd.Vars = append(fd.Vars, n) - fd.Slots = append(fd.Slots, sl) - slid := len(fd.VarSlots) - fd.VarSlots = append(fd.VarSlots, []SlotID{SlotID(slid)}) + rval.Vars = append(rval.Vars, n) + rval.Slots = append(rval.Slots, sl) + slid := len(rval.VarSlots) + rval.VarSlots = append(rval.VarSlots, []SlotID{SlotID(slid)}) if afterPrologVal == ID(-1) { // This can happen for degenerate functions with infinite @@ -1662,7 +1663,7 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta // Param is arriving in one or more registers. We need a 2-element // location expression for it. First entry in location list // will correspond to lifetime in input registers. - list, sizeIdx := setupLocList(ctxt, f, fd.LocationLists[pidx], + list, sizeIdx := setupLocList(ctxt, f, rval.LocationLists[pidx], BlockStart.ID, afterPrologVal) if list == nil { pidx++ @@ -1727,8 +1728,7 @@ func BuildFuncDebugNoOptimized(ctxt *obj.Link, f *Func, loggingEnabled bool, sta // fill in size ctxt.Arch.ByteOrder.PutUint16(list[sizeIdx:], uint16(len(list)-sizeIdx-2)) - fd.LocationLists[pidx] = list + rval.LocationLists[pidx] = list pidx++ } - return &fd } diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go index 0853242e6f..d6407af334 100644 --- a/src/cmd/compile/internal/ssagen/ssa.go +++ b/src/cmd/compile/internal/ssagen/ssa.go @@ -484,6 +484,19 @@ func buildssa(fn *ir.Func, worker int) *ssa.Func { var params *abi.ABIParamResultInfo params = s.f.ABISelf.ABIAnalyze(fn.Type(), true) + // The backend's stackframe pass prunes away entries from the fn's + // Dcl list, including PARAMOUT nodes that correspond to output + // params passed in registers. Walk the Dcl list and capture these + // nodes to a side list, so that we'll have them available during + // DWARF-gen later on. See issue 48573 for more details. + var debugInfo ssa.FuncDebug + for _, n := range fn.Dcl { + if n.Class == ir.PPARAMOUT && n.IsOutputParamInRegisters() { + debugInfo.RegOutputParams = append(debugInfo.RegOutputParams, n) + } + } + fn.DebugInfo = &debugInfo + // Generate addresses of local declarations s.decladdrs = map[*ir.Name]*ssa.Value{} for _, n := range fn.Dcl { @@ -7003,12 +7016,12 @@ func genssa(f *ssa.Func, pp *objw.Progs) { if base.Ctxt.Flag_locationlists { var debugInfo *ssa.FuncDebug + debugInfo = e.curfn.DebugInfo.(*ssa.FuncDebug) if e.curfn.ABI == obj.ABIInternal && base.Flag.N != 0 { - debugInfo = ssa.BuildFuncDebugNoOptimized(base.Ctxt, f, base.Debug.LocationLists > 1, StackOffset) + ssa.BuildFuncDebugNoOptimized(base.Ctxt, f, base.Debug.LocationLists > 1, StackOffset, debugInfo) } else { - debugInfo = ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, StackOffset) + ssa.BuildFuncDebug(base.Ctxt, f, base.Debug.LocationLists > 1, StackOffset, debugInfo) } - e.curfn.DebugInfo = debugInfo bstart := s.bstart idToIdx := make([]int, f.NumBlocks()) for i, b := range f.Blocks { diff --git a/src/cmd/link/internal/ld/dwarf_test.go b/src/cmd/link/internal/ld/dwarf_test.go index db9002491e..9a163488e6 100644 --- a/src/cmd/link/internal/ld/dwarf_test.go +++ b/src/cmd/link/internal/ld/dwarf_test.go @@ -1635,6 +1635,66 @@ func TestIssue42484(t *testing.T) { f.Close() } +// processParams examines the formal parameter children of subprogram +// DIE "die" using the explorer "ex" and returns a string that +// captures the name, order, and classification of the subprogram's +// input and output parameters. For example, for the go function +// +// func foo(i1 int, f1 float64) (string, bool) { +// +// this function would return a string something like +// +// i1:0:1 f1:1:1 ~r0:2:2 ~r1:3:2 +// +// where each chunk above is of the form NAME:ORDER:INOUTCLASSIFICATION +// +func processParams(die *dwarf.Entry, ex *examiner) string { + // Values in the returned map are of the form : + // where order is the order within the child DIE list of the + // param, and is an integer: + // + // -1: varparm attr not found + // 1: varparm found with value false + // 2: varparm found with value true + // + foundParams := make(map[string]string) + + // Walk ABCs's children looking for params. + abcIdx := ex.idxFromOffset(die.Offset) + childDies := ex.Children(abcIdx) + idx := 0 + for _, child := range childDies { + if child.Tag == dwarf.TagFormalParameter { + // NB: a setting of DW_AT_variable_parameter indicates + // that the param in question is an output parameter; we + // want to see this attribute set to TRUE for all Go + // return params. It would be OK to have it missing for + // input parameters, but for the moment we verify that the + // attr is present but set to false. + st := -1 + if vp, ok := child.Val(dwarf.AttrVarParam).(bool); ok { + if vp { + st = 2 + } else { + st = 1 + } + } + if name, ok := child.Val(dwarf.AttrName).(string); ok { + foundParams[name] = fmt.Sprintf("%d:%d", idx, st) + idx++ + } + } + } + + found := make([]string, 0, len(foundParams)) + for k, v := range foundParams { + found = append(found, fmt.Sprintf("%s:%s", k, v)) + } + sort.Strings(found) + + return fmt.Sprintf("%+v", found) +} + func TestOutputParamAbbrevAndAttr(t *testing.T) { testenv.MustHaveGoBuild(t) @@ -1694,56 +1754,15 @@ func main() { t.Fatalf("unexpected tag %v on main.ABC DIE", abcdie.Tag) } - // A setting of DW_AT_variable_parameter indicates that the - // param in question is an output parameter; we want to see this - // attribute set to TRUE for all Go return params. It would be - // OK to have it missing for input parameters, but for the moment - // we verify that the attr is present but set to false. - - // Values in this map are of the form : - // where order is the order within the child DIE list of the param, - // and is an integer: - // - // -1: varparm attr not found - // 1: varparm found with value false - // 2: varparm found with value true - // - foundParams := make(map[string]string) - - // Walk ABCs's children looking for params. - abcIdx := ex.idxFromOffset(abcdie.Offset) - childDies := ex.Children(abcIdx) - idx := 0 - for _, child := range childDies { - if child.Tag == dwarf.TagFormalParameter { - st := -1 - if vp, ok := child.Val(dwarf.AttrVarParam).(bool); ok { - if vp { - st = 2 - } else { - st = 1 - } - } - if name, ok := child.Val(dwarf.AttrName).(string); ok { - foundParams[name] = fmt.Sprintf("%d:%d", idx, st) - idx++ - } - } - } - - // Digest the result. - found := make([]string, 0, len(foundParams)) - for k, v := range foundParams { - found = append(found, fmt.Sprintf("%s:%s", k, v)) - } - sort.Strings(found) + // Call a helper to collect param info. + found := processParams(abcdie, &ex) // Make sure we see all of the expected params in the proper - // order, that they have the varparam attr, and the varparm is set - // for the returns. + // order, that they have the varparam attr, and the varparam is + // set for the returns. expected := "[c1:0:1 c2:1:1 c3:2:1 d1:3:1 d2:4:1 d3:5:1 d4:6:1 f1:7:1 f2:8:1 f3:9:1 g1:10:1 r1:11:2 r2:12:2 r3:13:2 r4:14:2 r5:15:2 r6:16:2]" - if fmt.Sprintf("%+v", found) != expected { - t.Errorf("param check failed, wanted %s got %s\n", + if found != expected { + t.Errorf("param check failed, wanted:\n%s\ngot:\n%s\n", expected, found) } } @@ -1849,3 +1868,156 @@ func main() { } } } + +func TestOptimizedOutParamHandling(t *testing.T) { + testenv.MustHaveGoBuild(t) + + if runtime.GOOS == "plan9" { + t.Skip("skipping on plan9; no DWARF symbol table in executables") + } + t.Parallel() + + // This test is intended to verify that the compiler emits DWARF + // DIE entries for all input and output parameters, and that: + // + // - attributes are set correctly for output params, + // - things appear in the proper order + // - things work properly for both register-resident + // params and params passed on the stack + // - things work for both referenced and unreferenced params + // - things work for named return values un-named return vals + // + // The scenarios below don't cover all possible permutations and + // combinations, but they hit a bunch of the high points. + + const prog = ` +package main + +// First testcase. All input params in registers, all params used. + +//go:noinline +func tc1(p1, p2 int, p3 string) (int, string) { + return p1 + p2, p3 + "foo" +} + +// Second testcase. Some params in registers, some on stack. + +//go:noinline +func tc2(p1 int, p2 [128]int, p3 string) (int, string, [128]int) { + return p1 + p2[p1], p3 + "foo", [128]int{p1} +} + +// Third testcase. Named return params. + +//go:noinline +func tc3(p1 int, p2 [128]int, p3 string) (r1 int, r2 bool, r3 string, r4 [128]int) { + if p1 == 101 { + r1 = p1 + p2[p1] + r2 = p3 == "foo" + r4 = [128]int{p1} + return + } else { + return p1 - p2[p1+3], false, "bar", [128]int{p1 + 2} + } +} + +// Fourth testcase. Some thing are used, some are unused. + +//go:noinline +func tc4(p1, p1un int, p2, p2un [128]int, p3, p3un string) (r1 int, r1un int, r2 bool, r3 string, r4, r4un [128]int) { + if p1 == 101 { + r1 = p1 + p2[p2[0]] + r2 = p3 == "foo" + r4 = [128]int{p1} + return + } else { + return p1, -1, true, "plex", [128]int{p1 + 2}, [128]int{-1} + } +} + +func main() { + { + r1, r2 := tc1(3, 4, "five") + println(r1, r2) + } + { + x := [128]int{9} + r1, r2, r3 := tc2(3, x, "five") + println(r1, r2, r3[0]) + } + { + x := [128]int{9} + r1, r2, r3, r4 := tc3(3, x, "five") + println(r1, r2, r3, r4[0]) + } + { + x := [128]int{3} + y := [128]int{7} + r1, r1u, r2, r3, r4, r4u := tc4(0, 1, x, y, "a", "b") + println(r1, r1u, r2, r3, r4[0], r4u[1]) + } + +} +` + dir := t.TempDir() + f := gobuild(t, dir, prog, DefaultOpt) + defer f.Close() + + d, err := f.DWARF() + if err != nil { + t.Fatalf("error reading DWARF: %v", err) + } + + rdr := d.Reader() + ex := examiner{} + if err := ex.populate(rdr); err != nil { + t.Fatalf("error reading DWARF: %v", err) + } + + testcases := []struct { + tag string + expected string + }{ + { + tag: "tc1", + expected: "[p1:0:1 p2:1:1 p3:2:1 ~r0:3:2 ~r1:4:2]", + }, + { + tag: "tc2", + expected: "[p1:0:1 p2:1:1 p3:2:1 ~r0:3:2 ~r1:4:2 ~r2:5:2]", + }, + { + tag: "tc3", + expected: "[p1:0:1 p2:1:1 p3:2:1 r1:3:2 r2:4:2 r3:5:2 r4:6:2]", + }, + { + tag: "tc4", + expected: "[p1:0:1 p1un:1:1 p2:2:1 p2un:3:1 p3:4:1 p3un:5:1 r1:6:2 r1un:7:2 r2:8:2 r3:9:2 r4:10:2 r4un:11:2]", + }, + } + + for _, tc := range testcases { + // Locate the proper DIE + which := fmt.Sprintf("main.%s", tc.tag) + tcs := ex.Named(which) + if len(tcs) == 0 { + t.Fatalf("unable to locate DIE for " + which) + } + if len(tcs) != 1 { + t.Fatalf("more than one " + which + " DIE") + } + die := tcs[0] + + // Vet the DIE + if die.Tag != dwarf.TagSubprogram { + t.Fatalf("unexpected tag %v on "+which+" DIE", die.Tag) + } + + // Examine params for this subprogram. + foundParams := processParams(die, &ex) + if foundParams != tc.expected { + t.Errorf("check failed for testcase %s -- wanted:\n%s\ngot:%s\n", + tc.tag, tc.expected, foundParams) + } + } +} From c49627e81b05f23f97544fc6bfae3347296b4a06 Mon Sep 17 00:00:00 2001 From: Than McIntosh Date: Wed, 10 Nov 2021 15:36:25 -0500 Subject: [PATCH 098/752] cmd/compile: use canonical stringslice/ representations in abiutils A chunk of code in abiutils was synthesizing the internals of a Go string type as "struct { unsafe.Pointer, uintptr }" instead of the more canonical representation "struct { *uint8, int }" used elsewhere in the compiler. The abiutils type was being pulled into the code during late call expansion, which resulted in two different entries in the SSA named value table for the same variable piece, each with different types; this then confused DWARF location list generation. This patch changes the abiutils synthesized type to be consistent with other parts of the back end, and makes a similar change for synthesized slice types (use "struct { *uint8, int, int }"). Fixes #47354. Change-Id: If789031cdc7abaf215bc75ee6eb863defbe530be Reviewed-on: https://go-review.googlesource.com/c/go/+/362715 Trust: Than McIntosh Run-TryBot: Than McIntosh TryBot-Result: Go Bot Reviewed-by: Cherry Mui --- src/cmd/compile/internal/abi/abiutils.go | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/src/cmd/compile/internal/abi/abiutils.go b/src/cmd/compile/internal/abi/abiutils.go index 74c8707b29..529150a390 100644 --- a/src/cmd/compile/internal/abi/abiutils.go +++ b/src/cmd/compile/internal/abi/abiutils.go @@ -715,19 +715,20 @@ func setup() { synthOnce.Do(func() { fname := types.BuiltinPkg.Lookup nxp := src.NoXPos - unsp := types.Types[types.TUNSAFEPTR] - ui := types.Types[types.TUINTPTR] + bp := types.NewPtr(types.Types[types.TUINT8]) + it := types.Types[types.TINT] 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), + types.NewField(nxp, fname("ptr"), bp), + types.NewField(nxp, fname("len"), it), + types.NewField(nxp, fname("cap"), it), }) types.CalcStructSize(synthSlice) synthString = types.NewStruct(types.NoPkg, []*types.Field{ - types.NewField(nxp, fname("data"), unsp), - types.NewField(nxp, fname("len"), ui), + types.NewField(nxp, fname("data"), bp), + types.NewField(nxp, fname("len"), it), }) types.CalcStructSize(synthString) + unsp := types.Types[types.TUNSAFEPTR] synthIface = types.NewStruct(types.NoPkg, []*types.Field{ types.NewField(nxp, fname("f1"), unsp), types.NewField(nxp, fname("f2"), unsp), From d76b1ac3e1919bd863e7e906202ae085cb20f595 Mon Sep 17 00:00:00 2001 From: Than McIntosh Date: Thu, 11 Nov 2021 07:06:24 -0500 Subject: [PATCH 099/752] net: skip new testpoint TestUDPIPVersionReadMsg on plan9 Skip TestUDPIPVersionReadMsg on plan9, since it does things not supported on that OS. Change-Id: Icd1716fb5ed4e8877e57acb8c851ec3be72e83e2 Reviewed-on: https://go-review.googlesource.com/c/go/+/363354 Reviewed-by: Jason A. Donenfeld Trust: Jason A. Donenfeld Trust: Than McIntosh Run-TryBot: Jason A. Donenfeld Run-TryBot: Than McIntosh TryBot-Result: Go Bot --- src/net/udpsock_test.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go index 01b8d39216..8ccdb365ab 100644 --- a/src/net/udpsock_test.go +++ b/src/net/udpsock_test.go @@ -605,6 +605,10 @@ func BenchmarkWriteToReadFromUDPAddrPort(b *testing.B) { } func TestUDPIPVersionReadMsg(t *testing.T) { + switch runtime.GOOS { + case "plan9": + t.Skipf("skipping on %v", runtime.GOOS) + } conn, err := ListenUDP("udp4", &UDPAddr{IP: IPv4(127, 0, 0, 1)}) if err != nil { t.Fatal(err) From 47b3ab5ede452a88c2da4c5eaf092b2d707d2ff4 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 10 Nov 2021 16:57:14 -0500 Subject: [PATCH 100/752] doc/go1.18: add a release note for 'go mod vendor -o' For #47327 Change-Id: I50418c0d017c4e90a2c13d26945ee639079e4e33 Reviewed-on: https://go-review.googlesource.com/c/go/+/363174 Trust: Bryan C. Mills Run-TryBot: Bryan C. Mills TryBot-Result: Go Bot Reviewed-by: Paschalis Tsilias Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 44c56444fc..bec9ada383 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -114,6 +114,15 @@ Do not send CLs removing the interior tags from such phrases. go mod download all.

+

+ The go mod vendor subcommand now + supports a -o flag to set the output directory. + (Other go commands still read from the vendor + directory at the module root when loading packages + with -mod=vendor, so the main use for this flag is for + third-party tools that need to collect package source code.) +

+

TODO: https://golang.org/cl/349595: cmd/go: add GOAMD64 environment variable

From 8c73f80400d04a320165f4c1e535524cc50e20b4 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Tue, 9 Nov 2021 19:50:47 -0500 Subject: [PATCH 101/752] runtime: bypass scheduler when doing traceback for goroutine profile When acquire a goroutine profile, we stop the world then acquire a stack trace for each goroutine. When cgo traceback is used, the traceback code may call the cgo traceback function using cgocall. As the world is stopped, cgocall will be blocked at exitsyscall, causing a deadlock. Bypass the scheduler (using asmcgocall) to fix this. Change-Id: Ic4e596adc3711310b6a983d73786d697ef15dd72 Reviewed-on: https://go-review.googlesource.com/c/go/+/362757 Trust: Cherry Mui Run-TryBot: Cherry Mui Reviewed-by: Ian Lance Taylor --- src/runtime/crash_cgo_test.go | 8 ++++ src/runtime/mprof.go | 6 ++- src/runtime/testdata/testprogcgo/gprof.go | 46 ++++++++++++++++++++++ src/runtime/testdata/testprogcgo/gprof_c.c | 29 ++++++++++++++ 4 files changed, 88 insertions(+), 1 deletion(-) create mode 100644 src/runtime/testdata/testprogcgo/gprof.go create mode 100644 src/runtime/testdata/testprogcgo/gprof_c.c diff --git a/src/runtime/crash_cgo_test.go b/src/runtime/crash_cgo_test.go index e6d1742a38..58c340f8ad 100644 --- a/src/runtime/crash_cgo_test.go +++ b/src/runtime/crash_cgo_test.go @@ -702,3 +702,11 @@ func TestNeedmDeadlock(t *testing.T) { t.Fatalf("want %s, got %s\n", want, output) } } + +func TestCgoTracebackGoroutineProfile(t *testing.T) { + output := runTestProg(t, "testprogcgo", "GoroutineProfile") + want := "OK\n" + if output != want { + t.Fatalf("want %s, got %s\n", want, output) + } +} diff --git a/src/runtime/mprof.go b/src/runtime/mprof.go index b4de8f53a9..569c17f0a7 100644 --- a/src/runtime/mprof.go +++ b/src/runtime/mprof.go @@ -805,7 +805,11 @@ func goroutineProfileWithLabels(p []StackRecord, labels []unsafe.Pointer) (n int // truncated profile than to crash the entire process. return } - saveg(^uintptr(0), ^uintptr(0), gp1, &r[0]) + // saveg calls gentraceback, which may call cgo traceback functions. + // The world is stopped, so it cannot use cgocall (which will be + // blocked at exitsyscall). Do it on the system stack so it won't + // call into the schedular (see traceback.go:cgoContextPCs). + systemstack(func() { saveg(^uintptr(0), ^uintptr(0), gp1, &r[0]) }) if labels != nil { lbl[0] = gp1.labels lbl = lbl[1:] diff --git a/src/runtime/testdata/testprogcgo/gprof.go b/src/runtime/testdata/testprogcgo/gprof.go new file mode 100644 index 0000000000..d453b4d0ce --- /dev/null +++ b/src/runtime/testdata/testprogcgo/gprof.go @@ -0,0 +1,46 @@ +// 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 + +// Test taking a goroutine profile with C traceback. + +/* +// Defined in gprof_c.c. +void CallGoSleep(void); +void gprofCgoTraceback(void* parg); +void gprofCgoContext(void* parg); +*/ +import "C" + +import ( + "fmt" + "io" + "runtime" + "runtime/pprof" + "time" + "unsafe" +) + +func init() { + register("GoroutineProfile", GoroutineProfile) +} + +func GoroutineProfile() { + runtime.SetCgoTraceback(0, unsafe.Pointer(C.gprofCgoTraceback), unsafe.Pointer(C.gprofCgoContext), nil) + + go C.CallGoSleep() + go C.CallGoSleep() + go C.CallGoSleep() + time.Sleep(1 * time.Second) + + prof := pprof.Lookup("goroutine") + prof.WriteTo(io.Discard, 1) + fmt.Println("OK") +} + +//export GoSleep +func GoSleep() { + time.Sleep(time.Hour) +} diff --git a/src/runtime/testdata/testprogcgo/gprof_c.c b/src/runtime/testdata/testprogcgo/gprof_c.c new file mode 100644 index 0000000000..6ddff445ad --- /dev/null +++ b/src/runtime/testdata/testprogcgo/gprof_c.c @@ -0,0 +1,29 @@ +// 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. + +// The C definitions for gprof.go. That file uses //export so +// it can't put function definitions in the "C" import comment. + +#include +#include + +// Functions exported from Go. +extern void GoSleep(); + +struct cgoContextArg { + uintptr_t context; +}; + +void gprofCgoContext(void *arg) { + ((struct cgoContextArg*)arg)->context = 1; +} + +void gprofCgoTraceback(void *arg) { + // spend some time here so the P is more likely to be retaken. + for (volatile int i = 0; i < 123456789; i++); +} + +void CallGoSleep() { + GoSleep(); +} From 666fc173c02ff3004ac9ef867aa4eec7e243dde3 Mon Sep 17 00:00:00 2001 From: Neil Alexander Date: Tue, 9 Nov 2021 22:35:50 +0000 Subject: [PATCH 102/752] doc/go1.18: document http.Transport.Dial* being used in js/wasm This PR adds a note into the Go 1.18 changelog for CL 330852. Updates #46923. Change-Id: I99150e9275ce23fcf3697d6a22ac216818223c74 GitHub-Last-Rev: b2772ce68bcd02af672c663760b635eab292afb7 GitHub-Pull-Request: golang/go#49258 Reviewed-on: https://go-review.googlesource.com/c/go/+/360297 Trust: Roland Shoemaker Reviewed-by: Dmitri Shuralyov --- doc/go1.18.html | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index bec9ada383..45f89b7be5 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -276,6 +276,12 @@ Do not send CLs removing the interior tags from such phrases.
net/http
+

+ On WebAssembly targets, the Dial, DialContext, + DialTLS and DialTLSContext method fields in + Transport + will now be correctly used, if specified, for making HTTP requests. +

TODO: https://golang.org/cl/338590: add Cookie.Valid method

From 73a4bbb0df36d85d1ab8cb12d220d1d56e4049ec Mon Sep 17 00:00:00 2001 From: Cuong Manh Le Date: Thu, 11 Nov 2021 15:29:38 +0700 Subject: [PATCH 103/752] cmd/compile: fix missing ddd when building call for function instantiation closure When building a call expression for function instantiation closure, if it's a variadic function, the CallExpr.IsDDD must be set for typecheck to work properly. Otherwise, there will be a mismatch between the arguments type and the function signature. Fixes #49516 Change-Id: I0af90ee3fcc3e6c8bba8b20e331e044cbce17985 Reviewed-on: https://go-review.googlesource.com/c/go/+/363314 Trust: Cuong Manh Le Run-TryBot: Cuong Manh Le TryBot-Result: Go Bot Reviewed-by: Keith Randall --- src/cmd/compile/internal/noder/stencil.go | 1 + test/typeparam/issue49516.go | 26 +++++++++++++++++++++++ 2 files changed, 27 insertions(+) create mode 100644 test/typeparam/issue49516.go diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go index cfbbee3ceb..c8c5d80cfc 100644 --- a/src/cmd/compile/internal/noder/stencil.go +++ b/src/cmd/compile/internal/noder/stencil.go @@ -515,6 +515,7 @@ func (g *genInst) buildClosure(outer *ir.Func, x ir.Node) ir.Node { // Build call itself. var innerCall ir.Node = ir.NewCallExpr(pos, ir.OCALL, target.Nname, args) + innerCall.(*ir.CallExpr).IsDDD = typ.IsVariadic() if len(formalResults) > 0 { innerCall = ir.NewReturnStmt(pos, []ir.Node{innerCall}) } diff --git a/test/typeparam/issue49516.go b/test/typeparam/issue49516.go new file mode 100644 index 0000000000..d6fab02463 --- /dev/null +++ b/test/typeparam/issue49516.go @@ -0,0 +1,26 @@ +// compile -G=3 + +// 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 + +type Q[T any] struct { + s []T +} + +func (q *Q[T]) Push(v ...T) { + q.s = append(q.s, v...) +} + +func pushN(push func(*Q[int], ...int), n int) { + var q Q[int] + for i := 0; i < n; i++ { + push(&q, i) + } +} + +func f() { + pushN((*Q[int]).Push, 100) +} From 84277bfd07dad771b9978149bdaed8aa16ed8982 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Thu, 11 Nov 2021 12:52:45 -0500 Subject: [PATCH 104/752] runtime: fix C compilation error in TestCgoTracebackGoroutineProfile Use C89 declaration. Also fix indentation. Change-Id: Ib974eb32ac95610d0b0eca00ca3b139b388c73bd Reviewed-on: https://go-review.googlesource.com/c/go/+/363356 Trust: Cherry Mui Run-TryBot: Cherry Mui TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/runtime/testdata/testprogcgo/gprof_c.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/runtime/testdata/testprogcgo/gprof_c.c b/src/runtime/testdata/testprogcgo/gprof_c.c index 6ddff445ad..5c7cd77022 100644 --- a/src/runtime/testdata/testprogcgo/gprof_c.c +++ b/src/runtime/testdata/testprogcgo/gprof_c.c @@ -21,9 +21,10 @@ void gprofCgoContext(void *arg) { void gprofCgoTraceback(void *arg) { // spend some time here so the P is more likely to be retaken. - for (volatile int i = 0; i < 123456789; i++); + volatile int i; + for (i = 0; i < 123456789; i++); } void CallGoSleep() { - GoSleep(); + GoSleep(); } From 8ce1a953fb125ab390e816540d7f6c304ee7e52b Mon Sep 17 00:00:00 2001 From: jiahua wang Date: Sat, 2 Oct 2021 22:50:31 +0800 Subject: [PATCH 105/752] io: add error check to TeeReader Example Change-Id: I0b94bdced47483c6412e9979ce2d103fbfc52afb Reviewed-on: https://go-review.googlesource.com/c/go/+/353729 Run-TryBot: Ian Lance Taylor TryBot-Result: Go Bot Reviewed-by: Ian Lance Taylor Trust: Carlos Amedee --- src/io/example_test.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/io/example_test.go b/src/io/example_test.go index f6d9fd575f..419e449982 100644 --- a/src/io/example_test.go +++ b/src/io/example_test.go @@ -142,7 +142,9 @@ func ExampleTeeReader() { r = io.TeeReader(r, os.Stdout) // Everything read from r will be copied to stdout. - io.ReadAll(r) + if _, err := io.ReadAll(r); err != nil { + log.Fatal(err) + } // Output: // some io.Reader stream to be read From f1935c52703e4482c5047b4b35276e965896df7c Mon Sep 17 00:00:00 2001 From: hasheddan Date: Thu, 11 Nov 2021 10:02:13 -0500 Subject: [PATCH 106/752] obj/riscv: fix link to risc-v dwarf register numbers The repository name and structure in the RISC-V GitHub org has been modified, rendering the existing link invalid. This updates to point at the new location of the RISC-V DWARF specification. Change occured in https://github.com/riscv-non-isa/riscv-elf-psabi-doc/pull/208 Change-Id: I8ca4c390bee2d7ce20418cdd00e4945a426cf5f7 Reviewed-on: https://go-review.googlesource.com/c/go/+/363355 Reviewed-by: Brad Fitzpatrick Trust: Brad Fitzpatrick Trust: Than McIntosh --- src/cmd/internal/obj/riscv/cpu.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cmd/internal/obj/riscv/cpu.go b/src/cmd/internal/obj/riscv/cpu.go index ed88f621d9..d9434e7415 100644 --- a/src/cmd/internal/obj/riscv/cpu.go +++ b/src/cmd/internal/obj/riscv/cpu.go @@ -183,7 +183,7 @@ const ( REGG = REG_G ) -// https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md#dwarf-register-numbers +// https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-dwarf.adoc#dwarf-register-numbers var RISCV64DWARFRegisters = map[int16]int16{ // Integer Registers. REG_X0: 0, From d60a4e69f16f5bc958094af206ac7e47f6bc8b04 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 11 Nov 2021 08:36:15 -0800 Subject: [PATCH 107/752] spec: fix a broken link Thanks for jtagcat@ for finding this. Change-Id: If7324808edbae19ec8bf503b04e0426f3fb3b47a Reviewed-on: https://go-review.googlesource.com/c/go/+/363394 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Go Bot Reviewed-by: Ian Lance Taylor --- doc/go1.17_spec.html | 2 +- doc/go_spec.html | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/go1.17_spec.html b/doc/go1.17_spec.html index 46eebb5713..0b374e7bfb 100644 --- a/doc/go1.17_spec.html +++ b/doc/go1.17_spec.html @@ -258,7 +258,7 @@ continue for import return var

The following character sequences represent operators -(including assignment operators) and punctuation: +(including assignment operators) and punctuation: 

 +    &     +=    &=     &&    ==    !=    (    )
diff --git a/doc/go_spec.html b/doc/go_spec.html
index 46eebb5713..0b374e7bfb 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -258,7 +258,7 @@ continue     for          import       return       var
 
 

 The following character sequences represent operators
-(including assignment operators) and punctuation:
+(including assignment operators) and punctuation:
 

 
 +    &     +=    &=     &&    ==    !=    (    )

From 48f1cde942959e2fc3c56973a2986c24d554c82c Mon Sep 17 00:00:00 2001
From: Pavel 
Date: Mon, 8 Nov 2021 14:29:16 +0000
Subject: [PATCH 108/752] database/sql: prevent closes slices from assigning to
 free conn

In function connectionCleanerRunLocked append to closing slice affects db.freeConns and vise versa. Sometimes valid connections are closed and some invalid not.

Change-Id: I5282f15be3e549533b7d994b17b2060db3c0e7da
GitHub-Last-Rev: b3eb3ab6f49c036519f777fc7189e9507010c166
GitHub-Pull-Request: golang/go#49429
Reviewed-on: https://go-review.googlesource.com/c/go/+/362214
Reviewed-by: Daniel Theophanes 
Reviewed-by: Ian Lance Taylor 
---
 src/database/sql/sql.go      |  2 +-
 src/database/sql/sql_test.go | 61 +++++++++++++++++++++++++++++-------
 2 files changed, 50 insertions(+), 13 deletions(-)

diff --git a/src/database/sql/sql.go b/src/database/sql/sql.go
index 5131c08b51..c5b4f50aa7 100644
--- a/src/database/sql/sql.go
+++ b/src/database/sql/sql.go
@@ -1115,7 +1115,7 @@ func (db *DB) connectionCleanerRunLocked(d time.Duration) (time.Duration, []*dri
 			c := db.freeConn[i]
 			if c.returnedAt.Before(idleSince) {
 				i++
-				closing = db.freeConn[:i]
+				closing = db.freeConn[:i:i]
 				db.freeConn = db.freeConn[i:]
 				idleClosing = int64(len(closing))
 				db.maxIdleTimeClosed += idleClosing
diff --git a/src/database/sql/sql_test.go b/src/database/sql/sql_test.go
index 889adc3164..b887b40d71 100644
--- a/src/database/sql/sql_test.go
+++ b/src/database/sql/sql_test.go
@@ -3910,6 +3910,10 @@ func testUseConns(t *testing.T, count int, tm time.Time, db *DB) time.Time {
 	conns := make([]*Conn, count)
 	ctx := context.Background()
 	for i := range conns {
+		tm = tm.Add(time.Nanosecond)
+		nowFunc = func() time.Time {
+			return tm
+		}
 		c, err := db.Conn(ctx)
 		if err != nil {
 			t.Error(err)
@@ -3917,12 +3921,12 @@ func testUseConns(t *testing.T, count int, tm time.Time, db *DB) time.Time {
 		conns[i] = c
 	}
 
-	for _, c := range conns {
+	for i := len(conns) - 1; i >= 0; i-- {
 		tm = tm.Add(time.Nanosecond)
 		nowFunc = func() time.Time {
 			return tm
 		}
-		if err := c.Close(); err != nil {
+		if err := conns[i].Close(); err != nil {
 			t.Error(err)
 		}
 	}
@@ -3934,18 +3938,46 @@ func TestMaxIdleTime(t *testing.T) {
 	usedConns := 5
 	reusedConns := 2
 	list := []struct {
-		wantMaxIdleTime time.Duration
-		wantNextCheck   time.Duration
-		wantIdleClosed  int64
-		timeOffset      time.Duration
+		wantMaxIdleTime   time.Duration
+		wantMaxLifetime   time.Duration
+		wantNextCheck     time.Duration
+		wantIdleClosed    int64
+		wantMaxIdleClosed int64
+		timeOffset        time.Duration
+		secondTimeOffset  time.Duration
 	}{
 		{
 			time.Millisecond,
+			0,
 			time.Millisecond - time.Nanosecond,
 			int64(usedConns - reusedConns),
+			int64(usedConns - reusedConns),
 			10 * time.Millisecond,
+			0,
 		},
-		{time.Hour, time.Second, 0, 10 * time.Millisecond},
+		{
+			// Want to close some connections via max idle time and one by max lifetime.
+			time.Millisecond,
+			// nowFunc() - MaxLifetime should be 1 * time.Nanosecond in connectionCleanerRunLocked.
+			// This guarantees that first opened connection is to be closed.
+			// Thus it is timeOffset + secondTimeOffset + 3 (+2 for Close while reusing conns and +1 for Conn).
+			10*time.Millisecond + 100*time.Nanosecond + 3*time.Nanosecond,
+			time.Nanosecond,
+			// Closed all not reused connections and extra one by max lifetime.
+			int64(usedConns - reusedConns + 1),
+			int64(usedConns - reusedConns),
+			10 * time.Millisecond,
+			// Add second offset because otherwise connections are expired via max lifetime in Close.
+			100 * time.Nanosecond,
+		},
+		{
+			time.Hour,
+			0,
+			time.Second,
+			0,
+			0,
+			10 * time.Millisecond,
+			0},
 	}
 	baseTime := time.Unix(0, 0)
 	defer func() {
@@ -3962,18 +3994,23 @@ func TestMaxIdleTime(t *testing.T) {
 			db.SetMaxOpenConns(usedConns)
 			db.SetMaxIdleConns(usedConns)
 			db.SetConnMaxIdleTime(item.wantMaxIdleTime)
-			db.SetConnMaxLifetime(0)
+			db.SetConnMaxLifetime(item.wantMaxLifetime)
 
 			preMaxIdleClosed := db.Stats().MaxIdleTimeClosed
 
 			// Busy usedConns.
-			tm := testUseConns(t, usedConns, baseTime, db)
+			testUseConns(t, usedConns, baseTime, db)
 
-			tm = baseTime.Add(item.timeOffset)
+			tm := baseTime.Add(item.timeOffset)
 
 			// Reuse connections which should never be considered idle
 			// and exercises the sorting for issue 39471.
-			testUseConns(t, reusedConns, tm, db)
+			tm = testUseConns(t, reusedConns, tm, db)
+
+			tm = tm.Add(item.secondTimeOffset)
+			nowFunc = func() time.Time {
+				return tm
+			}
 
 			db.mu.Lock()
 			nc, closing := db.connectionCleanerRunLocked(time.Second)
@@ -4001,7 +4038,7 @@ func TestMaxIdleTime(t *testing.T) {
 
 			st := db.Stats()
 			maxIdleClosed := st.MaxIdleTimeClosed - preMaxIdleClosed
-			if g, w := maxIdleClosed, item.wantIdleClosed; g != w {
+			if g, w := maxIdleClosed, item.wantMaxIdleClosed; g != w {
 				t.Errorf("got: %d; want %d max idle closed conns", g, w)
 			}
 		})

From 3e94140465984ff6c8d658051d022e8eacf057c3 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek 
Date: Wed, 10 Nov 2021 22:03:28 +0000
Subject: [PATCH 109/752] runtime/debug: make TestFreeOSMemory more robust

FreeOSMemory relies on the function FreeOSMemory increasing HeapReleased
as opposed to the background scavenger, because it reads memory stats
*after* the free of a large allocation. However, before that even
happens, the background scavenger can swoop in and release all that
memory, making it appear as if FreeOSMemory didn't do anything.

This change modifies the test to just make sure that the large
allocation's memory is returned to the OS *somehow*, by the end of the
test. It doesn't really care which happens. It also increases the size
of that large allocation to increase the likelihood that the test isn't
relying 100% on the background scavenger, and that FreeOSMemory is doing
some of the work.

Fixes #49478.

Change-Id: Ief1d839753720ebb88cbb616c46302293ee2d19c
Reviewed-on: https://go-review.googlesource.com/c/go/+/363414
Reviewed-by: David Chase 
Trust: Michael Knyszek 
---
 src/runtime/debug/garbage_test.go | 65 ++++++++++++++++++++++++++-----
 1 file changed, 55 insertions(+), 10 deletions(-)

diff --git a/src/runtime/debug/garbage_test.go b/src/runtime/debug/garbage_test.go
index 69e769ecf2..c3501408dd 100644
--- a/src/runtime/debug/garbage_test.go
+++ b/src/runtime/debug/garbage_test.go
@@ -6,6 +6,7 @@ package debug_test
 
 import (
 	"internal/testenv"
+	"os"
 	"runtime"
 	. "runtime/debug"
 	"testing"
@@ -87,21 +88,65 @@ func TestReadGCStats(t *testing.T) {
 	}
 }
 
-var big = make([]byte, 1<<20)
+var big []byte
 
 func TestFreeOSMemory(t *testing.T) {
-	var ms1, ms2 runtime.MemStats
+	// Tests FreeOSMemory by making big susceptible to collection
+	// and checking that at least that much memory is returned to
+	// the OS after.
 
-	if big == nil {
-		t.Skip("test is not reliable when run multiple times")
-	}
-	big = nil
+	const bigBytes = 32 << 20
+	big = make([]byte, bigBytes)
+
+	// Make sure any in-progress GCs are complete.
 	runtime.GC()
-	runtime.ReadMemStats(&ms1)
+
+	var before runtime.MemStats
+	runtime.ReadMemStats(&before)
+
+	// Clear the last reference to the big allocation, making it
+	// susceptible to collection.
+	big = nil
+
+	// FreeOSMemory runs a GC cycle before releasing memory,
+	// so it's fine to skip a GC here.
+	//
+	// It's possible the background scavenger runs concurrently
+	// with this function and does most of the work for it.
+	// If that happens, it's OK. What we want is a test that fails
+	// often if FreeOSMemory does not work correctly, and a test
+	// that passes every time if it does.
 	FreeOSMemory()
-	runtime.ReadMemStats(&ms2)
-	if ms1.HeapReleased >= ms2.HeapReleased {
-		t.Errorf("released before=%d; released after=%d; did not go up", ms1.HeapReleased, ms2.HeapReleased)
+
+	var after runtime.MemStats
+	runtime.ReadMemStats(&after)
+
+	// Check to make sure that the big allocation (now freed)
+	// had its memory shift into HeapReleased as a result of that
+	// FreeOSMemory.
+	if after.HeapReleased <= before.HeapReleased {
+		t.Fatalf("no memory released: %d -> %d", before.HeapReleased, after.HeapReleased)
+	}
+
+	// Check to make sure bigBytes was released, plus some slack. Pages may get
+	// allocated in between the two measurements above for a variety for reasons,
+	// most commonly for GC work bufs. Since this can get fairly high, depending
+	// on scheduling and what GOMAXPROCS is, give a lot of slack up-front.
+	//
+	// Add a little more slack too if the page size is bigger than the runtime page size.
+	// "big" could end up unaligned on its ends, forcing the scavenger to skip at worst
+	// 2x pages.
+	slack := uint64(bigBytes / 2)
+	pageSize := uint64(os.Getpagesize())
+	if pageSize > 8<<10 {
+		slack += pageSize * 2
+	}
+	if slack > bigBytes {
+		// We basically already checked this.
+		return
+	}
+	if after.HeapReleased-before.HeapReleased < bigBytes-slack {
+		t.Fatalf("less than %d released: %d -> %d", bigBytes, before.HeapReleased, after.HeapReleased)
 	}
 }
 

From 46b2fc05a2681a9dd3b606176e738d786b0c2176 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek 
Date: Thu, 11 Nov 2021 17:31:36 +0000
Subject: [PATCH 110/752] runtime: adjust TestPhysicalMemoryUtilization to
 handle large page sizes

Currently TestPhysicalMemoryUtilization can fail on systems with large
physical page sizes like 64 KiB because all the of the holes to be
scavenged are not aligned to the page size. The holes themselves are 64
KiB so this is actually quite likely.

Bump the size of the allocations for systems with larger physical page
sizes, and add additional slack to the threshold for unaligned pieces of
the holes that may be unaligned.

Fixes #49411.

Change-Id: Iafb35b8761dc9cdc53d3745c4771b1a64c5c97b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/363415
Trust: Michael Knyszek 
Reviewed-by: David Chase 
---
 src/runtime/testdata/testprog/gc.go | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/src/runtime/testdata/testprog/gc.go b/src/runtime/testdata/testprog/gc.go
index 6484c36139..7d371a6a89 100644
--- a/src/runtime/testdata/testprog/gc.go
+++ b/src/runtime/testdata/testprog/gc.go
@@ -140,13 +140,26 @@ func GCPhys() {
 	// returned to the OS.
 
 	const (
+		// The total amount of memory we're willing to allocate.
 		allocTotal = 32 << 20
-		allocChunk = 64 << 10
-		allocs     = allocTotal / allocChunk
 
 		// The page cache could hide 64 8-KiB pages from the scavenger today.
 		maxPageCache = (8 << 10) * 64
 	)
+
+	// How big the allocations are needs to depend on the page size.
+	// If the page size is too big and the allocations are too small,
+	// they might not be aligned to the physical page size, so the scavenger
+	// will gloss over them.
+	pageSize := os.Getpagesize()
+	var allocChunk int
+	if pageSize <= 8<<10 {
+		allocChunk = 64 << 10
+	} else {
+		allocChunk = 512 << 10
+	}
+	allocs := allocTotal / allocChunk
+
 	// Set GC percent just so this test is a little more consistent in the
 	// face of varying environments.
 	debug.SetGCPercent(100)
@@ -197,7 +210,7 @@ func GCPhys() {
 	//
 	// heapBacked also subtracts out maxPageCache bytes of memory because
 	// this is memory that may be hidden from the scavenger per-P. Since
-	// GOMAXPROCS=1 here, that's fine.
+	// GOMAXPROCS=1 here, subtracting it out once is fine.
 	var stats runtime.MemStats
 	runtime.ReadMemStats(&stats)
 	heapBacked := stats.HeapSys - stats.HeapReleased - maxPageCache
@@ -212,7 +225,12 @@ func GCPhys() {
 	overuse := (float64(heapBacked) - float64(stats.HeapAlloc)) / float64(stats.HeapAlloc)
 	// Check against our overuse threshold, which is what the scavenger always reserves
 	// to encourage allocation of memory that doesn't need to be faulted in.
-	const threshold = 0.1
+	//
+	// Add additional slack in case the page size is large and the scavenger
+	// can't reach that memory because it doesn't constitute a complete aligned
+	// physical page. Assume the worst case: a full physical page out of each
+	// allocation.
+	threshold := 0.1 + float64(pageSize)/float64(allocChunk)
 	if overuse <= threshold {
 		fmt.Println("OK")
 		return

From eb68e3367bf8d55bb98eb002cef35455f5be3c5f Mon Sep 17 00:00:00 2001
From: cuiweixie 
Date: Thu, 11 Nov 2021 07:10:52 +0000
Subject: [PATCH 111/752] runtime: fix typo

Change filepath reference from cmd/internal/ld/symtab.go to
cmd/link/internal/ld/symtab.go.

Change-Id: Icb207a2e2c82d3976787d2d5cfb0f8005696f738
GitHub-Last-Rev: 428d99c6ca97db79b7d8cdf24843df3492a9aeb0
GitHub-Pull-Request: golang/go#49518
Reviewed-on: https://go-review.googlesource.com/c/go/+/363276
Reviewed-by: Ian Lance Taylor 
Trust: Brad Fitzpatrick 
---
 src/runtime/symtab.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/symtab.go b/src/runtime/symtab.go
index 3237a6b708..21dd95a397 100644
--- a/src/runtime/symtab.go
+++ b/src/runtime/symtab.go
@@ -408,7 +408,7 @@ type pcHeader struct {
 
 // moduledata records information about the layout of the executable
 // image. It is written by the linker. Any changes here must be
-// matched changes to the code in cmd/internal/ld/symtab.go:symtab.
+// matched changes to the code in cmd/link/internal/ld/symtab.go:symtab.
 // moduledata is stored in statically allocated non-pointer memory;
 // none of the pointers here are visible to the garbage collector.
 type moduledata struct {

From c622d1d3f68369ec5f8ce9694fa27e7acb025004 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor 
Date: Wed, 10 Nov 2021 20:28:45 -0800
Subject: [PATCH 112/752] go/build: skip rune literals when looking for
 go:embed

Fixes #49514

Change-Id: Id687eead731ba49974f11d2e5b489f11eff7d07b
Reviewed-on: https://go-review.googlesource.com/c/go/+/363275
Trust: Ian Lance Taylor 
Run-TryBot: Ian Lance Taylor 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
---
 src/embed/internal/embedtest/embed_test.go |  5 +++++
 src/go/build/read.go                       | 21 +++++++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/src/embed/internal/embedtest/embed_test.go b/src/embed/internal/embedtest/embed_test.go
index bfd94af69d..1337e421bd 100644
--- a/src/embed/internal/embedtest/embed_test.go
+++ b/src/embed/internal/embedtest/embed_test.go
@@ -60,6 +60,11 @@ func testDir(t *testing.T, f embed.FS, name string, expect ...string) {
 	}
 }
 
+// Tests for issue 49514.
+var _ = '"'
+var _ = '\''
+var _ = '🦆'
+
 func TestGlobal(t *testing.T) {
 	testFiles(t, global, "concurrency.txt", "Concurrency is not parallelism.\n")
 	testFiles(t, global, "testdata/hello.txt", "hello, world\n")
diff --git a/src/go/build/read.go b/src/go/build/read.go
index 6115ef810c..de5c33a4f8 100644
--- a/src/go/build/read.go
+++ b/src/go/build/read.go
@@ -240,6 +240,27 @@ func (r *importReader) findEmbed(first bool) bool {
 				}
 			}
 
+		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
+				}
+			}
+
 		case '/':
 			c = r.readByteNoBuf()
 			switch c {

From 10d3b1355184320f6d9623cb35e848e5af7c29ed Mon Sep 17 00:00:00 2001
From: Keith Randall 
Date: Thu, 11 Nov 2021 08:45:02 -0800
Subject: [PATCH 113/752] cmd/compile: ensure stenciled function bodies are
 nonempty

Our compiler gets confused between functions that were declared
with no body, and those which have a body but it is empty.

Ensure that when stenciling, we generate a nonempty body.

The particular test that causes this problem is in
cmd/compile/internal/gc/main.go:enqueueFunc. It thinks that if
a function has no body, then we need to generate ABI wrappers for
it, but not compile it.

Fixes #49524

Change-Id: Id962666a2098f60a2421484b6a776eafdc4f4a63
Reviewed-on: https://go-review.googlesource.com/c/go/+/363395
Trust: Keith Randall 
Trust: Dan Scales 
Run-TryBot: Keith Randall 
TryBot-Result: Go Bot 
Reviewed-by: Dan Scales 
---
 src/cmd/compile/internal/noder/stencil.go |  6 ++++++
 test/typeparam/issue49524.dir/a.go        |  8 ++++++++
 test/typeparam/issue49524.dir/main.go     | 11 +++++++++++
 test/typeparam/issue49524.go              |  7 +++++++
 4 files changed, 32 insertions(+)
 create mode 100644 test/typeparam/issue49524.dir/a.go
 create mode 100644 test/typeparam/issue49524.dir/main.go
 create mode 100644 test/typeparam/issue49524.go

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index c8c5d80cfc..20197565f5 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -802,6 +802,12 @@ func (g *genInst) genericSubst(newsym *types.Sym, nameNode *ir.Name, shapes []*t
 
 	// Make sure name/type of newf is set before substituting the body.
 	newf.Body = subst.list(gf.Body)
+	if len(newf.Body) == 0 {
+		// Ensure the body is nonempty, for issue 49524.
+		// TODO: have some other way to detect the difference between
+		// a function declared with no body, vs. one with an empty body?
+		newf.Body = append(newf.Body, ir.NewBlockStmt(gf.Pos(), nil))
+	}
 
 	if len(subst.defnMap) > 0 {
 		base.Fatalf("defnMap is not empty")
diff --git a/test/typeparam/issue49524.dir/a.go b/test/typeparam/issue49524.dir/a.go
new file mode 100644
index 0000000000..f40075e953
--- /dev/null
+++ b/test/typeparam/issue49524.dir/a.go
@@ -0,0 +1,8 @@
+// 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[T any]() {
+}
diff --git a/test/typeparam/issue49524.dir/main.go b/test/typeparam/issue49524.dir/main.go
new file mode 100644
index 0000000000..ef00c8a81c
--- /dev/null
+++ b/test/typeparam/issue49524.dir/main.go
@@ -0,0 +1,11 @@
+package main
+
+// 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.
+
+import "a"
+
+func main() {
+	a.F[int]()
+}
diff --git a/test/typeparam/issue49524.go b/test/typeparam/issue49524.go
new file mode 100644
index 0000000000..76930e5e4f
--- /dev/null
+++ b/test/typeparam/issue49524.go
@@ -0,0 +1,7 @@
+// rundir -G=3
+
+// 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

From ccd41cc05e3ee2f0d0ded1d7faf9c1f43ce1037b Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Thu, 11 Nov 2021 11:57:43 -0800
Subject: [PATCH 114/752] go/types, types2: document nil scope for imported and
 instantiated Func objects

Also, don't set the scope anymore when instantiating (substituting)
a signature.

Per discussion with rfindley.

Change-Id: I560d4571c7ff14b0df3e15fece634cb5f9f94a99
Reviewed-on: https://go-review.googlesource.com/c/go/+/363435
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/object.go    | 2 ++
 src/cmd/compile/internal/types2/signature.go | 2 +-
 src/cmd/compile/internal/types2/subst.go     | 4 ++--
 src/go/types/object.go                       | 2 ++
 src/go/types/signature.go                    | 2 +-
 src/go/types/subst.go                        | 4 ++--
 6 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/types2/object.go b/src/cmd/compile/internal/types2/object.go
index d86c166c72..da3e1a2abc 100644
--- a/src/cmd/compile/internal/types2/object.go
+++ b/src/cmd/compile/internal/types2/object.go
@@ -389,6 +389,8 @@ func (obj *Func) FullName() string {
 }
 
 // Scope returns the scope of the function's body block.
+// The result is nil for imported or instantiated functions and methods
+// (but there is also no mechanism to get to an instantiated function).
 func (obj *Func) Scope() *Scope { return obj.typ.(*Signature).scope }
 
 // hasPtrRecv reports whether the receiver is of the form *T for the given method obj.
diff --git a/src/cmd/compile/internal/types2/signature.go b/src/cmd/compile/internal/types2/signature.go
index 4541435587..b0b8ad49d9 100644
--- a/src/cmd/compile/internal/types2/signature.go
+++ b/src/cmd/compile/internal/types2/signature.go
@@ -18,7 +18,7 @@ type Signature struct {
 	// We then unpack the *Signature and use the scope for the literal body.
 	rparams  *TypeParamList // receiver type parameters from left to right, or nil
 	tparams  *TypeParamList // type parameters from left to right, or nil
-	scope    *Scope         // function scope, present for package-local signatures
+	scope    *Scope         // function scope for package-local and non-instantiated signatures; nil otherwise
 	recv     *Var           // nil if not a method
 	params   *Tuple         // (incoming) parameters from left to right; or nil
 	results  *Tuple         // (outgoing) results from left to right; or nil
diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
index a4e46b2097..f46e895b12 100644
--- a/src/cmd/compile/internal/types2/subst.go
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -115,8 +115,8 @@ func (subst *subster) typ(typ Type) Type {
 			return &Signature{
 				rparams: t.rparams,
 				// TODO(gri) why can't we nil out tparams here, rather than in instantiate?
-				tparams:  t.tparams,
-				scope:    t.scope,
+				tparams: t.tparams,
+				// instantiated signatures have a nil scope
 				recv:     recv,
 				params:   params,
 				results:  results,
diff --git a/src/go/types/object.go b/src/go/types/object.go
index e7a4425643..9309a529c4 100644
--- a/src/go/types/object.go
+++ b/src/go/types/object.go
@@ -343,6 +343,8 @@ func (obj *Func) FullName() string {
 }
 
 // Scope returns the scope of the function's body block.
+// The result is nil for imported or instantiated functions and methods
+// (but there is also no mechanism to get to an instantiated function).
 func (obj *Func) Scope() *Scope { return obj.typ.(*Signature).scope }
 
 // hasPtrRecv reports whether the receiver is of the form *T for the given method obj.
diff --git a/src/go/types/signature.go b/src/go/types/signature.go
index ad69c95d12..3e0a046afa 100644
--- a/src/go/types/signature.go
+++ b/src/go/types/signature.go
@@ -21,7 +21,7 @@ type Signature struct {
 	// We then unpack the *Signature and use the scope for the literal body.
 	rparams  *TypeParamList // receiver type parameters from left to right, or nil
 	tparams  *TypeParamList // type parameters from left to right, or nil
-	scope    *Scope         // function scope, present for package-local signatures
+	scope    *Scope         // function scope for package-local and non-instantiated signatures; nil otherwise
 	recv     *Var           // nil if not a method
 	params   *Tuple         // (incoming) parameters from left to right; or nil
 	results  *Tuple         // (outgoing) results from left to right; or nil
diff --git a/src/go/types/subst.go b/src/go/types/subst.go
index 1fac82fe8a..a05195150f 100644
--- a/src/go/types/subst.go
+++ b/src/go/types/subst.go
@@ -115,8 +115,8 @@ func (subst *subster) typ(typ Type) Type {
 			return &Signature{
 				rparams: t.rparams,
 				// TODO(rFindley) why can't we nil out tparams here, rather than in instantiate?
-				tparams:  t.tparams,
-				scope:    t.scope,
+				tparams: t.tparams,
+				// instantiated signatures have a nil scope
 				recv:     recv,
 				params:   params,
 				results:  results,

From 9d89a5eb64f25ce0e7cc6086d44b6f327cbb302c Mon Sep 17 00:00:00 2001
From: Katie Hockman 
Date: Tue, 9 Nov 2021 17:13:36 -0500
Subject: [PATCH 115/752] all: update terminology for fuzzing

This change doesn't modify any functionality.
It also doesn't update all of the comments and
variable names of the internal code, but everything
user facing should be correct.

Updates #49185

Change-Id: Ia8b2c94b89ba45897c4085ea0c17a3d8896f7ec7
Reviewed-on: https://go-review.googlesource.com/c/go/+/362794
Trust: Katie Hockman 
Run-TryBot: Katie Hockman 
TryBot-Result: Go Bot 
Reviewed-by: Roland Shoemaker 
---
 src/cmd/go/alldocs.go                         |  31 ++--
 src/cmd/go/internal/test/test.go              |  43 +++---
 src/cmd/go/testdata/script/test_fuzz.txt      |  10 +-
 .../go/testdata/script/test_fuzz_match.txt    |   4 +-
 .../go/testdata/script/test_fuzz_multiple.txt |   2 +-
 .../script/test_fuzz_mutator_repeat.txt       |   2 +-
 .../testdata/script/test_fuzz_seed_corpus.txt |  22 +--
 src/go/doc/example.go                         |   6 +-
 src/internal/fuzz/fuzz.go                     |   4 +-
 src/testing/fuzz.go                           | 138 +++++++++---------
 src/testing/testing.go                        |  55 +++----
 11 files changed, 159 insertions(+), 158 deletions(-)

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index ff144f9847..dfb88ab78d 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1547,7 +1547,7 @@
 // 'Go test' recompiles each package along with any files with names matching
 // the file pattern "*_test.go".
 // These additional files can contain test functions, benchmark functions, fuzz
-// targets and example functions. See 'go help testfunc' for more.
+// tests and example functions. See 'go help testfunc' for more.
 // Each listed package causes the execution of a separate test binary.
 // Files whose names begin with "_" (including "_test.go") or "." are ignored.
 //
@@ -2796,7 +2796,7 @@
 // 	    Run each test, benchmark, and fuzz seed n times (default 1).
 // 	    If -cpu is set, run n times for each GOMAXPROCS value.
 // 	    Examples are always run once. -count does not apply to
-// 	    fuzz targets matched by -fuzz.
+// 	    fuzz tests matched by -fuzz.
 //
 // 	-cover
 // 	    Enable coverage analysis.
@@ -2824,20 +2824,19 @@
 //
 // 	-cpu 1,2,4
 // 	    Specify a list of GOMAXPROCS values for which the tests, benchmarks or
-// 	    fuzz targets should be executed. The default is the current value
-// 	    of GOMAXPROCS. -cpu does not apply to fuzz targets matched by -fuzz.
+// 	    fuzz tests should be executed. The default is the current value
+// 	    of GOMAXPROCS. -cpu does not apply to fuzz tests matched by -fuzz.
 //
 // 	-failfast
 // 	    Do not start new tests after the first test failure.
 //
 // 	-fuzz regexp
-// 	    Run the fuzz target matching the regular expression. When specified,
+// 	    Run the fuzz test matching the regular expression. When specified,
 // 	    the command line argument must match exactly one package within the
-// 	    main module, and regexp must match exactly one fuzz target within
-// 	    that package. After tests, benchmarks, seed corpora of other fuzz
-// 	    targets, and examples have completed, the matching target will be
-// 	    fuzzed. See the Fuzzing section of the testing package documentation
-// 	    for details.
+// 	    main module, and regexp must match exactly one fuzz test within
+// 	    that package. Fuzzing will occur after tests, benchmarks, seed corpora
+// 	    of other fuzz tests, and examples have completed. See the Fuzzing
+// 	    section of the testing package documentation for details.
 //
 // 	-fuzztime t
 // 	    Run enough iterations of the fuzz test to take t, specified as a
@@ -2851,14 +2850,14 @@
 // 	    same information as the -v flag in a machine-readable format.
 //
 // 	-list regexp
-// 	    List tests, benchmarks, fuzz targets, or examples matching the regular
-// 	    expression. No tests, benchmarks, fuzz targets, or examples will be run.
+// 	    List tests, benchmarks, fuzz tests, or examples matching the regular
+// 	    expression. No tests, benchmarks, fuzz tests, or examples will be run.
 // 	    This will only list top-level tests. No subtest or subbenchmarks will be
 // 	    shown.
 //
 // 	-parallel n
 // 	    Allow parallel execution of test functions that call t.Parallel, and
-// 	    f.Fuzz functions that call t.Parallel when running the seed corpus.
+// 	    fuzz targets that call t.Parallel when running the seed corpus.
 // 	    The value of this flag is the maximum number of tests to run
 // 	    simultaneously.
 // 	    While fuzzing, the value of this flag is the maximum number of
@@ -2873,7 +2872,7 @@
 // 	    (see 'go help build').
 //
 // 	-run regexp
-// 	    Run only those tests, examples, and fuzz targets matching the regular
+// 	    Run only those tests, examples, and fuzz tests matching the regular
 // 	    expression. For tests, the regular expression is split by unbracketed
 // 	    slash (/) characters into a sequence of regular expressions, and each
 // 	    part of a test's identifier must match the corresponding element in
@@ -3047,7 +3046,7 @@
 //
 // 	func BenchmarkXxx(b *testing.B) { ... }
 //
-// A fuzz target is one named FuzzXxx and should have the signature,
+// A fuzz test is one named FuzzXxx and should have the signature,
 //
 // 	func FuzzXxx(f *testing.F) { ... }
 //
@@ -3090,7 +3089,7 @@
 //
 // The entire test file is presented as the example when it contains a single
 // example function, at least one other function, type, variable, or constant
-// declaration, and no fuzz targets or test or benchmark functions.
+// declaration, and no tests, benchmarks, or fuzz tests.
 //
 // See the documentation of the testing package for more information.
 //
diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 7361c11786..73abca8927 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -65,7 +65,7 @@ followed by detailed output for each failed package.
 'Go test' recompiles each package along with any files with names matching
 the file pattern "*_test.go".
 These additional files can contain test functions, benchmark functions, fuzz
-targets and example functions. See 'go help testfunc' for more.
+tests and example functions. See 'go help testfunc' for more.
 Each listed package causes the execution of a separate test binary.
 Files whose names begin with "_" (including "_test.go") or "." are ignored.
 
@@ -214,7 +214,7 @@ control the execution of any test:
 	    Run each test, benchmark, and fuzz seed n times (default 1).
 	    If -cpu is set, run n times for each GOMAXPROCS value.
 	    Examples are always run once. -count does not apply to
-	    fuzz targets matched by -fuzz.
+	    fuzz tests matched by -fuzz.
 
 	-cover
 	    Enable coverage analysis.
@@ -242,20 +242,19 @@ control the execution of any test:
 
 	-cpu 1,2,4
 	    Specify a list of GOMAXPROCS values for which the tests, benchmarks or
-	    fuzz targets should be executed. The default is the current value
-	    of GOMAXPROCS. -cpu does not apply to fuzz targets matched by -fuzz.
+	    fuzz tests should be executed. The default is the current value
+	    of GOMAXPROCS. -cpu does not apply to fuzz tests matched by -fuzz.
 
 	-failfast
 	    Do not start new tests after the first test failure.
 
 	-fuzz regexp
-	    Run the fuzz target matching the regular expression. When specified,
+	    Run the fuzz test matching the regular expression. When specified,
 	    the command line argument must match exactly one package within the
-	    main module, and regexp must match exactly one fuzz target within
-	    that package. After tests, benchmarks, seed corpora of other fuzz
-	    targets, and examples have completed, the matching target will be
-	    fuzzed. See the Fuzzing section of the testing package documentation
-	    for details.
+	    main module, and regexp must match exactly one fuzz test within
+	    that package. Fuzzing will occur after tests, benchmarks, seed corpora
+	    of other fuzz tests, and examples have completed. See the Fuzzing
+	    section of the testing package documentation for details.
 
 	-fuzztime t
 	    Run enough iterations of the fuzz test to take t, specified as a
@@ -269,14 +268,14 @@ control the execution of any test:
 	    same information as the -v flag in a machine-readable format.
 
 	-list regexp
-	    List tests, benchmarks, fuzz targets, or examples matching the regular
-	    expression. No tests, benchmarks, fuzz targets, or examples will be run.
+	    List tests, benchmarks, fuzz tests, or examples matching the regular
+	    expression. No tests, benchmarks, fuzz tests, or examples will be run.
 	    This will only list top-level tests. No subtest or subbenchmarks will be
 	    shown.
 
 	-parallel n
 	    Allow parallel execution of test functions that call t.Parallel, and
-	    f.Fuzz functions that call t.Parallel when running the seed corpus.
+	    fuzz targets that call t.Parallel when running the seed corpus.
 	    The value of this flag is the maximum number of tests to run
 	    simultaneously.
 	    While fuzzing, the value of this flag is the maximum number of
@@ -291,7 +290,7 @@ control the execution of any test:
 	    (see 'go help build').
 
 	-run regexp
-	    Run only those tests, examples, and fuzz targets matching the regular
+	    Run only those tests, examples, and fuzz tests matching the regular
 	    expression. For tests, the regular expression is split by unbracketed
 	    slash (/) characters into a sequence of regular expressions, and each
 	    part of a test's identifier must match the corresponding element in
@@ -468,7 +467,7 @@ A benchmark function is one named BenchmarkXxx and should have the signature,
 
 	func BenchmarkXxx(b *testing.B) { ... }
 
-A fuzz target is one named FuzzXxx and should have the signature,
+A fuzz test is one named FuzzXxx and should have the signature,
 
 	func FuzzXxx(f *testing.F) { ... }
 
@@ -511,7 +510,7 @@ Here is another example where the ordering of the output is ignored:
 
 The entire test file is presented as the example when it contains a single
 example function, at least one other function, type, variable, or constant
-declaration, and no fuzz targets or test or benchmark functions.
+declaration, and no tests, benchmarks, or fuzz tests.
 
 See the documentation of the testing package for more information.
 `,
@@ -1196,8 +1195,8 @@ func declareCoverVars(p *load.Package, files ...string) map[string]*load.CoverVa
 }
 
 var noTestsToRun = []byte("\ntesting: warning: no tests to run\n")
-var noTargetsToFuzz = []byte("\ntesting: warning: no targets to fuzz\n")
-var tooManyTargetsToFuzz = []byte("\ntesting: warning: -fuzz matches more than one target, won't fuzz\n")
+var noFuzzTestsToFuzz = []byte("\ntesting: warning: no fuzz tests to fuzz\n")
+var tooManyFuzzTestsToFuzz = []byte("\ntesting: warning: -fuzz matches more than one fuzz test, won't fuzz\n")
 
 type runCache struct {
 	disableCache bool // cache should be disabled for this run
@@ -1399,11 +1398,11 @@ func (c *runCache) builderRunTest(b *work.Builder, ctx context.Context, a *work.
 		if bytes.HasPrefix(out, noTestsToRun[1:]) || bytes.Contains(out, noTestsToRun) {
 			norun = " [no tests to run]"
 		}
-		if bytes.HasPrefix(out, noTargetsToFuzz[1:]) || bytes.Contains(out, noTargetsToFuzz) {
-			norun = " [no targets to fuzz]"
+		if bytes.HasPrefix(out, noFuzzTestsToFuzz[1:]) || bytes.Contains(out, noFuzzTestsToFuzz) {
+			norun = " [no fuzz tests to fuzz]"
 		}
-		if bytes.HasPrefix(out, tooManyTargetsToFuzz[1:]) || bytes.Contains(out, tooManyTargetsToFuzz) {
-			norun = " [will not fuzz, -fuzz matches more than one target]"
+		if bytes.HasPrefix(out, tooManyFuzzTestsToFuzz[1:]) || bytes.Contains(out, tooManyFuzzTestsToFuzz) {
+			norun = "[-fuzz matches more than one fuzz test, won't fuzz]"
 		}
 		if len(out) > 0 && !bytes.HasSuffix(out, []byte("\n")) {
 			// Ensure that the output ends with a newline before the "ok"
diff --git a/src/cmd/go/testdata/script/test_fuzz.txt b/src/cmd/go/testdata/script/test_fuzz.txt
index 150491be04..3e048e00c5 100644
--- a/src/cmd/go/testdata/script/test_fuzz.txt
+++ b/src/cmd/go/testdata/script/test_fuzz.txt
@@ -60,34 +60,34 @@ stdout ok
 ! stdout ^ok
 ! stdout 'fatal here'
 stdout FAIL
-stdout 'f.Fuzz function'
+stdout 'fuzz target'
 
 # Test that f.Error within f.Fuzz panics
 ! go test error_fuzz_fn_fuzz_test.go
 ! stdout ^ok
 ! stdout 'error here'
 stdout FAIL
-stdout 'f.Fuzz function'
+stdout 'fuzz target'
 
 # Test that f.Fail within f.Fuzz panics
 ! go test fail_fuzz_fn_fuzz_test.go
 ! stdout ^ok
 stdout FAIL
-stdout 'f.Fuzz function'
+stdout 'fuzz target'
 
 # Test that f.Skip within f.Fuzz panics
 ! go test skip_fuzz_fn_fuzz_test.go
 ! stdout ^ok
 ! stdout 'skip here'
 stdout FAIL
-stdout 'f.Fuzz function'
+stdout 'fuzz target'
 
 # Test that f.Skipped within f.Fuzz panics
 ! go test skipped_fuzz_fn_fuzz_test.go
 ! stdout ^ok
 ! stdout 'f.Skipped is'
 stdout FAIL
-stdout 'f.Fuzz function'
+stdout 'fuzz target'
 stdout 't.Skipped is false'
 
 # Test that runtime.Goexit within the fuzz function is an error.
diff --git a/src/cmd/go/testdata/script/test_fuzz_match.txt b/src/cmd/go/testdata/script/test_fuzz_match.txt
index 0c0085f2c2..dbf987605f 100644
--- a/src/cmd/go/testdata/script/test_fuzz_match.txt
+++ b/src/cmd/go/testdata/script/test_fuzz_match.txt
@@ -14,7 +14,7 @@ stdout '^ok'
 go test -fuzz ThisWillNotMatch -fuzztime 1x standalone_fuzz_test.go
 ! stdout '^ok.*no tests to run'
 stdout '^ok'
-stdout 'no targets to fuzz'
+stdout 'no fuzz tests to fuzz'
 
 [short] stop
 
@@ -26,7 +26,7 @@ stdout '^ok'
 # Matches no fuzz targets.
 go test -run ThisWillNotMatch standalone_fuzz_test.go
 stdout '^ok.*no tests to run'
-! stdout 'no targets to fuzz'
+! stdout 'no fuzz tests to fuzz'
 
 -- standalone_fuzz_test.go --
 package standalone_fuzz
diff --git a/src/cmd/go/testdata/script/test_fuzz_multiple.txt b/src/cmd/go/testdata/script/test_fuzz_multiple.txt
index d96b2b6206..1ec4985613 100644
--- a/src/cmd/go/testdata/script/test_fuzz_multiple.txt
+++ b/src/cmd/go/testdata/script/test_fuzz_multiple.txt
@@ -18,7 +18,7 @@ go test -fuzz=. -fuzztime=1x ./one
 
 # With fuzzing enabled, at most one target in the same package may match.
 ! go test -fuzz=. ./two
-stdout '^testing: will not fuzz, -fuzz matches more than one target: \[FuzzOne FuzzTwo\]$'
+stdout '^testing: will not fuzz, -fuzz matches more than one fuzz test: \[FuzzOne FuzzTwo\]$'
 go test -fuzz=FuzzTwo -fuzztime=1x ./two
 
 -- go.mod --
diff --git a/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt b/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
index 15d7cb6b32..60f5787464 100644
--- a/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
+++ b/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
@@ -13,7 +13,7 @@
 ! exists want
 ! go test -fuzz=. -parallel=1 -fuzztime=110x -fuzzminimizetime=10x -v
 stdout 'fuzzing process terminated unexpectedly'
-stdout 'Crash written to testdata'
+stdout 'Failing input written to testdata'
 
 # Run the fuzz target without fuzzing. The fuzz function is called with the
 # crashing input in testdata. The test passes if that input is identical to
diff --git a/src/cmd/go/testdata/script/test_fuzz_seed_corpus.txt b/src/cmd/go/testdata/script/test_fuzz_seed_corpus.txt
index 4be9a6e385..57c8a8ba65 100644
--- a/src/cmd/go/testdata/script/test_fuzz_seed_corpus.txt
+++ b/src/cmd/go/testdata/script/test_fuzz_seed_corpus.txt
@@ -6,7 +6,7 @@ env GOCACHE=$WORK/cache
 # and doesn't write anything to testdata/fuzz
 ! go test -fuzz=FuzzWithAdd -run=FuzzWithAdd -fuzztime=1x
 ! stdout ^ok
-! stdout 'Crash written to testdata[/\\]fuzz[/\\]FuzzWithAdd[/\\]'
+! stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithAdd[/\\]'
 stdout FAIL
 
 # Test that fuzzing a target with a sucess in f.Add and a fuzztime of only
@@ -19,15 +19,15 @@ stdout ok
 # and doesn't write anything to testdata/fuzz
 ! go test -fuzz=FuzzWithTestdata -run=FuzzWithTestdata -fuzztime=1x
 ! stdout ^ok
-! stdout 'Crash written to testdata[/\\]fuzz[/\\]FuzzWithTestdata[/\\]'
-stdout 'found a crash while testing seed corpus entry: FuzzWithTestdata/1'
+! stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithTestdata[/\\]'
+stdout 'failure while testing seed corpus entry: FuzzWithTestdata/1'
 stdout FAIL
 
 # Test that fuzzing a target with no seed corpus or cache finds a crash, prints
 # it, and write it to testdata
 ! go test -fuzz=FuzzWithNoCache -run=FuzzWithNoCache -fuzztime=1x
 ! stdout ^ok
-stdout 'Crash written to testdata[/\\]fuzz[/\\]FuzzWithNoCache[/\\]'
+stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithNoCache[/\\]'
 stdout FAIL
 
 # Write a crashing input to the cache
@@ -38,7 +38,7 @@ cp cache-file $GOCACHE/fuzz/example.com/x/FuzzWithCache/1
 # and writes this as a "new" crash to testdata/fuzz
 ! go test -fuzz=FuzzWithCache -run=FuzzWithCache -fuzztime=1x
 ! stdout ^ok
-stdout 'Crash written to testdata[/\\]fuzz[/\\]FuzzWithCache[/\\]'
+stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithCache[/\\]'
 stdout FAIL
 
 # Write a crashing input to the cache
@@ -52,7 +52,7 @@ cp cache-file-bytes $GOCACHE/fuzz/example.com/x/FuzzWithMinimizableCache/1
 stdout 'gathering baseline coverage'
 stdout 'got the minimum size!'
 stdout 'contains a non-zero byte of length 10'
-stdout 'Crash written to testdata[/\\]fuzz[/\\]FuzzWithMinimizableCache[/\\]'
+stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithMinimizableCache[/\\]'
 stdout FAIL
 # Make sure this crash didn't come from fuzzing
 # (the log line that states fuzzing began shouldn't have printed)
@@ -70,7 +70,7 @@ go clean -fuzzcache
 # the crash and doesn't write anything to testdata/fuzz -fuzztime=1x
 ! go test -fuzz=FuzzWithAdd -run=None
 ! stdout ^ok
-! stdout 'Crash written to testdata[/\\]fuzz[/\\]FuzzWithAdd[/\\]'
+! stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithAdd[/\\]'
 stdout FAIL
 
 # Test that fuzzing a target (with -run=None set) with a sucess in f.Add and a
@@ -83,7 +83,7 @@ stdout ok
 # testdata/fuzz prints the crash and doesn't write anything to testdata/fuzz
 ! go test -fuzz=FuzzWithTestdata -run=None -fuzztime=1x
 ! stdout ^ok
-! stdout 'Crash written to testdata[/\\]fuzz[/\\]FuzzWithTestdata[/\\]'
+! stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithTestdata[/\\]'
 stdout FAIL
 
 # Write a crashing input to the cache
@@ -94,7 +94,7 @@ cp cache-file $GOCACHE/fuzz/example.com/x/FuzzRunNoneWithCache/1
 # prints the crash and writes this as a "new" crash to testdata/fuzz
 ! go test -fuzz=FuzzRunNoneWithCache -run=None -fuzztime=1x
 ! stdout ^ok
-stdout 'Crash written to testdata[/\\]fuzz[/\\]FuzzRunNoneWithCache[/\\]'
+stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzRunNoneWithCache[/\\]'
 stdout FAIL
 
 # Clear the fuzz cache and make sure it's gone
@@ -109,14 +109,14 @@ go clean -fuzzcache
 go test -c
 ! exec ./x.test$GOEXE -test.fuzz=FuzzWithAdd -test.run=FuzzWithAdd -test.fuzztime=1x -test.fuzzcachedir=$WORK/cache
 ! stdout ^ok
-! stdout 'Crash written to testdata[/\\]fuzz[/\\]FuzzWithAdd[/\\]'
+! stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithAdd[/\\]'
 stdout FAIL
 stderr warning
 
 go test -c
 ! exec ./x.test$GOEXE -test.fuzz=FuzzWithTestdata -test.run=FuzzWithTestdata -test.fuzztime=1x -test.fuzzcachedir=$WORK/cache
 ! stdout ^ok
-! stdout 'Crash written to testdata[/\\]fuzz[/\\]FuzzWithTestdata[/\\]'
+! stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithTestdata[/\\]'
 stdout FAIL
 stderr warning
 
diff --git a/src/go/doc/example.go b/src/go/doc/example.go
index fbbd846354..0a880cdefb 100644
--- a/src/go/doc/example.go
+++ b/src/go/doc/example.go
@@ -44,13 +44,13 @@ type Example struct {
 //     identifiers from other packages (or predeclared identifiers, such as
 //     "int") and the test file does not include a dot import.
 //   - The entire test file is the example: the file contains exactly one
-//     example function, zero test, fuzz target, or benchmark function, and at
+//     example function, zero test, fuzz test, or benchmark function, and at
 //     least one top-level function, type, variable, or constant declaration
 //     other than the example function.
 func Examples(testFiles ...*ast.File) []*Example {
 	var list []*Example
 	for _, file := range testFiles {
-		hasTests := false // file contains tests, fuzz targets, or benchmarks
+		hasTests := false // file contains tests, fuzz test, or benchmarks
 		numDecl := 0      // number of non-import declarations in the file
 		var flist []*Example
 		for _, decl := range file.Decls {
@@ -133,7 +133,7 @@ func exampleOutput(b *ast.BlockStmt, comments []*ast.CommentGroup) (output strin
 	return "", false, false // no suitable comment found
 }
 
-// isTest tells whether name looks like a test, example, fuzz target, or
+// isTest tells whether name looks like a test, example, fuzz test, or
 // benchmark. It is a Test (say) if there is a character after Test that is not
 // a lower-case letter. (We don't want Testiness.)
 func isTest(name, prefix string) bool {
diff --git a/src/internal/fuzz/fuzz.go b/src/internal/fuzz/fuzz.go
index 8bd40fe8bf..cb739232c7 100644
--- a/src/internal/fuzz/fuzz.go
+++ b/src/internal/fuzz/fuzz.go
@@ -232,7 +232,7 @@ func CoordinateFuzzing(ctx context.Context, opts CoordinateFuzzingOpts) (err err
 			if result.crasherMsg != "" {
 				if c.warmupRun() && result.entry.IsSeed {
 					target := filepath.Base(c.opts.CorpusDir)
-					fmt.Fprintf(c.opts.Log, "found a crash while testing seed corpus entry: %s/%s\n", target, testName(result.entry.Parent))
+					fmt.Fprintf(c.opts.Log, "failure while testing seed corpus entry: %s/%s\n", target, testName(result.entry.Parent))
 					stop(errors.New(result.crasherMsg))
 					break
 				}
@@ -246,7 +246,7 @@ func CoordinateFuzzing(ctx context.Context, opts CoordinateFuzzingOpts) (err err
 					// Send it back to a worker for minimization. Disable inputC so
 					// other workers don't continue fuzzing.
 					c.crashMinimizing = &result
-					fmt.Fprintf(c.opts.Log, "fuzz: minimizing %d-byte crash file\n", len(result.entry.Data))
+					fmt.Fprintf(c.opts.Log, "fuzz: minimizing %d-byte failing input file\n", len(result.entry.Data))
 					c.queueForMinimization(result, nil)
 				} else if !crashWritten {
 					// Found a crasher that's either minimized or not minimizable.
diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go
index 46c9d63df4..24a0080730 100644
--- a/src/testing/fuzz.go
+++ b/src/testing/fuzz.go
@@ -19,9 +19,9 @@ import (
 )
 
 func initFuzzFlags() {
-	matchFuzz = flag.String("test.fuzz", "", "run the fuzz target matching `regexp`")
+	matchFuzz = flag.String("test.fuzz", "", "run the fuzz test matching `regexp`")
 	flag.Var(&fuzzDuration, "test.fuzztime", "time to spend fuzzing; default is to run indefinitely")
-	flag.Var(&minimizeDuration, "test.fuzzminimizetime", "time to spend minimizing a value after finding a crash")
+	flag.Var(&minimizeDuration, "test.fuzzminimizetime", "time to spend minimizing a value after finding a failing input")
 	fuzzCacheDir = flag.String("test.fuzzcachedir", "", "directory where interesting fuzzing inputs are stored")
 	isFuzzWorker = flag.Bool("test.fuzzworker", false, "coordinate with the parent process to fuzz random values")
 }
@@ -33,34 +33,38 @@ var (
 	fuzzCacheDir     *string
 	isFuzzWorker     *bool
 
-	// corpusDir is the parent directory of the target's seed corpus within
+	// corpusDir is the parent directory of the fuzz test's seed corpus within
 	// the package.
 	corpusDir = "testdata/fuzz"
 )
 
-// fuzzWorkerExitCode is used as an exit code by fuzz worker processes after an internal error.
-// This distinguishes internal errors from uncontrolled panics and other crashes.
-// Keep in sync with internal/fuzz.workerExitCode.
+// fuzzWorkerExitCode is used as an exit code by fuzz worker processes after an
+// internal error. This distinguishes internal errors from uncontrolled panics
+// and other failiures. Keep in sync with internal/fuzz.workerExitCode.
 const fuzzWorkerExitCode = 70
 
-// InternalFuzzTarget is an internal type but exported because it is cross-package;
-// it is part of the implementation of the "go test" command.
+// InternalFuzzTarget is an internal type but exported because it is
+// cross-package; it is part of the implementation of the "go test" command.
 type InternalFuzzTarget struct {
 	Name string
 	Fn   func(f *F)
 }
 
-// F is a type passed to fuzz targets.
+// F is a type passed to fuzz tests.
 //
-// A fuzz target may add seed corpus entries using F.Add or by storing files in
-// the testdata/fuzz/ directory. The fuzz target must then
-// call F.Fuzz once to provide a fuzz function. See the testing package
-// documentation for an example, and see the F.Fuzz and F.Add method
-// documentation for details.
+// Fuzz tests run generated inputs against a provided fuzz target, which can
+// find and report potential bugs in the code being tested.
 //
-// *F methods can only be called before (*F).Fuzz. Once inside the function
-// passed to (*F).Fuzz, only (*T) methods can be used. The only *F methods that
-// are allowed in the (*F).Fuzz function are (*F).Failed and (*F).Name.
+// A fuzz test runs the seed corpus by default, which includes entries provided
+// by (*F).Add and entries in the testdata/fuzz/ directory. After
+// any necessary setup and calls to (*F).Add, the fuzz test must then call
+// (*F).Fuzz to provide the fuzz target. See the testing package documentation
+// for an example, and see the F.Fuzz and F.Add method documentation for
+// details.
+//
+// *F methods can only be called before (*F).Fuzz. Once the the test is
+// executing the fuzz target, only (*T) methods can be used. The only *F methods
+// that are allowed in the (*F).Fuzz function are (*F).Failed and (*F).Name.
 type F struct {
 	common
 	fuzzContext *fuzzContext
@@ -97,7 +101,7 @@ type corpusEntry = struct {
 // Helper may be called simultaneously from multiple goroutines.
 func (f *F) Helper() {
 	if f.inFuzzFn {
-		panic("testing: f.Helper was called inside the f.Fuzz function, use t.Helper instead")
+		panic("testing: f.Helper was called inside the fuzz target, use t.Helper instead")
 	}
 
 	// common.Helper is inlined here.
@@ -125,7 +129,7 @@ func (f *F) Fail() {
 	// (*F).Fail may be called by (*T).Fail, which we should allow. However, we
 	// shouldn't allow direct (*F).Fail calls from inside the (*F).Fuzz function.
 	if f.inFuzzFn {
-		panic("testing: f.Fail was called inside the f.Fuzz function, use t.Fail instead")
+		panic("testing: f.Fail was called inside the fuzz target, use t.Fail instead")
 	}
 	f.common.Helper()
 	f.common.Fail()
@@ -136,15 +140,15 @@ func (f *F) Skipped() bool {
 	// (*F).Skipped may be called by tRunner, which we should allow. However, we
 	// shouldn't allow direct (*F).Skipped calls from inside the (*F).Fuzz function.
 	if f.inFuzzFn {
-		panic("testing: f.Skipped was called inside the f.Fuzz function, use t.Skipped instead")
+		panic("testing: f.Skipped was called inside the fuzz target, use t.Skipped instead")
 	}
 	f.common.Helper()
 	return f.common.Skipped()
 }
 
-// Add will add the arguments to the seed corpus for the fuzz target. This will
-// be a no-op if called after or within the Fuzz function. The args must match
-// those in the Fuzz function.
+// Add will add the arguments to the seed corpus for the fuzz test. This will be
+// a no-op if called after or within the fuzz target, and args must match the
+// arguments for the fuzz target.
 func (f *F) Add(args ...interface{}) {
 	var values []interface{}
 	for i := range args {
@@ -220,7 +224,7 @@ func (f *F) Fuzz(ff interface{}) {
 		panic("testing: F.Fuzz must receive a function")
 	}
 	if fnType.NumIn() < 2 || fnType.In(0) != reflect.TypeOf((*T)(nil)) {
-		panic("testing: F.Fuzz function must receive at least two arguments, where the first argument is a *T")
+		panic("testing: fuzz target must receive at least two arguments, where the first argument is a *T")
 	}
 
 	// Save the types of the function to compare against the corpus.
@@ -354,7 +358,7 @@ func (f *F) Fuzz(ff interface{}) {
 			fmt.Fprintf(f.w, "%v\n", err)
 			if crashErr, ok := err.(fuzzCrashError); ok {
 				crashPath := crashErr.CrashPath()
-				fmt.Fprintf(f.w, "Crash written to %s\n", crashPath)
+				fmt.Fprintf(f.w, "Failing input written to %s\n", crashPath)
 				testName := filepath.Base(crashPath)
 				fmt.Fprintf(f.w, "To re-run:\ngo test -run=%s/%s\n", f.name, testName)
 			}
@@ -378,7 +382,7 @@ func (f *F) Fuzz(ff interface{}) {
 		}); err != nil {
 			// Internal errors are marked with f.Fail; user code may call this too, before F.Fuzz.
 			// The worker will exit with fuzzWorkerExitCode, indicating this is a failure
-			// (and 'go test' should exit non-zero) but a crasher should not be recorded.
+			// (and 'go test' should exit non-zero) but a failing input should not be recorded.
 			f.Errorf("communicating with fuzzing coordinator: %v", err)
 		}
 
@@ -415,7 +419,7 @@ func (f *F) report() {
 type fuzzResult struct {
 	N     int           // The number of iterations.
 	T     time.Duration // The total time taken.
-	Error error         // Error is the error from the crash
+	Error error         // Error is the error from the failing input
 }
 
 func (r fuzzResult) String() string {
@@ -427,7 +431,7 @@ func (r fuzzResult) String() string {
 	return s
 }
 
-// fuzzCrashError is satisfied by a crash detected within the fuzz function.
+// fuzzCrashError is satisfied by a failing input detected while fuzzing.
 // These errors are written to the seed corpus and can be re-run with 'go test'.
 // Errors within the fuzzing framework (like I/O errors between coordinator
 // and worker processes) don't satisfy this interface.
@@ -437,12 +441,12 @@ type fuzzCrashError interface {
 
 	// CrashPath returns the path of the subtest that corresponds to the saved
 	// crash input file in the seed corpus. The test can be re-run with go test
-	// -run=$target/$name $target is the fuzz target name, and $name is the
+	// -run=$test/$name $test is the fuzz test name, and $name is the
 	// filepath.Base of the string returned here.
 	CrashPath() string
 }
 
-// fuzzContext holds fields common to all fuzz targets.
+// fuzzContext holds fields common to all fuzz tests.
 type fuzzContext struct {
 	deps testDeps
 	mode fuzzMode
@@ -456,12 +460,12 @@ const (
 	fuzzWorker
 )
 
-// runFuzzTargets runs the fuzz targets matching the pattern for -run. This will
-// only run the f.Fuzz function for each seed corpus without using the fuzzing
-// engine to generate or mutate inputs.
-func runFuzzTargets(deps testDeps, fuzzTargets []InternalFuzzTarget, deadline time.Time) (ran, ok bool) {
+// runFuzzTests runs the fuzz tests matching the pattern for -run. This will
+// only run the (*F).Fuzz function for each seed corpus without using the
+// fuzzing engine to generate or mutate inputs.
+func runFuzzTests(deps testDeps, fuzzTests []InternalFuzzTarget, deadline time.Time) (ran, ok bool) {
 	ok = true
-	if len(fuzzTargets) == 0 || *isFuzzWorker {
+	if len(fuzzTests) == 0 || *isFuzzWorker {
 		return ran, ok
 	}
 	m := newMatcher(deps.MatchString, *match, "-test.run")
@@ -476,7 +480,7 @@ func runFuzzTargets(deps testDeps, fuzzTargets []InternalFuzzTarget, deadline ti
 	if Verbose() {
 		root.chatty = newChattyPrinter(root.w)
 	}
-	for _, ft := range fuzzTargets {
+	for _, ft := range fuzzTests {
 		if shouldFailFast() {
 			break
 		}
@@ -486,7 +490,7 @@ func runFuzzTargets(deps testDeps, fuzzTargets []InternalFuzzTarget, deadline ti
 		}
 		if mFuzz != nil {
 			if _, fuzzMatched, _ := mFuzz.fullName(nil, ft.Name); fuzzMatched {
-				// If this target will be fuzzed, then don't run the seed corpus
+				// If this will be fuzzed, then don't run the seed corpus
 				// right now. That will happen later.
 				continue
 			}
@@ -515,17 +519,14 @@ func runFuzzTargets(deps testDeps, fuzzTargets []InternalFuzzTarget, deadline ti
 	return root.ran, !root.Failed()
 }
 
-// runFuzzing runs the fuzz target matching the pattern for -fuzz. Only one such
-// fuzz target must match. This will run the fuzzing engine to generate and
-// mutate new inputs against the f.Fuzz function.
+// runFuzzing runs the fuzz test matching the pattern for -fuzz. Only one such
+// fuzz test must match. This will run the fuzzing engine to generate and
+// mutate new inputs against the fuzz target.
 //
 // If fuzzing is disabled (-test.fuzz is not set), runFuzzing
 // returns immediately.
-func runFuzzing(deps testDeps, fuzzTargets []InternalFuzzTarget) (ok bool) {
-	// TODO(katiehockman,jayconrod): Should we do something special to make sure
-	// we don't print f.Log statements again with runFuzzing, since we already
-	// would have printed them when we ran runFuzzTargets (ie. seed corpus run)?
-	if len(fuzzTargets) == 0 || *matchFuzz == "" {
+func runFuzzing(deps testDeps, fuzzTests []InternalFuzzTarget) (ok bool) {
+	if len(fuzzTests) == 0 || *matchFuzz == "" {
 		return true
 	}
 	m := newMatcher(deps.MatchString, *matchFuzz, "-test.fuzz")
@@ -544,24 +545,24 @@ func runFuzzing(deps testDeps, fuzzTargets []InternalFuzzTarget) (ok bool) {
 	if Verbose() && !*isFuzzWorker {
 		root.chatty = newChattyPrinter(root.w)
 	}
-	var target *InternalFuzzTarget
-	var targetName string
+	var fuzzTest *InternalFuzzTarget
+	var testName string
 	var matched []string
-	for i := range fuzzTargets {
-		name, ok, _ := tctx.match.fullName(nil, fuzzTargets[i].Name)
+	for i := range fuzzTests {
+		name, ok, _ := tctx.match.fullName(nil, fuzzTests[i].Name)
 		if !ok {
 			continue
 		}
 		matched = append(matched, name)
-		target = &fuzzTargets[i]
-		targetName = name
+		fuzzTest = &fuzzTests[i]
+		testName = name
 	}
 	if len(matched) == 0 {
-		fmt.Fprintln(os.Stderr, "testing: warning: no targets to fuzz")
+		fmt.Fprintln(os.Stderr, "testing: warning: no fuzz tests to fuzz")
 		return true
 	}
 	if len(matched) > 1 {
-		fmt.Fprintf(os.Stderr, "testing: will not fuzz, -fuzz matches more than one target: %v\n", matched)
+		fmt.Fprintf(os.Stderr, "testing: will not fuzz, -fuzz matches more than one fuzz test: %v\n", matched)
 		return false
 	}
 
@@ -569,7 +570,7 @@ func runFuzzing(deps testDeps, fuzzTargets []InternalFuzzTarget) (ok bool) {
 		common: common{
 			signal:  make(chan bool),
 			barrier: nil, // T.Parallel has no effect when fuzzing.
-			name:    targetName,
+			name:    testName,
 			parent:  &root,
 			level:   root.level + 1,
 			chatty:  root.chatty,
@@ -582,31 +583,32 @@ func runFuzzing(deps testDeps, fuzzTargets []InternalFuzzTarget) (ok bool) {
 		// TODO(#48132): adjust this to work with test2json.
 		f.chatty.Updatef(f.name, "=== FUZZ  %s\n", f.name)
 	}
-	go fRunner(f, target.Fn)
+	go fRunner(f, fuzzTest.Fn)
 	<-f.signal
 	return !f.failed
 }
 
-// fRunner wraps a call to a fuzz target and ensures that cleanup functions are
+// fRunner wraps a call to a fuzz test and ensures that cleanup functions are
 // called and status flags are set. fRunner should be called in its own
 // goroutine. To wait for its completion, receive from f.signal.
 //
 // fRunner is analogous to tRunner, which wraps subtests started with T.Run.
-// Tests and fuzz targets work a little differently, so for now, these functions
-// aren't consolidated. In particular, because there are no F.Run and F.Parallel
-// methods, i.e., no fuzz sub-targets or parallel fuzz targets, a few
+// Unit tests and fuzz tests work a little differently, so for now, these
+// functions aren't consolidated. In particular, because there are no F.Run and
+// F.Parallel methods, i.e., no fuzz sub-tests or parallel fuzz tests, a few
 // simplifications are made. We also require that F.Fuzz, F.Skip, or F.Fail is
 // called.
 func fRunner(f *F, fn func(*F)) {
-	// When this goroutine is done, either because runtime.Goexit was called,
-	// a panic started, or fn returned normally, record the duration and send
-	// t.signal, indicating the fuzz target is done.
+	// When this goroutine is done, either because runtime.Goexit was called, a
+	// panic started, or fn returned normally, record the duration and send
+	// t.signal, indicating the fuzz test is done.
 	defer func() {
-		// Detect whether the fuzz target panicked or called runtime.Goexit without
-		// calling F.Fuzz, F.Fail, or F.Skip. If it did, panic (possibly replacing a
-		// nil panic value). Nothing should recover after fRunner unwinds, so this
-		// should crash the process and print stack. Unfortunately, recovering here
-		// adds stack frames, but the location of the original panic should still be
+		// Detect whether the fuzz test panicked or called runtime.Goexit
+		// without calling F.Fuzz, F.Fail, or F.Skip. If it did, panic (possibly
+		// replacing a nil panic value). Nothing should recover after fRunner
+		// unwinds, so this should crash the process and print stack.
+		// Unfortunately, recovering here adds stack frames, but the location of
+		// the original panic should still be
 		// clear.
 		if f.Failed() {
 			atomic.AddUint32(&numFailed, 1)
@@ -662,7 +664,7 @@ func fRunner(f *F, fn func(*F)) {
 
 		if len(f.sub) > 0 {
 			// Unblock inputs that called T.Parallel while running the seed corpus.
-			// This only affects fuzz targets run as normal tests.
+			// This only affects fuzz tests run as normal tests.
 			// While fuzzing, T.Parallel has no effect, so f.sub is empty, and this
 			// branch is not taken. f.barrier is nil in that case.
 			close(f.barrier)
diff --git a/src/testing/testing.go b/src/testing/testing.go
index 2ad2266e2d..3458b46d97 100644
--- a/src/testing/testing.go
+++ b/src/testing/testing.go
@@ -146,11 +146,9 @@
 // a function is called with randomly generated inputs to find bugs not
 // anticipated by unit tests.
 //
-// A fuzz target is a function that declares a set of "seed" inputs by calling
-// F.Add, then provides a fuzz function by calling F.Fuzz. A fuzz target has
-// the form:
-//
+// Functions of the form
 //     func FuzzXxx(*testing.F)
+// are considered fuzz tests.
 //
 // For example:
 //
@@ -170,35 +168,38 @@
 //       })
 //     }
 //
-// Seed inputs may be registered by calling F.Add or by storing files in the
-// directory testdata/fuzz/ (where  is the name of the fuzz target)
-// within the package containing the fuzz target. Seed inputs are optional, but
-// the fuzzing engine may find bugs more efficiently when provided with a set
-// of small seed inputs with good code coverage.
+// A fuzz test maintains a seed corpus, or a set of inputs which are run by
+// default, and can seed input generation. Seed inputs may be registered by
+// calling (*F).Add or by storing files in the directory testdata/fuzz/
+// (where  is the name of the fuzz test) within the package containing
+// the fuzz test. Seed inputs are optional, but the fuzzing engine may find
+// bugs more efficiently when provided with a set of small seed inputs with good
+// code coverage. These seed inputs can also serve as regression tests for bugs
+// identified through fuzzing.
 //
-// The fuzz function provided to F.Fuzz must accept a *testing.T parameter,
-// followed by one or more parameters for random inputs. The types of arguments
-// passed to F.Add must be identical to the types of these parameters. The fuzz
-// function may signal that it's found a problem the same way tests do: by
-// calling T.Fail (or any method that calls it like T.Error or T.Fatal) or by
-// panicking.
+// The function passed to (*F).Fuzz within the fuzz test is considered the fuzz
+// target. A fuzz target must accept a *T parameter, followed by one or more
+// parameters for random inputs. The types of arguments passed to (*F).Add must
+// be identical to the types of these parameters. The fuzz target may signal
+// that it's found a problem the same way tests do: by calling T.Fail (or any
+// method that calls it like T.Error or T.Fatal) or by panicking.
 //
 // When fuzzing is enabled (by setting the -fuzz flag to a regular expression
-// that matches a specific fuzz target), the fuzz function is called with
-// arguments generated by repeatedly making random changes to the seed inputs.
-// On supported platforms, 'go test' compiles the test executable with fuzzing
+// that matches a specific fuzz test), the fuzz target is called with arguments
+// generated by repeatedly making random changes to the seed inputs. On
+// supported platforms, 'go test' compiles the test executable with fuzzing
 // coverage instrumentation. The fuzzing engine uses that instrumentation to
-// find and cache inputs that expand coverage, increasing the liklihood of
-// finding bugs. If the fuzz function finds a problem, the fuzzing engine writes
-// the inputs that caused the problem to a file in the directory
+// find and cache inputs that expand coverage, increasing the likelihood of
+// finding bugs. If the fuzz target fails for a given input, the fuzzing engine
+// writes the inputs that caused the failure to a file in the directory
 // testdata/fuzz/ within the package directory. This file later serves as
 // a seed input. If the file can't be written at that location (for example,
 // because the directory is read-only), the fuzzing engine writes the file to
 // the fuzz cache directory within the build cache instead.
 //
-// When fuzzing is disabled, the fuzz function is called with the seed inputs
+// When fuzzing is disabled, the fuzz target is called with the seed inputs
 // registered with F.Add and seed inputs from testdata/fuzz/. In this
-// mode, the fuzz target acts much like a regular test, with subtests started
+// mode, the fuzz test acts much like a regular test, with subtests started
 // with F.Fuzz instead of T.Run.
 //
 // TODO(#48255): write and link to documentation that will be helpful to users
@@ -217,7 +218,7 @@
 //     }
 //
 // The Skip method of *T can be used in a fuzz target if the input is invalid,
-// but should not be considered a crash. For example:
+// but should not be considered a failing input. For example:
 //
 //     func FuzzJSONMarshalling(f *testing.F) {
 //         f.Fuzz(func(t *testing.T, b []byte) {
@@ -500,7 +501,7 @@ type common struct {
 	cleanupName string               // Name of the cleanup function.
 	cleanupPc   []uintptr            // The stack trace at the point where Cleanup was called.
 	finished    bool                 // Test function has completed.
-	inFuzzFn    bool                 // Whether the fuzz function, if this is one, is running.
+	inFuzzFn    bool                 // Whether the fuzz target, if this is one, is running.
 
 	chatty     *chattyPrinter // A copy of chattyPrinter, if the chatty flag is set.
 	bench      bool           // Whether the current test is a benchmark.
@@ -558,7 +559,7 @@ func Verbose() bool {
 
 func (c *common) checkFuzzFn(name string) {
 	if c.inFuzzFn {
-		panic(fmt.Sprintf("testing: f.%s was called inside the f.Fuzz function, use t.%s instead", name, name))
+		panic(fmt.Sprintf("testing: f.%s was called inside the fuzz target, use t.%s instead", name, name))
 	}
 }
 
@@ -1687,7 +1688,7 @@ func (m *M) Run() (code int) {
 		deadline := m.startAlarm()
 		haveExamples = len(m.examples) > 0
 		testRan, testOk := runTests(m.deps.MatchString, m.tests, deadline)
-		fuzzTargetsRan, fuzzTargetsOk := runFuzzTargets(m.deps, m.fuzzTargets, deadline)
+		fuzzTargetsRan, fuzzTargetsOk := runFuzzTests(m.deps, m.fuzzTargets, deadline)
 		exampleRan, exampleOk := runExamples(m.deps.MatchString, m.examples)
 		m.stopAlarm()
 		if !testRan && !exampleRan && !fuzzTargetsRan && *matchBenchmarks == "" && *matchFuzz == "" {

From c3c4a2bf6589f8c1e046149356fb5456b34a0df1 Mon Sep 17 00:00:00 2001
From: Pedro Lopez Mareque 
Date: Fri, 8 Oct 2021 07:01:35 +0200
Subject: [PATCH 116/752] math/bits: add examples for Add, Sub, Mul and Div

Change-Id: I2f3619aa827e18f356871511c20cf2c712f496b3
Reviewed-on: https://go-review.googlesource.com/c/go/+/353189
Run-TryBot: Ian Lance Taylor 
TryBot-Result: Go Bot 
Reviewed-by: Ian Lance Taylor 
Trust: Keith Randall 
---
 src/math/bits/example_math_test.go | 202 +++++++++++++++++++++++++++++
 1 file changed, 202 insertions(+)
 create mode 100644 src/math/bits/example_math_test.go

diff --git a/src/math/bits/example_math_test.go b/src/math/bits/example_math_test.go
new file mode 100644
index 0000000000..4bb466f85c
--- /dev/null
+++ b/src/math/bits/example_math_test.go
@@ -0,0 +1,202 @@
+// 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 bits_test
+
+import (
+	"fmt"
+	"math/bits"
+)
+
+func ExampleAdd32() {
+	// First number is 33<<32 + 12
+	n1 := []uint32{33, 12}
+	// Second number is 21<<32 + 23
+	n2 := []uint32{21, 23}
+	// Add them together without producing carry.
+	d1, carry := bits.Add32(n1[1], n2[1], 0)
+	d0, _ := bits.Add32(n1[0], n2[0], carry)
+	nsum := []uint32{d0, d1}
+	fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
+
+	// First number is 1<<32 + 2147483648
+	n1 = []uint32{1, 0x80000000}
+	// Second number is 1<<32 + 2147483648
+	n2 = []uint32{1, 0x80000000}
+	// Add them together producing carry.
+	d1, carry = bits.Add32(n1[1], n2[1], 0)
+	d0, _ = bits.Add32(n1[0], n2[0], carry)
+	nsum = []uint32{d0, d1}
+	fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
+	// Output:
+	// [33 12] + [21 23] = [54 35] (carry bit was 0)
+	// [1 2147483648] + [1 2147483648] = [3 0] (carry bit was 1)
+}
+
+func ExampleAdd64() {
+	// First number is 33<<64 + 12
+	n1 := []uint64{33, 12}
+	// Second number is 21<<64 + 23
+	n2 := []uint64{21, 23}
+	// Add them together without producing carry.
+	d1, carry := bits.Add64(n1[1], n2[1], 0)
+	d0, _ := bits.Add64(n1[0], n2[0], carry)
+	nsum := []uint64{d0, d1}
+	fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
+
+	// First number is 1<<64 + 9223372036854775808
+	n1 = []uint64{1, 0x8000000000000000}
+	// Second number is 1<<64 + 9223372036854775808
+	n2 = []uint64{1, 0x8000000000000000}
+	// Add them together producing carry.
+	d1, carry = bits.Add64(n1[1], n2[1], 0)
+	d0, _ = bits.Add64(n1[0], n2[0], carry)
+	nsum = []uint64{d0, d1}
+	fmt.Printf("%v + %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
+	// Output:
+	// [33 12] + [21 23] = [54 35] (carry bit was 0)
+	// [1 9223372036854775808] + [1 9223372036854775808] = [3 0] (carry bit was 1)
+}
+
+func ExampleSub32() {
+	// First number is 33<<32 + 23
+	n1 := []uint32{33, 23}
+	// Second number is 21<<32 + 12
+	n2 := []uint32{21, 12}
+	// Sub them together without producing carry.
+	d1, carry := bits.Sub32(n1[1], n2[1], 0)
+	d0, _ := bits.Sub32(n1[0], n2[0], carry)
+	nsum := []uint32{d0, d1}
+	fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
+
+	// First number is 3<<32 + 2147483647
+	n1 = []uint32{3, 0x7fffffff}
+	// Second number is 1<<32 + 2147483648
+	n2 = []uint32{1, 0x80000000}
+	// Sub them together producing carry.
+	d1, carry = bits.Sub32(n1[1], n2[1], 0)
+	d0, _ = bits.Sub32(n1[0], n2[0], carry)
+	nsum = []uint32{d0, d1}
+	fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
+	// Output:
+	// [33 23] - [21 12] = [12 11] (carry bit was 0)
+	// [3 2147483647] - [1 2147483648] = [1 4294967295] (carry bit was 1)
+}
+
+func ExampleSub64() {
+	// First number is 33<<64 + 23
+	n1 := []uint64{33, 23}
+	// Second number is 21<<64 + 12
+	n2 := []uint64{21, 12}
+	// Sub them together without producing carry.
+	d1, carry := bits.Sub64(n1[1], n2[1], 0)
+	d0, _ := bits.Sub64(n1[0], n2[0], carry)
+	nsum := []uint64{d0, d1}
+	fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
+
+	// First number is 3<<64 + 9223372036854775807
+	n1 = []uint64{3, 0x7fffffffffffffff}
+	// Second number is 1<<64 + 9223372036854775808
+	n2 = []uint64{1, 0x8000000000000000}
+	// Sub them together producing carry.
+	d1, carry = bits.Sub64(n1[1], n2[1], 0)
+	d0, _ = bits.Sub64(n1[0], n2[0], carry)
+	nsum = []uint64{d0, d1}
+	fmt.Printf("%v - %v = %v (carry bit was %v)\n", n1, n2, nsum, carry)
+	// Output:
+	// [33 23] - [21 12] = [12 11] (carry bit was 0)
+	// [3 9223372036854775807] - [1 9223372036854775808] = [1 18446744073709551615] (carry bit was 1)
+}
+
+func ExampleMul32() {
+	// First number is 0<<32 + 12
+	n1 := []uint32{0, 12}
+	// Second number is 0<<32 + 12
+	n2 := []uint32{0, 12}
+	// Multiply them together without producing overflow.
+	hi, lo := bits.Mul32(n1[1], n2[1])
+	nsum := []uint32{hi, lo}
+	fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)
+
+	// First number is 0<<32 + 2147483648
+	n1 = []uint32{0, 0x80000000}
+	// Second number is 0<<32 + 2
+	n2 = []uint32{0, 2}
+	// Multiply them together producing overflow.
+	hi, lo = bits.Mul32(n1[1], n2[1])
+	nsum = []uint32{hi, lo}
+	fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)
+	// Output:
+	// 12 * 12 = [0 144]
+	// 2147483648 * 2 = [1 0]
+}
+
+func ExampleMul64() {
+	// First number is 0<<64 + 12
+	n1 := []uint64{0, 12}
+	// Second number is 0<<64 + 12
+	n2 := []uint64{0, 12}
+	// Multiply them together without producing overflow.
+	hi, lo := bits.Mul64(n1[1], n2[1])
+	nsum := []uint64{hi, lo}
+	fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)
+
+	// First number is 0<<64 + 9223372036854775808
+	n1 = []uint64{0, 0x8000000000000000}
+	// Second number is 0<<64 + 2
+	n2 = []uint64{0, 2}
+	// Multiply them together producing overflow.
+	hi, lo = bits.Mul64(n1[1], n2[1])
+	nsum = []uint64{hi, lo}
+	fmt.Printf("%v * %v = %v\n", n1[1], n2[1], nsum)
+	// Output:
+	// 12 * 12 = [0 144]
+	// 9223372036854775808 * 2 = [1 0]
+}
+
+func ExampleDiv32() {
+	// First number is 0<<32 + 6
+	n1 := []uint32{0, 6}
+	// Second number is 0<<32 + 3
+	n2 := []uint32{0, 3}
+	// Divide them together.
+	quo, rem := bits.Div32(n1[0], n1[1], n2[1])
+	nsum := []uint32{quo, rem}
+	fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)
+
+	// First number is 2<<32 + 2147483648
+	n1 = []uint32{2, 0x80000000}
+	// Second number is 0<<32 + 2147483648
+	n2 = []uint32{0, 0x80000000}
+	// Divide them together.
+	quo, rem = bits.Div32(n1[0], n1[1], n2[1])
+	nsum = []uint32{quo, rem}
+	fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)
+	// Output:
+	// [0 6] / 3 = [2 0]
+	// [2 2147483648] / 2147483648 = [5 0]
+}
+
+func ExampleDiv64() {
+	// First number is 0<<64 + 6
+	n1 := []uint64{0, 6}
+	// Second number is 0<<64 + 3
+	n2 := []uint64{0, 3}
+	// Divide them together.
+	quo, rem := bits.Div64(n1[0], n1[1], n2[1])
+	nsum := []uint64{quo, rem}
+	fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)
+
+	// First number is 2<<64 + 9223372036854775808
+	n1 = []uint64{2, 0x8000000000000000}
+	// Second number is 0<<64 + 9223372036854775808
+	n2 = []uint64{0, 0x8000000000000000}
+	// Divide them together.
+	quo, rem = bits.Div64(n1[0], n1[1], n2[1])
+	nsum = []uint64{quo, rem}
+	fmt.Printf("[%v %v] / %v = %v\n", n1[0], n1[1], n2[1], nsum)
+	// Output:
+	// [0 6] / 3 = [2 0]
+	// [2 9223372036854775808] / 9223372036854775808 = [5 0]
+}

From 7bed3c7975780cad3c0adcf548d8b2d324a09265 Mon Sep 17 00:00:00 2001
From: Mikhail Faraponov 
Date: Thu, 11 Nov 2021 21:45:45 +0000
Subject: [PATCH 117/752] net: use Done rather than comparing with
 context.Background

Fixes #49023

Change-Id: I3de70f8a25f4ba8a0fb8bb96581371e33fde2f7a
GitHub-Last-Rev: b7ec9405adc77ec513df344f2ad33801feb2d3ca
GitHub-Pull-Request: golang/go#49024
Reviewed-on: https://go-review.googlesource.com/c/go/+/356471
Reviewed-by: Ian Lance Taylor 
Trust: Damien Neil 
---
 src/net/fd_unix.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/net/fd_unix.go b/src/net/fd_unix.go
index 1bb029d370..4ded833bbf 100644
--- a/src/net/fd_unix.go
+++ b/src/net/fd_unix.go
@@ -91,12 +91,11 @@ func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa sysc
 	}
 
 	// Start the "interrupter" goroutine, if this context might be canceled.
-	// (The background context cannot)
 	//
 	// The interrupter goroutine waits for the context to be done and
 	// interrupts the dial (by altering the fd's write deadline, which
 	// wakes up waitWrite).
-	if ctx != context.Background() {
+	if ctxDone := ctx.Done(); ctxDone != nil {
 		// Wait for the interrupter goroutine to exit before returning
 		// from connect.
 		done := make(chan struct{})
@@ -116,7 +115,7 @@ func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa sysc
 		}()
 		go func() {
 			select {
-			case <-ctx.Done():
+			case <-ctxDone:
 				// Force the runtime's poller to immediately give up
 				// waiting for writability, unblocking waitWrite
 				// below.

From e9f0381a807d1797e0b5969a29f4a3666a73c9e3 Mon Sep 17 00:00:00 2001
From: Cherry Mui 
Date: Thu, 11 Nov 2021 16:51:08 -0500
Subject: [PATCH 118/752] cmd/link: don't unmap output file at error exit

When the link exits on error it currently calls Out.Close, which
will munmap the output buffer and close the file. This may be
called in concurrent phase where other goroutines may be writing
to the output buffer. The munmap can race with the write, causing
it to write to unmapped memory and crash. This CL changes it to
just close the file without unmapping. We're exiting on error
anyway so no need to unmap.

Fixes #47816.

Change-Id: I0e89aca991bdada3d017b7d5c8efc29e46308c03
Reviewed-on: https://go-review.googlesource.com/c/go/+/363357
Trust: Cherry Mui 
Run-TryBot: Cherry Mui 
TryBot-Result: Go Bot 
Reviewed-by: Than McIntosh 
---
 src/cmd/link/internal/ld/lib.go    |  1 -
 src/cmd/link/internal/ld/outbuf.go | 14 ++++++++++++++
 src/cmd/link/internal/ld/sym.go    |  2 +-
 3 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 91665b2ebb..9e13db7b71 100644
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -1103,7 +1103,6 @@ func hostlinksetup(ctxt *Link) {
 		*flagTmpdir = dir
 		ownTmpDir = true
 		AtExit(func() {
-			ctxt.Out.Close()
 			os.RemoveAll(*flagTmpdir)
 		})
 	}
diff --git a/src/cmd/link/internal/ld/outbuf.go b/src/cmd/link/internal/ld/outbuf.go
index 9d5e8854fe..1d21dce9c5 100644
--- a/src/cmd/link/internal/ld/outbuf.go
+++ b/src/cmd/link/internal/ld/outbuf.go
@@ -131,6 +131,20 @@ func (out *OutBuf) Close() error {
 	return nil
 }
 
+// ErrorClose closes the output file (if any).
+// It is supposed to be called only at exit on error, so it doesn't do
+// any clean up or buffer flushing, just closes the file.
+func (out *OutBuf) ErrorClose() {
+	if out.isView {
+		panic(viewCloseError)
+	}
+	if out.f == nil {
+		return
+	}
+	out.f.Close() // best effort, ignore error
+	out.f = nil
+}
+
 // isMmapped returns true if the OutBuf is mmaped.
 func (out *OutBuf) isMmapped() bool {
 	return len(out.buf) != 0
diff --git a/src/cmd/link/internal/ld/sym.go b/src/cmd/link/internal/ld/sym.go
index 72639962e2..d51a59ef46 100644
--- a/src/cmd/link/internal/ld/sym.go
+++ b/src/cmd/link/internal/ld/sym.go
@@ -60,7 +60,7 @@ func linknew(arch *sys.Arch) *Link {
 
 	AtExit(func() {
 		if nerrors > 0 {
-			ctxt.Out.Close()
+			ctxt.Out.ErrorClose()
 			mayberemoveoutfile()
 		}
 	})

From 23adc139bf1c0c099dd075da076f5a1f3ac700d4 Mon Sep 17 00:00:00 2001
From: Cherry Mui 
Date: Thu, 11 Nov 2021 19:58:23 -0500
Subject: [PATCH 119/752] reflect: keep pointer in aggregate-typed args live in
 Call

When register ABI is used, reflect.Value.Call prepares the call
arguments in a memory representation of the argument registers.
It has special handling to keep the pointers in arguments live.
Currently, this handles pointer-typed arguments. But when an
argument is an aggregate-type that contains pointers and passed
in registers, it currently doesn't keep the pointers live. Do
so in this CL.

May fix #49363.

Change-Id: Ic6a0c5fdf9375ef02f7c03fbe9345e2e98c9353d
Reviewed-on: https://go-review.googlesource.com/c/go/+/363358
Trust: Cherry Mui 
Run-TryBot: Cherry Mui 
TryBot-Result: Go Bot 
Reviewed-by: Michael Knyszek 
---
 src/internal/abi/abi.go | 18 ++++++++++++++++++
 src/reflect/all_test.go | 23 +++++++++++++++++++++++
 src/reflect/value.go    | 19 ++++++++++++++++---
 3 files changed, 57 insertions(+), 3 deletions(-)

diff --git a/src/internal/abi/abi.go b/src/internal/abi/abi.go
index 46dc593bd7..b266a7ff78 100644
--- a/src/internal/abi/abi.go
+++ b/src/internal/abi/abi.go
@@ -44,6 +44,24 @@ type RegArgs struct {
 	ReturnIsPtr IntArgRegBitmap
 }
 
+func (r *RegArgs) Dump() {
+	print("Ints:")
+	for _, x := range r.Ints {
+		print(" ", x)
+	}
+	println()
+	print("Floats:")
+	for _, x := range r.Floats {
+		print(" ", x)
+	}
+	println()
+	print("Ptrs:")
+	for _, x := range r.Ptrs {
+		print(" ", x)
+	}
+	println()
+}
+
 // IntRegArgAddr returns a pointer inside of r.Ints[reg] that is appropriately
 // offset for an argument of size argSize.
 //
diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go
index acc09962a0..8c51d8ec26 100644
--- a/src/reflect/all_test.go
+++ b/src/reflect/all_test.go
@@ -6478,6 +6478,29 @@ func TestCallMethodJump(t *testing.T) {
 	*CallGC = false
 }
 
+func TestCallArgLive(t *testing.T) {
+	type T struct{ X, Y *string } // pointerful aggregate
+
+	F := func(t T) { *t.X = "ok" }
+
+	// In reflect.Value.Call, trigger a garbage collection in reflect.call
+	// between marshaling argument and the actual call.
+	*CallGC = true
+
+	x := new(string)
+	runtime.SetFinalizer(x, func(p *string) {
+		if *p != "ok" {
+			t.Errorf("x dead prematurely")
+		}
+	})
+	v := T{x, nil}
+
+	ValueOf(F).Call([]Value{ValueOf(v)})
+
+	// Stop garbage collecting during reflect.call.
+	*CallGC = false
+}
+
 func TestMakeFuncStackCopy(t *testing.T) {
 	target := func(in []Value) []Value {
 		runtime.GC()
diff --git a/src/reflect/value.go b/src/reflect/value.go
index ecf9dd7bc8..02354f2736 100644
--- a/src/reflect/value.go
+++ b/src/reflect/value.go
@@ -352,7 +352,7 @@ func (v Value) CallSlice(in []Value) []Value {
 	return v.call("CallSlice", in)
 }
 
-var callGC bool // for testing; see TestCallMethodJump
+var callGC bool // for testing; see TestCallMethodJump and TestCallArgLive
 
 const debugReflectCall = false
 
@@ -509,12 +509,16 @@ func (v Value) call(op string, in []Value) []Value {
 				// Copy values to "integer registers."
 				if v.flag&flagIndir != 0 {
 					offset := add(v.ptr, st.offset, "precomputed value offset")
-					intToReg(®Args, st.ireg, st.size, offset)
-				} 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] = *(*unsafe.Pointer)(offset)
+					}
+					intToReg(®Args, st.ireg, st.size, offset)
+				} else {
+					if st.kind == abiStepPointer {
+						// See the comment in abiStepPointer case above.
 						regArgs.Ptrs[st.ireg] = v.ptr
 					}
 					regArgs.Ints[st.ireg] = uintptr(v.ptr)
@@ -539,6 +543,15 @@ func (v Value) call(op string, in []Value) []Value {
 	// Mark pointers in registers for the return path.
 	regArgs.ReturnIsPtr = abi.outRegPtrs
 
+	if debugReflectCall {
+		regArgs.Dump()
+	}
+
+	// For testing; see TestCallArgLive.
+	if callGC {
+		runtime.GC()
+	}
+
 	// Call.
 	call(frametype, fn, stackArgs, uint32(frametype.size), uint32(abi.retOffset), uint32(frameSize), ®Args)
 

From 95d06576702c54139796f3e24e2eec4b135b1a09 Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek 
Date: Fri, 12 Nov 2021 05:04:32 +0000
Subject: [PATCH 120/752] test/recover4.go: use mprotect to create a hole
 instead of munmap

Currently the recover4 test, which recovers from a panic created from a
fault, generates a fault by creating a hole in a mapping. It does this
via munmap. However, it's possible the runtime can create a new mapping
that ends up in that hole, for example if the GC executes, causing the
test to fail.

In fact, this is the case now with a smaller minimum heap size.

Modify the test to use mprotect, and clean up the code a little while
we're here: define everything in terms of the length of original
mapping, deduplicate some constants and expressions, and have the test
recover properly even if recover() returns nil (right now it panics
because it fails to type assert nil as error).

Fixes #49381.

Change-Id: If399eca564466e5e8aeb2dc6f86a246d0fce7b5d
Reviewed-on: https://go-review.googlesource.com/c/go/+/363534
Trust: Michael Knyszek 
Run-TryBot: Michael Knyszek 
TryBot-Result: Go Bot 
Reviewed-by: Cherry Mui 
---
 test/recover4.go | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/test/recover4.go b/test/recover4.go
index 67ed970ecb..7cab15a5a8 100644
--- a/test/recover4.go
+++ b/test/recover4.go
@@ -24,12 +24,13 @@ import (
 	"log"
 	"runtime/debug"
 	"syscall"
-	"unsafe"
 )
 
 func memcopy(dst, src []byte) (n int, err error) {
 	defer func() {
-		err = recover().(error)
+		if r, ok := recover().(error); ok {
+			err = r
+		}
 	}()
 
 	for i := 0; i < len(dst) && i < len(src); i++ {
@@ -52,22 +53,23 @@ func main() {
 		log.Fatalf("mmap: %v", err)
 	}
 
-	other := make([]byte, 16*size)
-
-	// Note: Cannot call syscall.Munmap, because Munmap checks
-	// that you are unmapping a whole region returned by Mmap.
-	// We are trying to unmap just a hole in the middle.
-	if _, _, err := syscall.Syscall(syscall.SYS_MUNMAP, uintptr(unsafe.Pointer(&data[8*size])), uintptr(4*size), 0); err != 0 {
-		log.Fatalf("munmap: %v", err)
+	// Create a hole in the mapping that's PROT_NONE.
+	// Note that we can't use munmap here because the Go runtime
+	// could create a mapping that ends up in this hole otherwise,
+	// invalidating the test.
+	hole := data[len(data)/2 : 3*(len(data)/4)]
+	if err := syscall.Mprotect(hole, syscall.PROT_NONE); err != nil {
+		log.Fatalf("mprotect: %v", err)
 	}
 
 	// Check that memcopy returns the actual amount copied
-	// before the fault (8*size - 5, the offset we skip in the argument).
-	n, err := memcopy(data[5:], other)
+	// before the fault.
+	const offset = 5
+	n, err := memcopy(data[offset:], make([]byte, len(data)))
 	if err == nil {
 		log.Fatal("no error from memcopy across memory hole")
 	}
-	if n != 8*size-5 {
-		log.Fatalf("memcopy returned %d, want %d", n, 8*size-5)
+	if expect := len(data)/2 - offset; n != expect {
+		log.Fatalf("memcopy returned %d, want %d", n, expect)
 	}
 }

From 0c6a6cd4d8c19ca8892085a38477e5ff56b7cc2b Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Tue, 9 Nov 2021 21:39:53 -0500
Subject: [PATCH 121/752] go/types: use Identical to verify type identity in
 the Context map

We don't have guarantees that our type hash is perfect, and in fact
fuzzing found cases where identical types hashed to different values. In
case non-identical types hash to the same value, we should ensure that
we de-duplicate using Identical.

Adjust the type map to keep a slice of distinct type identities, so that
we can guarantee that type identity is preserved by de-duplication.

To allow look-up of instances by their identity, before they are
actually instantiated, add a Context.lookup method that accepts origin
type and type arguments. Replace the multi-function typeForHash method
with an update method that requires its argument be non-nil.

Change-Id: I8fe6fb2955f508db608161b7285b02d0a2fa0e46
Reviewed-on: https://go-review.googlesource.com/c/go/+/362798
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/context.go     | 52 +++++++++++++++++++++++++++++--------
 src/go/types/instantiate.go |  4 +--
 src/go/types/named.go       |  2 +-
 src/go/types/predicates.go  | 17 ++++++++++++
 src/go/types/subst.go       |  2 +-
 src/go/types/typexpr.go     | 16 ++++++------
 6 files changed, 70 insertions(+), 23 deletions(-)

diff --git a/src/go/types/context.go b/src/go/types/context.go
index 7caf631b57..e89babcd70 100644
--- a/src/go/types/context.go
+++ b/src/go/types/context.go
@@ -6,6 +6,7 @@ package types
 
 import (
 	"bytes"
+	"fmt"
 	"strings"
 	"sync"
 )
@@ -17,15 +18,15 @@ import (
 // It is safe for concurrent use.
 type Context struct {
 	mu      sync.Mutex
-	typeMap map[string]*Named // type hash -> instance
-	nextID  int               // next unique ID
-	seen    map[*Named]int    // assigned unique IDs
+	typeMap map[string][]*Named // type hash -> instances
+	nextID  int                 // next unique ID
+	seen    map[*Named]int      // assigned unique IDs
 }
 
 // NewContext creates a new Context.
 func NewContext() *Context {
 	return &Context{
-		typeMap: make(map[string]*Named),
+		typeMap: make(map[string][]*Named),
 		seen:    make(map[*Named]int),
 	}
 }
@@ -57,17 +58,46 @@ func (ctxt *Context) typeHash(typ Type, targs []Type) string {
 	return strings.Replace(buf.String(), " ", "#", -1) // ReplaceAll is not available in Go1.4
 }
 
-// typeForHash returns the recorded type for the type hash h, if it exists.
-// If no type exists for h and n is non-nil, n is recorded for h.
-func (ctxt *Context) typeForHash(h string, n *Named) *Named {
+// lookup returns an existing instantiation of orig with targs, if it exists.
+// Otherwise, it returns nil.
+func (ctxt *Context) lookup(h string, orig *Named, targs []Type) *Named {
 	ctxt.mu.Lock()
 	defer ctxt.mu.Unlock()
-	if existing := ctxt.typeMap[h]; existing != nil {
-		return existing
+
+	for _, e := range ctxt.typeMap[h] {
+		if identicalInstance(orig, targs, e.orig, e.TypeArgs().list()) {
+			return e
+		}
+		if debug {
+			// Panic during development to surface any imperfections in our hash.
+			panic(fmt.Sprintf("non-identical instances: (orig: %s, targs: %v) and %s", orig, targs, e))
+		}
 	}
-	if n != nil {
-		ctxt.typeMap[h] = n
+
+	return nil
+}
+
+// update de-duplicates n against previously seen types with the hash h.  If an
+// identical type is found with the type hash h, the previously seen type is
+// returned. Otherwise, n is returned, and recorded in the Context for the hash
+// h.
+func (ctxt *Context) update(h string, n *Named) *Named {
+	assert(n != nil)
+
+	ctxt.mu.Lock()
+	defer ctxt.mu.Unlock()
+
+	for _, e := range ctxt.typeMap[h] {
+		if n == nil || Identical(n, e) {
+			return e
+		}
+		if debug {
+			// Panic during development to surface any imperfections in our hash.
+			panic(fmt.Sprintf("%s and %s are not identical", n, e))
+		}
 	}
+
+	ctxt.typeMap[h] = append(ctxt.typeMap[h], n)
 	return n
 }
 
diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index 8d8d281842..1077ad8160 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -60,7 +60,7 @@ func (check *Checker) instance(pos token.Pos, typ Type, targs []Type, ctxt *Cont
 			h = ctxt.typeHash(t, targs)
 			// typ may already have been instantiated with identical type arguments. In
 			// that case, re-use the existing instance.
-			if named := ctxt.typeForHash(h, nil); named != nil {
+			if named := ctxt.lookup(h, t, targs); named != nil {
 				return named
 			}
 		}
@@ -73,7 +73,7 @@ func (check *Checker) instance(pos token.Pos, typ Type, targs []Type, ctxt *Cont
 		if ctxt != nil {
 			// It's possible that we've lost a race to add named to the context.
 			// In this case, use whichever instance is recorded in the context.
-			named = ctxt.typeForHash(h, named)
+			named = ctxt.update(h, named)
 		}
 		return named
 
diff --git a/src/go/types/named.go b/src/go/types/named.go
index 393d40b127..12d87af084 100644
--- a/src/go/types/named.go
+++ b/src/go/types/named.go
@@ -255,7 +255,7 @@ func expandNamed(ctxt *Context, n *Named, instPos token.Pos) (tparams *TypeParam
 		ctxt = check.bestContext(ctxt)
 		h := ctxt.typeHash(n.orig, n.targs.list())
 		// ensure that an instance is recorded for h to avoid infinite recursion.
-		ctxt.typeForHash(h, n)
+		ctxt.update(h, n)
 
 		smap := makeSubstMap(n.orig.tparams.list(), n.targs.list())
 		underlying = n.check.subst(instPos, n.orig.underlying, smap, ctxt)
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index e8689a12cc..e7f9d3b1db 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -375,6 +375,23 @@ func identical(x, y Type, cmpTags bool, p *ifacePair) bool {
 	return false
 }
 
+// identicalInstance reports if two type instantiations are identical.
+// Instantiations are identical if their origin and type arguments are
+// identical.
+func identicalInstance(xorig Type, xargs []Type, yorig Type, yargs []Type) bool {
+	if len(xargs) != len(yargs) {
+		return false
+	}
+
+	for i, xa := range xargs {
+		if !Identical(xa, yargs[i]) {
+			return false
+		}
+	}
+
+	return Identical(xorig, yorig)
+}
+
 func identicalTParams(x, y []*TypeParam, cmpTags bool, p *ifacePair) bool {
 	if len(x) != len(y) {
 		return false
diff --git a/src/go/types/subst.go b/src/go/types/subst.go
index a05195150f..0e3eafdaf1 100644
--- a/src/go/types/subst.go
+++ b/src/go/types/subst.go
@@ -209,7 +209,7 @@ func (subst *subster) typ(typ Type) Type {
 		// before creating a new named type, check if we have this one already
 		h := subst.ctxt.typeHash(t.orig, newTArgs)
 		dump(">>> new type hash: %s", h)
-		if named := subst.ctxt.typeForHash(h, nil); named != nil {
+		if named := subst.ctxt.lookup(h, t.orig, newTArgs); named != nil {
 			dump(">>> found %s", named)
 			return named
 		}
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 12e0f968c2..17d07649ef 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -390,8 +390,8 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 		return gtyp // error already reported
 	}
 
-	origin, _ := gtyp.(*Named)
-	if origin == nil {
+	orig, _ := gtyp.(*Named)
+	if orig == nil {
 		panic(fmt.Sprintf("%v: cannot instantiate %v", x.Pos(), gtyp))
 	}
 
@@ -409,23 +409,23 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 	}
 
 	// create the instance
-	h := check.conf.Context.typeHash(origin, targs)
+	h := check.conf.Context.typeHash(orig, targs)
 	// targs may be incomplete, and require inference. In any case we should de-duplicate.
-	inst := check.conf.Context.typeForHash(h, nil)
+	inst := check.conf.Context.lookup(h, orig, targs)
 	// If inst is non-nil, we can't just return here. Inst may have been
 	// constructed via recursive substitution, in which case we wouldn't do the
 	// validation below. Ensure that the validation (and resulting errors) runs
 	// for each instantiated type in the source.
 	if inst == nil {
-		tname := NewTypeName(x.Pos(), origin.obj.pkg, origin.obj.name, nil)
-		inst = check.newNamed(tname, origin, nil, nil, nil) // underlying, methods and tparams are set when named is resolved
+		tname := NewTypeName(x.Pos(), orig.obj.pkg, orig.obj.name, nil)
+		inst = check.newNamed(tname, orig, nil, nil, nil) // underlying, methods and tparams are set when named is resolved
 		inst.targs = NewTypeList(targs)
-		inst = check.conf.Context.typeForHash(h, inst)
+		inst = check.conf.Context.update(h, inst)
 	}
 	def.setUnderlying(inst)
 
 	inst.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) {
-		tparams := origin.TypeParams().list()
+		tparams := orig.TypeParams().list()
 
 		inferred := targs
 		if len(targs) < len(tparams) {

From 2dbf37045c24c8ab6f93083adc8be9ccdb3e3603 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Tue, 9 Nov 2021 22:20:18 -0500
Subject: [PATCH 122/752] go/types: refactor the Context type map to accept
 arbitrary types

In preparation for storing *Signature types in Context, refactor the
type map to not depend on the *Named type API.

Change-Id: I0439d43aa4cc3a60a78f409a773a343a4fffd0fa
Reviewed-on: https://go-review.googlesource.com/c/go/+/362799
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/context.go     | 41 +++++++++++++++++++++++--------------
 src/go/types/instantiate.go | 24 +++++++++++-----------
 src/go/types/named.go       |  2 +-
 src/go/types/typexpr.go     |  4 ++--
 4 files changed, 41 insertions(+), 30 deletions(-)

diff --git a/src/go/types/context.go b/src/go/types/context.go
index e89babcd70..0c2b0958c1 100644
--- a/src/go/types/context.go
+++ b/src/go/types/context.go
@@ -18,15 +18,21 @@ import (
 // It is safe for concurrent use.
 type Context struct {
 	mu      sync.Mutex
-	typeMap map[string][]*Named // type hash -> instances
-	nextID  int                 // next unique ID
-	seen    map[*Named]int      // assigned unique IDs
+	typeMap map[string][]ctxtEntry // type hash -> instances entries
+	nextID  int                    // next unique ID
+	seen    map[*Named]int         // assigned unique IDs
+}
+
+type ctxtEntry struct {
+	orig     Type
+	targs    []Type
+	instance Type // = orig[targs]
 }
 
 // NewContext creates a new Context.
 func NewContext() *Context {
 	return &Context{
-		typeMap: make(map[string][]*Named),
+		typeMap: make(map[string][]ctxtEntry),
 		seen:    make(map[*Named]int),
 	}
 }
@@ -60,17 +66,17 @@ func (ctxt *Context) typeHash(typ Type, targs []Type) string {
 
 // lookup returns an existing instantiation of orig with targs, if it exists.
 // Otherwise, it returns nil.
-func (ctxt *Context) lookup(h string, orig *Named, targs []Type) *Named {
+func (ctxt *Context) lookup(h string, orig *Named, targs []Type) Type {
 	ctxt.mu.Lock()
 	defer ctxt.mu.Unlock()
 
 	for _, e := range ctxt.typeMap[h] {
-		if identicalInstance(orig, targs, e.orig, e.TypeArgs().list()) {
-			return e
+		if identicalInstance(orig, targs, e.orig, e.targs) {
+			return e.instance
 		}
 		if debug {
 			// Panic during development to surface any imperfections in our hash.
-			panic(fmt.Sprintf("non-identical instances: (orig: %s, targs: %v) and %s", orig, targs, e))
+			panic(fmt.Sprintf("non-identical instances: (orig: %s, targs: %v) and %s", orig, targs, e.instance))
 		}
 	}
 
@@ -81,24 +87,29 @@ func (ctxt *Context) lookup(h string, orig *Named, targs []Type) *Named {
 // identical type is found with the type hash h, the previously seen type is
 // returned. Otherwise, n is returned, and recorded in the Context for the hash
 // h.
-func (ctxt *Context) update(h string, n *Named) *Named {
-	assert(n != nil)
+func (ctxt *Context) update(h string, orig Type, targs []Type, inst Type) Type {
+	assert(inst != nil)
 
 	ctxt.mu.Lock()
 	defer ctxt.mu.Unlock()
 
 	for _, e := range ctxt.typeMap[h] {
-		if n == nil || Identical(n, e) {
-			return e
+		if inst == nil || Identical(inst, e.instance) {
+			return e.instance
 		}
 		if debug {
 			// Panic during development to surface any imperfections in our hash.
-			panic(fmt.Sprintf("%s and %s are not identical", n, e))
+			panic(fmt.Sprintf("%s and %s are not identical", inst, e.instance))
 		}
 	}
 
-	ctxt.typeMap[h] = append(ctxt.typeMap[h], n)
-	return n
+	ctxt.typeMap[h] = append(ctxt.typeMap[h], ctxtEntry{
+		orig:     orig,
+		targs:    targs,
+		instance: inst,
+	})
+
+	return inst
 }
 
 // idForType returns a unique ID for the pointer n.
diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index 1077ad8160..814d457de3 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -52,20 +52,20 @@ func Instantiate(ctxt *Context, typ Type, targs []Type, validate bool) (Type, er
 // instance creates a type or function instance using the given original type
 // typ and arguments targs. For Named types the resulting instance will be
 // unexpanded.
-func (check *Checker) instance(pos token.Pos, typ Type, targs []Type, ctxt *Context) Type {
-	switch t := typ.(type) {
+func (check *Checker) instance(pos token.Pos, orig Type, targs []Type, ctxt *Context) Type {
+	switch orig := orig.(type) {
 	case *Named:
 		var h string
 		if ctxt != nil {
-			h = ctxt.typeHash(t, targs)
+			h = ctxt.typeHash(orig, targs)
 			// typ may already have been instantiated with identical type arguments. In
 			// that case, re-use the existing instance.
-			if named := ctxt.lookup(h, t, targs); named != nil {
+			if named := ctxt.lookup(h, orig, targs); named != nil {
 				return named
 			}
 		}
-		tname := NewTypeName(pos, t.obj.pkg, t.obj.name, nil)
-		named := check.newNamed(tname, t, nil, nil, nil) // underlying, tparams, and methods are set when named is resolved
+		tname := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil)
+		named := check.newNamed(tname, orig, nil, nil, nil) // underlying, tparams, and methods are set when named is resolved
 		named.targs = NewTypeList(targs)
 		named.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) {
 			return expandNamed(ctxt, n, pos)
@@ -73,23 +73,23 @@ func (check *Checker) instance(pos token.Pos, typ Type, targs []Type, ctxt *Cont
 		if ctxt != nil {
 			// It's possible that we've lost a race to add named to the context.
 			// In this case, use whichever instance is recorded in the context.
-			named = ctxt.update(h, named)
+			named = ctxt.update(h, orig, targs, named).(*Named)
 		}
 		return named
 
 	case *Signature:
-		tparams := t.TypeParams()
+		tparams := orig.TypeParams()
 		if !check.validateTArgLen(pos, tparams.Len(), len(targs)) {
 			return Typ[Invalid]
 		}
 		if tparams.Len() == 0 {
-			return typ // nothing to do (minor optimization)
+			return orig // nothing to do (minor optimization)
 		}
-		sig := check.subst(pos, typ, makeSubstMap(tparams.list(), targs), ctxt).(*Signature)
+		sig := check.subst(pos, orig, makeSubstMap(tparams.list(), targs), ctxt).(*Signature)
 		// If the signature doesn't use its type parameters, subst
 		// will not make a copy. In that case, make a copy now (so
 		// we can set tparams to nil w/o causing side-effects).
-		if sig == t {
+		if sig == orig {
 			copy := *sig
 			sig = ©
 		}
@@ -99,7 +99,7 @@ func (check *Checker) instance(pos token.Pos, typ Type, targs []Type, ctxt *Cont
 		return sig
 	}
 	// only types and functions can be generic
-	panic(fmt.Sprintf("%v: cannot instantiate %v", pos, typ))
+	panic(fmt.Sprintf("%v: cannot instantiate %v", pos, orig))
 }
 
 // validateTArgLen verifies that the length of targs and tparams matches,
diff --git a/src/go/types/named.go b/src/go/types/named.go
index 12d87af084..ed3c426a12 100644
--- a/src/go/types/named.go
+++ b/src/go/types/named.go
@@ -255,7 +255,7 @@ func expandNamed(ctxt *Context, n *Named, instPos token.Pos) (tparams *TypeParam
 		ctxt = check.bestContext(ctxt)
 		h := ctxt.typeHash(n.orig, n.targs.list())
 		// ensure that an instance is recorded for h to avoid infinite recursion.
-		ctxt.update(h, n)
+		ctxt.update(h, n.orig, n.TypeArgs().list(), n)
 
 		smap := makeSubstMap(n.orig.tparams.list(), n.targs.list())
 		underlying = n.check.subst(instPos, n.orig.underlying, smap, ctxt)
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 17d07649ef..048bc95e15 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -411,7 +411,7 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 	// create the instance
 	h := check.conf.Context.typeHash(orig, targs)
 	// targs may be incomplete, and require inference. In any case we should de-duplicate.
-	inst := check.conf.Context.lookup(h, orig, targs)
+	inst, _ := check.conf.Context.lookup(h, orig, targs).(*Named)
 	// If inst is non-nil, we can't just return here. Inst may have been
 	// constructed via recursive substitution, in which case we wouldn't do the
 	// validation below. Ensure that the validation (and resulting errors) runs
@@ -420,7 +420,7 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 		tname := NewTypeName(x.Pos(), orig.obj.pkg, orig.obj.name, nil)
 		inst = check.newNamed(tname, orig, nil, nil, nil) // underlying, methods and tparams are set when named is resolved
 		inst.targs = NewTypeList(targs)
-		inst = check.conf.Context.update(h, inst)
+		inst = check.conf.Context.update(h, orig, targs, inst).(*Named)
 	}
 	def.setUnderlying(inst)
 

From ede97290edd6ca9291d44f8eba503fbd8b162ed4 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Tue, 9 Nov 2021 22:28:18 -0500
Subject: [PATCH 123/752] go/types: re-use type hashing logic in
 Context.typeHash

The special handling for *Named types is not necessary. The hash of an
instance is simply the hash of its type followed by its type argument
list.

Change-Id: I7aa58e73b81731c3cad3a2fd14124f63cfb685a7
Reviewed-on: https://go-review.googlesource.com/c/go/+/362800
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/context.go     | 26 ++++++++++----------------
 src/go/types/instantiate.go |  4 ++--
 2 files changed, 12 insertions(+), 18 deletions(-)

diff --git a/src/go/types/context.go b/src/go/types/context.go
index 0c2b0958c1..1f102f0b8b 100644
--- a/src/go/types/context.go
+++ b/src/go/types/context.go
@@ -37,28 +37,22 @@ func NewContext() *Context {
 	}
 }
 
-// typeHash returns a string representation of typ, which can be used as an exact
-// type hash: types that are identical produce identical string representations.
-// If typ is a *Named type and targs is not empty, typ is printed as if it were
-// instantiated with targs. The result is guaranteed to not contain blanks (" ").
+// typeHash returns a string representation of typ instantiated with targs,
+// which can be used as an exact type hash: types that are identical produce
+// identical string representations. If targs is not empty, typ is printed as
+// if it were instantiated with targs. The result is guaranteed to not contain
+// blanks (" ").
 func (ctxt *Context) typeHash(typ Type, targs []Type) string {
 	assert(ctxt != nil)
 	assert(typ != nil)
 	var buf bytes.Buffer
 
 	h := newTypeHasher(&buf, ctxt)
-	// Caution: don't use asNamed here. TypeHash may be called for unexpanded
-	// types. We don't need anything other than name and type arguments below,
-	// which do not require expansion.
-	if named, _ := typ.(*Named); named != nil && len(targs) > 0 {
-		// Don't use WriteType because we need to use the provided targs
-		// and not any targs that might already be with the *Named type.
-		h.typePrefix(named)
-		h.typeName(named.obj)
+	h.typ(typ)
+	if len(targs) > 0 {
+		// TODO(rfindley): consider asserting on isGeneric(typ) here, if and when
+		// isGeneric handles *Signature types.
 		h.typeList(targs)
-	} else {
-		assert(targs == nil)
-		h.typ(typ)
 	}
 
 	return strings.Replace(buf.String(), " ", "#", -1) // ReplaceAll is not available in Go1.4
@@ -66,7 +60,7 @@ func (ctxt *Context) typeHash(typ Type, targs []Type) string {
 
 // lookup returns an existing instantiation of orig with targs, if it exists.
 // Otherwise, it returns nil.
-func (ctxt *Context) lookup(h string, orig *Named, targs []Type) Type {
+func (ctxt *Context) lookup(h string, orig Type, targs []Type) Type {
 	ctxt.mu.Lock()
 	defer ctxt.mu.Unlock()
 
diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index 814d457de3..62d9e18401 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -60,8 +60,8 @@ func (check *Checker) instance(pos token.Pos, orig Type, targs []Type, ctxt *Con
 			h = ctxt.typeHash(orig, targs)
 			// typ may already have been instantiated with identical type arguments. In
 			// that case, re-use the existing instance.
-			if named := ctxt.lookup(h, orig, targs); named != nil {
-				return named
+			if inst := ctxt.lookup(h, orig, targs); inst != nil {
+				return inst
 			}
 		}
 		tname := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil)

From 8b66b3d49f931715c52b4ed71bc1dc935132c30f Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Thu, 11 Nov 2021 19:07:28 -0500
Subject: [PATCH 124/752] cmd/compile/internal/types2: unexport
 Context.TypeHash

Context.TypeHash is not being used outside of the type checker, so
unexport it.

The TypeHash method is meant to hash instances, not arbitrary types, and
will soon be modified to differentiate origin types by pointer identity
(even if they are *Signature types).

Change-Id: Ia8d4a7c6350ce7f278b70630585efb0009fef63a
Reviewed-on: https://go-review.googlesource.com/c/go/+/363516
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/cmd/compile/internal/types2/context.go     | 4 ++--
 src/cmd/compile/internal/types2/instantiate.go | 2 +-
 src/cmd/compile/internal/types2/named.go       | 2 +-
 src/cmd/compile/internal/types2/subst.go       | 2 +-
 src/cmd/compile/internal/types2/typexpr.go     | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/types2/context.go b/src/cmd/compile/internal/types2/context.go
index f6137eea43..9e9eb5bdf6 100644
--- a/src/cmd/compile/internal/types2/context.go
+++ b/src/cmd/compile/internal/types2/context.go
@@ -29,11 +29,11 @@ func NewContext() *Context {
 	}
 }
 
-// TypeHash returns a string representation of typ, which can be used as an exact
+// typeHash returns a string representation of typ, which can be used as an exact
 // type hash: types that are identical produce identical string representations.
 // If typ is a *Named type and targs is not empty, typ is printed as if it were
 // instantiated with targs. The result is guaranteed to not contain blanks (" ").
-func (ctxt *Context) TypeHash(typ Type, targs []Type) string {
+func (ctxt *Context) typeHash(typ Type, targs []Type) string {
 	assert(ctxt != nil)
 	assert(typ != nil)
 	var buf bytes.Buffer
diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index 44cf593ffb..f814619bb0 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -57,7 +57,7 @@ func (check *Checker) instance(pos syntax.Pos, typ Type, targs []Type, ctxt *Con
 	case *Named:
 		var h string
 		if ctxt != nil {
-			h = ctxt.TypeHash(t, targs)
+			h = ctxt.typeHash(t, targs)
 			// typ may already have been instantiated with identical type arguments. In
 			// that case, re-use the existing instance.
 			if named := ctxt.typeForHash(h, nil); named != nil {
diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go
index 6ebad8fbb5..e73a31d42e 100644
--- a/src/cmd/compile/internal/types2/named.go
+++ b/src/cmd/compile/internal/types2/named.go
@@ -251,7 +251,7 @@ func expandNamed(ctxt *Context, n *Named, instPos syntax.Pos) (tparams *TypePara
 	if n.orig.tparams.Len() == n.targs.Len() {
 		// We must always have a context, to avoid infinite recursion.
 		ctxt = check.bestContext(ctxt)
-		h := ctxt.TypeHash(n.orig, n.targs.list())
+		h := ctxt.typeHash(n.orig, n.targs.list())
 		// ensure that an instance is recorded for h to avoid infinite recursion.
 		ctxt.typeForHash(h, n)
 
diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
index f46e895b12..5deb868a79 100644
--- a/src/cmd/compile/internal/types2/subst.go
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -207,7 +207,7 @@ func (subst *subster) typ(typ Type) Type {
 		}
 
 		// before creating a new named type, check if we have this one already
-		h := subst.ctxt.TypeHash(t.orig, newTArgs)
+		h := subst.ctxt.typeHash(t.orig, newTArgs)
 		dump(">>> new type hash: %s", h)
 		if named := subst.ctxt.typeForHash(h, nil); named != nil {
 			dump(">>> found %s", named)
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index a08e472703..82c029cfd6 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -431,7 +431,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 	}
 
 	// create the instance
-	h := check.conf.Context.TypeHash(origin, targs)
+	h := check.conf.Context.typeHash(origin, targs)
 	// targs may be incomplete, and require inference. In any case we should de-duplicate.
 	inst := check.conf.Context.typeForHash(h, nil)
 	// If inst is non-nil, we can't just return here. Inst may have been

From 5d24203c394e6b64c42a9f69b990d94cb6c8aad4 Mon Sep 17 00:00:00 2001
From: Katie Hockman 
Date: Wed, 10 Nov 2021 16:22:08 -0500
Subject: [PATCH 125/752] internal/fuzz: set timeout for each exec of fuzz
 target

This change sets a timeout of 10 seconds on each
execution of the fuzz target, both during fuzzing
and during minimization. This is not currently
customizable by the user, but issue #48157 tracks
this work.

Deadlocks will be considered non-recoverable errors,
and as such, will not be minimizable.

Fixes #48591

Change-Id: Ic86e8e9e9a0255e7860f7cbf5654e832785d1cbc
Reviewed-on: https://go-review.googlesource.com/c/go/+/363134
Trust: Katie Hockman 
Run-TryBot: Katie Hockman 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
---
 .../go/testdata/script/test_fuzz_minimize.txt |  2 +-
 .../script/test_fuzz_mutate_crash.txt         | 16 ++++++++-
 .../script/test_fuzz_mutator_repeat.txt       |  2 +-
 .../script/test_fuzz_non_crash_signal.txt     |  2 +-
 src/internal/fuzz/minimize_test.go            |  9 +++--
 src/internal/fuzz/worker.go                   | 36 ++++++++++++-------
 src/internal/fuzz/worker_test.go              |  3 +-
 7 files changed, 49 insertions(+), 21 deletions(-)

diff --git a/src/cmd/go/testdata/script/test_fuzz_minimize.txt b/src/cmd/go/testdata/script/test_fuzz_minimize.txt
index 462fb9a963..a6dc3f1953 100644
--- a/src/cmd/go/testdata/script/test_fuzz_minimize.txt
+++ b/src/cmd/go/testdata/script/test_fuzz_minimize.txt
@@ -67,7 +67,7 @@ rm testdata
 ! go test -fuzz=FuzzMinimizerNonrecoverable -run=FuzzMinimizerNonrecoverable -fuzztime=10000x .
 ! stdout '^ok'
 ! stdout 'minimizing'
-stdout -count=1 'fuzzing process terminated unexpectedly: exit status 99'
+stdout -count=1 '^\s+fuzzing process hung or terminated unexpectedly: exit status 99'
 stdout FAIL
 
 # Check that re-running the value causes a crash.
diff --git a/src/cmd/go/testdata/script/test_fuzz_mutate_crash.txt b/src/cmd/go/testdata/script/test_fuzz_mutate_crash.txt
index 4c4fa8e651..99bae1daf0 100644
--- a/src/cmd/go/testdata/script/test_fuzz_mutate_crash.txt
+++ b/src/cmd/go/testdata/script/test_fuzz_mutate_crash.txt
@@ -54,9 +54,14 @@ go run check_testdata.go FuzzWithFatalf
 
 ! go test -run=FuzzWithBadExit -fuzz=FuzzWithBadExit -fuzztime=100x -fuzzminimizetime=1000x
 stdout 'testdata[/\\]fuzz[/\\]FuzzWithBadExit[/\\]'
-stdout 'unexpectedly'
+stdout '^\s+fuzzing process hung or terminated unexpectedly: exit status'
 go run check_testdata.go FuzzWithBadExit
 
+! go test -run=FuzzDeadlock -fuzz=FuzzDeadlock -fuzztime=100x -fuzzminimizetime=0x
+stdout 'testdata[/\\]fuzz[/\\]FuzzDeadlock[/\\]'
+stdout '^\s+fuzzing process hung or terminated unexpectedly: exit status'
+go run check_testdata.go FuzzDeadlock
+
 # Running the fuzzer should find a crashing input quickly for fuzzing two types.
 ! go test -run=FuzzWithTwoTypes -fuzz=FuzzWithTwoTypes -fuzztime=100x -fuzzminimizetime=1000x
 stdout 'testdata[/\\]fuzz[/\\]FuzzWithTwoTypes[/\\]'
@@ -190,6 +195,15 @@ func FuzzWithBadExit(f *testing.F) {
 	})
 }
 
+func FuzzDeadlock(f *testing.F) {
+	f.Add(int(0))
+	f.Fuzz(func(t *testing.T, n int) {
+		if n != 0 {
+			select {}
+		}
+	})
+}
+
 func FuzzWithTwoTypes(f *testing.F) {
 	f.Fuzz(func(t *testing.T, a, b []byte) {
 		if len(a) > 0 && len(b) > 0 {
diff --git a/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt b/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
index 60f5787464..3764dcb915 100644
--- a/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
+++ b/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
@@ -12,7 +12,7 @@
 # The fuzzing engine reconstructs the crashing input and saves it to testdata.
 ! exists want
 ! go test -fuzz=. -parallel=1 -fuzztime=110x -fuzzminimizetime=10x -v
-stdout 'fuzzing process terminated unexpectedly'
+stdout '^\s+fuzzing process hung or terminated unexpectedly: exit status'
 stdout 'Failing input written to testdata'
 
 # Run the fuzz target without fuzzing. The fuzz function is called with the
diff --git a/src/cmd/go/testdata/script/test_fuzz_non_crash_signal.txt b/src/cmd/go/testdata/script/test_fuzz_non_crash_signal.txt
index 31d54bcb70..1051292fcb 100644
--- a/src/cmd/go/testdata/script/test_fuzz_non_crash_signal.txt
+++ b/src/cmd/go/testdata/script/test_fuzz_non_crash_signal.txt
@@ -25,7 +25,7 @@ stdout 'fuzzing process terminated by unexpected signal; no crash will be record
 # We should save a crasher.
 ! go test -fuzz=FuzzCrash
 exists testdata/fuzz/FuzzCrash
-stdout 'fuzzing process terminated unexpectedly'
+stdout '^\s+fuzzing process hung or terminated unexpectedly: exit status'
 
 -- go.mod --
 module test
diff --git a/src/internal/fuzz/minimize_test.go b/src/internal/fuzz/minimize_test.go
index dc153d0de4..04d785ce40 100644
--- a/src/internal/fuzz/minimize_test.go
+++ b/src/internal/fuzz/minimize_test.go
@@ -13,6 +13,7 @@ import (
 	"fmt"
 	"reflect"
 	"testing"
+	"time"
 	"unicode"
 	"unicode/utf8"
 )
@@ -279,7 +280,9 @@ func TestMinimizeInput(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 			ws := &workerServer{
-				fuzzFn: tc.fn,
+				fuzzFn: func(e CorpusEntry) (time.Duration, error) {
+					return time.Second, tc.fn(e)
+				},
 			}
 			count := int64(0)
 			vals := tc.input
@@ -304,8 +307,8 @@ func TestMinimizeInput(t *testing.T) {
 // input and a flaky failure occurs, that minimization was not indicated
 // to be successful, and the error isn't returned (since it's flaky).
 func TestMinimizeFlaky(t *testing.T) {
-	ws := &workerServer{fuzzFn: func(e CorpusEntry) error {
-		return errors.New("ohno")
+	ws := &workerServer{fuzzFn: func(e CorpusEntry) (time.Duration, error) {
+		return time.Second, errors.New("ohno")
 	}}
 	keepCoverage := make([]byte, len(coverageSnapshot))
 	count := int64(0)
diff --git a/src/internal/fuzz/worker.go b/src/internal/fuzz/worker.go
index 02efa7f84a..48a3923112 100644
--- a/src/internal/fuzz/worker.go
+++ b/src/internal/fuzz/worker.go
@@ -142,7 +142,7 @@ func (w *worker) coordinate(ctx context.Context) error {
 			}
 			// Worker exited non-zero or was terminated by a non-interrupt
 			// signal (for example, SIGSEGV) while fuzzing.
-			return fmt.Errorf("fuzzing process terminated unexpectedly: %w", err)
+			return fmt.Errorf("fuzzing process hung or terminated unexpectedly: %w", err)
 			// TODO(jayconrod,katiehockman): if -keepfuzzing, restart worker.
 
 		case input := <-w.coordinator.inputC:
@@ -183,7 +183,7 @@ func (w *worker) coordinate(ctx context.Context) error {
 				// Unexpected termination. Set error message and fall through.
 				// We'll restart the worker on the next iteration.
 				// Don't attempt to minimize this since it crashed the worker.
-				resp.Err = fmt.Sprintf("fuzzing process terminated unexpectedly: %v", w.waitErr)
+				resp.Err = fmt.Sprintf("fuzzing process hung or terminated unexpectedly: %v", w.waitErr)
 				canMinimize = false
 			}
 			result := fuzzResult{
@@ -255,7 +255,7 @@ func (w *worker) minimize(ctx context.Context, input fuzzMinimizeInput) (min fuz
 				limit:        input.limit,
 			}, nil
 		}
-		return fuzzResult{}, fmt.Errorf("fuzzing process terminated unexpectedly while minimizing: %w", w.waitErr)
+		return fuzzResult{}, fmt.Errorf("fuzzing process hung or terminated unexpectedly while minimizing: %w", w.waitErr)
 	}
 
 	if input.crasherMsg != "" && resp.Err == "" {
@@ -471,8 +471,16 @@ func RunFuzzWorker(ctx context.Context, fn func(CorpusEntry) error) error {
 	}
 	srv := &workerServer{
 		workerComm: comm,
-		fuzzFn:     fn,
-		m:          newMutator(),
+		fuzzFn: func(e CorpusEntry) (time.Duration, error) {
+			timer := time.AfterFunc(10*time.Second, func() {
+				panic("deadlocked!") // this error message won't be printed
+			})
+			defer timer.Stop()
+			start := time.Now()
+			err := fn(e)
+			return time.Since(start), err
+		},
+		m: newMutator(),
 	}
 	return srv.serve(ctx)
 }
@@ -604,9 +612,12 @@ type workerServer struct {
 	// coverage is found.
 	coverageMask []byte
 
-	// fuzzFn runs the worker's fuzz function on the given input and returns
-	// an error if it finds a crasher (the process may also exit or crash).
-	fuzzFn func(CorpusEntry) error
+	// fuzzFn runs the worker's fuzz target on the given input and returns an
+	// error if it finds a crasher (the process may also exit or crash), and the
+	// time it took to run the input. It sets a deadline of 10 seconds, at which
+	// point it will panic with the assumption that the process is hanging or
+	// deadlocked.
+	fuzzFn func(CorpusEntry) (time.Duration, error)
 }
 
 // serve reads serialized RPC messages on fuzzIn. When serve receives a message,
@@ -699,9 +710,8 @@ func (ws *workerServer) fuzz(ctx context.Context, args fuzzArgs) (resp fuzzRespo
 	}
 	fuzzOnce := func(entry CorpusEntry) (dur time.Duration, cov []byte, errMsg string) {
 		mem.header().count++
-		start := time.Now()
-		err := ws.fuzzFn(entry)
-		dur = time.Since(start)
+		var err error
+		dur, err = ws.fuzzFn(entry)
 		if err != nil {
 			errMsg = err.Error()
 			if errMsg == "" {
@@ -803,7 +813,7 @@ func (ws *workerServer) minimizeInput(ctx context.Context, vals []interface{}, c
 	// If not, then whatever caused us to think the value was interesting may
 	// have been a flake, and we can't minimize it.
 	*count++
-	retErr = ws.fuzzFn(CorpusEntry{Values: vals})
+	_, retErr = ws.fuzzFn(CorpusEntry{Values: vals})
 	if keepCoverage != nil {
 		if !hasCoverageBit(keepCoverage, coverageSnapshot) || retErr != nil {
 			return false, nil
@@ -870,7 +880,7 @@ func (ws *workerServer) minimizeInput(ctx context.Context, vals []interface{}, c
 			panic("impossible")
 		}
 		*count++
-		err := ws.fuzzFn(CorpusEntry{Values: vals})
+		_, err := ws.fuzzFn(CorpusEntry{Values: vals})
 		if err != nil {
 			retErr = err
 			if keepCoverage != nil {
diff --git a/src/internal/fuzz/worker_test.go b/src/internal/fuzz/worker_test.go
index c6f83fd08d..ed9722f43a 100644
--- a/src/internal/fuzz/worker_test.go
+++ b/src/internal/fuzz/worker_test.go
@@ -14,6 +14,7 @@ import (
 	"os/signal"
 	"reflect"
 	"testing"
+	"time"
 )
 
 var benchmarkWorkerFlag = flag.Bool("benchmarkworker", false, "")
@@ -36,7 +37,7 @@ func BenchmarkWorkerFuzzOverhead(b *testing.B) {
 	os.Setenv("GODEBUG", fmt.Sprintf("%s,fuzzseed=123", origEnv))
 
 	ws := &workerServer{
-		fuzzFn:     func(_ CorpusEntry) error { return nil },
+		fuzzFn:     func(_ CorpusEntry) (time.Duration, error) { return time.Second, nil },
 		workerComm: workerComm{memMu: make(chan *sharedMem, 1)},
 	}
 

From b1b6d928bd4fb368f8ada0a554fc85405e7a3688 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le 
Date: Fri, 12 Nov 2021 13:27:07 +0700
Subject: [PATCH 126/752] cmd/compile: fix missing transformEarlyCall for OXDOT
 in subster.node

Like OFUNCINST, in case of OXDOT call expression, the arguments need
to be transformed earlier, so any needed CONVIFACE nodes are exposed.

Fixes #49538

Change-Id: I275ddf6f53a9cadc8708e805941cdf7bdffabba9
Reviewed-on: https://go-review.googlesource.com/c/go/+/363554
Trust: Cuong Manh Le 
Trust: Dan Scales 
Run-TryBot: Cuong Manh Le 
TryBot-Result: Go Bot 
Reviewed-by: Dan Scales 
---
 src/cmd/compile/internal/noder/stencil.go | 12 ++++++++----
 test/typeparam/issue49538.go              | 23 +++++++++++++++++++++++
 2 files changed, 31 insertions(+), 4 deletions(-)
 create mode 100644 test/typeparam/issue49538.go

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 20197565f5..4f9f8107bc 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -1095,6 +1095,9 @@ func (subst *subster) node(n ir.Node) ir.Node {
 			case ir.OXDOT:
 				// This is the case of a bound call on a typeparam,
 				// which will be handled in the dictPass.
+				// As with OFUNCINST, we must transform the arguments of the call now,
+				// so any needed CONVIFACE nodes are exposed.
+				transformEarlyCall(call)
 
 			case ir.ODOTTYPE, ir.ODOTTYPE2:
 				// These are DOTTYPEs that could get transformed into
@@ -1229,14 +1232,15 @@ func (g *genInst) dictPass(info *instInfo) {
 				transformDot(mse, false)
 			}
 		case ir.OCALL:
-			op := m.(*ir.CallExpr).X.Op()
+			call := m.(*ir.CallExpr)
+			op := call.X.Op()
 			if op == ir.OMETHVALUE {
 				// Redo the transformation of OXDOT, now that we
 				// know the method value is being called.
-				m.(*ir.CallExpr).X.(*ir.SelectorExpr).SetOp(ir.OXDOT)
-				transformDot(m.(*ir.CallExpr).X.(*ir.SelectorExpr), true)
+				call.X.(*ir.SelectorExpr).SetOp(ir.OXDOT)
+				transformDot(call.X.(*ir.SelectorExpr), true)
 			}
-			transformCall(m.(*ir.CallExpr))
+			transformCall(call)
 
 		case ir.OCONVIFACE:
 			if m.Type().IsEmptyInterface() && m.(*ir.ConvExpr).X.Type().IsEmptyInterface() {
diff --git a/test/typeparam/issue49538.go b/test/typeparam/issue49538.go
new file mode 100644
index 0000000000..ac20a5423f
--- /dev/null
+++ b/test/typeparam/issue49538.go
@@ -0,0 +1,23 @@
+// compile -G=3
+
+// 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
+
+type I interface {
+	M(interface{})
+}
+
+type a[T any] struct{}
+
+func (a[T]) M(interface{}) {}
+
+func f[T I](t *T) {
+	(*t).M(t)
+}
+
+func g() {
+	f(&a[int]{})
+}

From ecd2e140ec54feca9afbda7726345e09cd380eea Mon Sep 17 00:00:00 2001
From: Michael Pratt 
Date: Fri, 12 Nov 2021 11:16:43 -0500
Subject: [PATCH 127/752] runtime: drop cgoTraceback call assumptions from
 CgoPprof tests

the CgoPprof tests currently assume that calls to their cgoTraceback
functions are primarily for generating pprof samples and exit early
after receiving two calls.

This is a fragile assumption, as cgoTraceback will be called for _any_
signal received, hence why the test already looks for 2 calls instead of
1.

Still, this has caused flaky failures in two cases:

* #37201, where async preemption signals add additional probability of
receiving non-profiling signals. This was resolved by disabling async
preemption.

* #49401, where some ITIMER_PROF SIGPROF signals are ignored in favor of
per-thread SIGPROF signals.

Rather than attempting to keep plugging holes, this CL drops the fragile
assumption from these tests. Now they simply unconditionally run for the
full 1s before exiting.

Fixes #49401

Change-Id: I16dc9d2f16c2fb511e9db93dd096a402121f86ac
Reviewed-on: https://go-review.googlesource.com/c/go/+/363634
Trust: Michael Pratt 
Run-TryBot: Michael Pratt 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
Reviewed-by: Rhys Hiltner 
---
 src/runtime/crash_cgo_test.go                   |  5 -----
 src/runtime/testdata/testprogcgo/pprof.go       | 11 +----------
 src/runtime/testdata/testprogcgo/threadpprof.go | 14 +-------------
 3 files changed, 2 insertions(+), 28 deletions(-)

diff --git a/src/runtime/crash_cgo_test.go b/src/runtime/crash_cgo_test.go
index 58c340f8ad..9a174fa549 100644
--- a/src/runtime/crash_cgo_test.go
+++ b/src/runtime/crash_cgo_test.go
@@ -302,12 +302,7 @@ func testCgoPprof(t *testing.T, buildArg, runArg, top, bottom string) {
 		t.Fatal(err)
 	}
 
-	// pprofCgoTraceback is called whenever CGO code is executing and a signal
-	// is received. Disable signal preemption to increase the likelihood at
-	// least one SIGPROF signal fired to capture a sample. See issue #37201.
 	cmd := testenv.CleanCmdEnv(exec.Command(exe, runArg))
-	cmd.Env = append(cmd.Env, "GODEBUG=asyncpreemptoff=1")
-
 	got, err := cmd.CombinedOutput()
 	if err != nil {
 		if testenv.Builder() == "linux-amd64-alpine" {
diff --git a/src/runtime/testdata/testprogcgo/pprof.go b/src/runtime/testdata/testprogcgo/pprof.go
index 3b73fa0bdd..8870d0c415 100644
--- a/src/runtime/testdata/testprogcgo/pprof.go
+++ b/src/runtime/testdata/testprogcgo/pprof.go
@@ -29,8 +29,6 @@ void cpuHog() {
 void cpuHog2() {
 }
 
-static int cpuHogCount;
-
 struct cgoTracebackArg {
 	uintptr_t  context;
 	uintptr_t  sigContext;
@@ -47,13 +45,6 @@ void pprofCgoTraceback(void* parg) {
 	arg->buf[0] = (uintptr_t)(cpuHog) + 0x10;
 	arg->buf[1] = (uintptr_t)(cpuHog2) + 0x4;
 	arg->buf[2] = 0;
-	++cpuHogCount;
-}
-
-// getCpuHogCount fetches the number of times we've seen cpuHog in the
-// traceback.
-int getCpuHogCount() {
-	return cpuHogCount;
 }
 */
 import "C"
@@ -86,7 +77,7 @@ func CgoPprof() {
 	}
 
 	t0 := time.Now()
-	for C.getCpuHogCount() < 2 && time.Since(t0) < time.Second {
+	for time.Since(t0) < time.Second {
 		C.cpuHog()
 	}
 
diff --git a/src/runtime/testdata/testprogcgo/threadpprof.go b/src/runtime/testdata/testprogcgo/threadpprof.go
index feb774ba59..4bc84d16d0 100644
--- a/src/runtime/testdata/testprogcgo/threadpprof.go
+++ b/src/runtime/testdata/testprogcgo/threadpprof.go
@@ -33,8 +33,6 @@ void cpuHogThread() {
 void cpuHogThread2() {
 }
 
-static int cpuHogThreadCount;
-
 struct cgoTracebackArg {
 	uintptr_t  context;
 	uintptr_t  sigContext;
@@ -49,13 +47,6 @@ void pprofCgoThreadTraceback(void* parg) {
 	arg->buf[0] = (uintptr_t)(cpuHogThread) + 0x10;
 	arg->buf[1] = (uintptr_t)(cpuHogThread2) + 0x4;
 	arg->buf[2] = 0;
-	__sync_add_and_fetch(&cpuHogThreadCount, 1);
-}
-
-// getCPUHogThreadCount fetches the number of times we've seen cpuHogThread
-// in the traceback.
-int getCPUHogThreadCount() {
-	return __sync_add_and_fetch(&cpuHogThreadCount, 0);
 }
 
 static void* cpuHogDriver(void* arg __attribute__ ((unused))) {
@@ -109,10 +100,7 @@ func pprofThread() {
 
 	C.runCPUHogThread()
 
-	t0 := time.Now()
-	for C.getCPUHogThreadCount() < 2 && time.Since(t0) < time.Second {
-		time.Sleep(100 * time.Millisecond)
-	}
+	time.Sleep(1*time.Second)
 
 	pprof.StopCPUProfile()
 

From 95196512b6163dbeff2e7ce5cea65072305905f2 Mon Sep 17 00:00:00 2001
From: Michael Pratt 
Date: Wed, 10 Nov 2021 17:35:13 -0500
Subject: [PATCH 128/752] runtime/pprof: mark
 TestCPUProfileMultithreadMagnitude as flaky

The Linux kernel starting in 5.9 and fixed in 5.16 has a bug that can
break CPU timer signal delivery on new new threads if the timer
interrupt fires during handling of the clone system call.

Broken CPU timer signal deliver will skew CPU profile results and cause
this test to fail.

There is currently no known workaround, so mark the test as flaky on
builders with known broken kernels.

For #49065

Change-Id: I37ceb9ea244869b0aab5cd9a36b27ca2f7e5d315
Reviewed-on: https://go-review.googlesource.com/c/go/+/363214
Trust: Michael Pratt 
Run-TryBot: Michael Pratt 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
Reviewed-by: Michael Knyszek 
---
 src/runtime/pprof/pprof_test.go       | 24 +++++++++++
 src/runtime/pprof/uname_linux_test.go | 61 +++++++++++++++++++++++++++
 src/runtime/pprof/uname_other_test.go | 15 +++++++
 3 files changed, 100 insertions(+)
 create mode 100644 src/runtime/pprof/uname_linux_test.go
 create mode 100644 src/runtime/pprof/uname_other_test.go

diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index 704c0c516d..d9be00d030 100644
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -116,6 +116,30 @@ func TestCPUProfileMultithreadMagnitude(t *testing.T) {
 		t.Skip("issue 35057 is only confirmed on Linux")
 	}
 
+	// Linux [5.9,5.16) has a kernel bug that can break CPU timers on newly
+	// created threads, breaking our CPU accounting.
+	major, minor, patch, err := linuxKernelVersion()
+	if err != nil {
+		t.Errorf("Error determining kernel version: %v", err)
+	}
+	t.Logf("Running on Linux %d.%d.%d", major, minor, patch)
+	defer func() {
+		if t.Failed() {
+			t.Logf("Failure of this test may indicate that your system suffers from a known Linux kernel bug fixed on newer kernels. See https://golang.org/issue/49065.")
+		}
+	}()
+
+	// Disable on affected builders to avoid flakiness, but otherwise keep
+	// it enabled to potentially warn users that they are on a broken
+	// kernel.
+	if testenv.Builder() != "" && (runtime.GOARCH == "386" || runtime.GOARCH == "amd64") {
+		have59 := major > 5 || (major == 5 && minor >= 9)
+		have516 := major > 5 || (major == 5 && minor >= 16)
+		if have59 && !have516 {
+			testenv.SkipFlaky(t, 49065)
+		}
+	}
+
 	// Run a workload in a single goroutine, then run copies of the same
 	// workload in several goroutines. For both the serial and parallel cases,
 	// the CPU time the process measures with its own profiler should match the
diff --git a/src/runtime/pprof/uname_linux_test.go b/src/runtime/pprof/uname_linux_test.go
new file mode 100644
index 0000000000..8374c83f74
--- /dev/null
+++ b/src/runtime/pprof/uname_linux_test.go
@@ -0,0 +1,61 @@
+// 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.
+
+//go:build linux
+
+package pprof
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"syscall"
+)
+
+var versionRe = regexp.MustCompile(`^(\d+)(?:\.(\d+)(?:\.(\d+))).*$`)
+
+func linuxKernelVersion() (major, minor, patch int, err error) {
+	var uname syscall.Utsname
+	if err := syscall.Uname(&uname); err != nil {
+		return 0, 0, 0, err
+	}
+
+	buf := make([]byte, 0, len(uname.Release))
+	for _, b := range uname.Release {
+		if b == 0 {
+			break
+		}
+		buf = append(buf, byte(b))
+	}
+	rl := string(buf)
+
+	m := versionRe.FindStringSubmatch(rl)
+	if m == nil {
+		return 0, 0, 0, fmt.Errorf("error matching version number in %q", rl)
+	}
+
+	v, err := strconv.ParseInt(m[1], 10, 64)
+	if err != nil {
+		return 0, 0, 0, fmt.Errorf("error parsing major version %q in %s: %w", m[1], rl, err)
+	}
+	major = int(v)
+
+	if len(m) >= 3 {
+		v, err := strconv.ParseInt(m[2], 10, 64)
+		if err != nil {
+			return 0, 0, 0, fmt.Errorf("error parsing minor version %q in %s: %w", m[2], rl, err)
+		}
+		minor = int(v)
+	}
+
+	if len(m) >= 4 {
+		v, err := strconv.ParseInt(m[3], 10, 64)
+		if err != nil {
+			return 0, 0, 0, fmt.Errorf("error parsing patch version %q in %s: %w", m[3], rl, err)
+		}
+		patch = int(v)
+	}
+
+	return
+}
diff --git a/src/runtime/pprof/uname_other_test.go b/src/runtime/pprof/uname_other_test.go
new file mode 100644
index 0000000000..327640755b
--- /dev/null
+++ b/src/runtime/pprof/uname_other_test.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.
+
+//go:build !linux
+
+package pprof
+
+import (
+	"errors"
+)
+
+func linuxKernelVersion() (major, minor, patch int, err error) {
+	return 0, 0, 0, errors.New("not running on linux")
+}

From 76fbd6167364fb98e3ebe946cfc16b5b84d4240e Mon Sep 17 00:00:00 2001
From: Damien Neil 
Date: Mon, 8 Nov 2021 11:23:27 -0800
Subject: [PATCH 129/752] net/http: do not cancel request context on response
 body read

When sending a Request with a non-context deadline, we create a
context with a timeout. This context is canceled when closing the
response body, and also if a read from the response body returns
an error (including io.EOF).

Cancelling the context in Response.Body.Read interferes with the
HTTP/2 client cleaning up after a request is completed, and is
unnecessary: The user should always close the body, the impact
from not canceling the context is minor (the context timer leaks
until it fires).

Fixes #49366.

Change-Id: Ieaed866116916261d9079f71d8fea7a7b303b8fb
Reviewed-on: https://go-review.googlesource.com/c/go/+/361919
Trust: Damien Neil 
Run-TryBot: Damien Neil 
TryBot-Result: Go Bot 
Reviewed-by: Brad Fitzpatrick 
---
 src/net/http/client.go      |  1 -
 src/net/http/client_test.go | 27 +++++++++++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/src/net/http/client.go b/src/net/http/client.go
index 4d380c65db..22db96b267 100644
--- a/src/net/http/client.go
+++ b/src/net/http/client.go
@@ -965,7 +965,6 @@ func (b *cancelTimerBody) Read(p []byte) (n int, err error) {
 	if err == nil {
 		return n, nil
 	}
-	b.stop()
 	if err == io.EOF {
 		return n, err
 	}
diff --git a/src/net/http/client_test.go b/src/net/http/client_test.go
index fb6fbe7197..62bf9342f4 100644
--- a/src/net/http/client_test.go
+++ b/src/net/http/client_test.go
@@ -1368,6 +1368,33 @@ func TestClientTimeoutCancel(t *testing.T) {
 	}
 }
 
+func TestClientTimeoutDoesNotExpire_h1(t *testing.T) { testClientTimeoutDoesNotExpire(t, h1Mode) }
+func TestClientTimeoutDoesNotExpire_h2(t *testing.T) { testClientTimeoutDoesNotExpire(t, h2Mode) }
+
+// Issue 49366: if Client.Timeout is set but not hit, no error should be returned.
+func testClientTimeoutDoesNotExpire(t *testing.T, h2 bool) {
+	setParallel(t)
+	defer afterTest(t)
+
+	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
+		w.Write([]byte("body"))
+	}))
+	defer cst.close()
+
+	cst.c.Timeout = 1 * time.Hour
+	req, _ := NewRequest("GET", cst.ts.URL, nil)
+	res, err := cst.c.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err = io.Copy(io.Discard, res.Body); err != nil {
+		t.Fatalf("io.Copy(io.Discard, res.Body) = %v, want nil", err)
+	}
+	if err = res.Body.Close(); err != nil {
+		t.Fatalf("res.Body.Close() = %v, want nil", err)
+	}
+}
+
 func TestClientRedirectEatsBody_h1(t *testing.T) { testClientRedirectEatsBody(t, h1Mode) }
 func TestClientRedirectEatsBody_h2(t *testing.T) { testClientRedirectEatsBody(t, h2Mode) }
 func testClientRedirectEatsBody(t *testing.T, h2 bool) {

From 363459479014bde19e83d9fb6781310f63fb0b45 Mon Sep 17 00:00:00 2001
From: Michael Pratt 
Date: Wed, 10 Nov 2021 12:56:40 -0500
Subject: [PATCH 130/752] runtime: start ARM atomic kernel helper traceback in
 caller

Like the VDSO, we cannot directly traceback from the Linux kernel ARM
atomic/barrier helpers. However, unlike the VDSO, this functions are
extremely simple. Neither of the functions we use, kuser_cmpxchg and
kuser_memory_barrier, touch SP or LR.

We can use this to our advantage to read LR and simply start tracebacks
in the caller.

Fixes #49182

Change-Id: I890edbeb7c128938000fe7baf6f913c02a956edd
Reviewed-on: https://go-review.googlesource.com/c/go/+/362977
Trust: Michael Pratt 
Run-TryBot: Michael Pratt 
TryBot-Result: Go Bot 
Reviewed-by: Cherry Mui 
---
 src/runtime/traceback.go | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/runtime/traceback.go b/src/runtime/traceback.go
index 36627a6735..73bd0e11a9 100644
--- a/src/runtime/traceback.go
+++ b/src/runtime/traceback.go
@@ -96,6 +96,20 @@ func gentraceback(pc0, sp0, lr0 uintptr, gp *g, skip int, pcbuf *uintptr, max in
 		}
 	}
 
+	// runtime/internal/atomic functions call into kernel helpers on
+	// arm < 7. See runtime/internal/atomic/sys_linux_arm.s.
+	//
+	// Start in the caller's frame.
+	if GOARCH == "arm" && goarm < 7 && GOOS == "linux" && frame.pc&0xffff0000 == 0xffff0000 {
+		// Note that the calls are simple BL without pushing the return
+		// address, so we use LR directly.
+		//
+		// The kernel helpers are frameless leaf functions, so SP and
+		// LR are not touched.
+		frame.pc = frame.lr
+		frame.lr = 0
+	}
+
 	f := findfunc(frame.pc)
 	if !f.valid() {
 		if callback != nil || printing {

From 9150c16bced33ca591a55fe4fb64817dd659b285 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Thu, 11 Nov 2021 16:02:35 -0800
Subject: [PATCH 131/752] cmd/compile/internal/types2: remove asTypeParam and
 simplify some code

Because we do not permit a stand-alone type parameter on the RHS of
a type declaration, the underlying type of a (Named) type cannot be
a type parameter. This allows us to simplify some code.

Specifically, when parsing union elements, we don't need to delay
a check for later, which allows further simplifications when computing
type sets.

Change-Id: I4047c609f87ebb194ea8c1bad630a70d255b20cf
Reviewed-on: https://go-review.googlesource.com/c/go/+/363438
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/importer/iimport.go    |  3 +--
 src/cmd/compile/internal/types2/builtins.go     |  6 +++---
 src/cmd/compile/internal/types2/call.go         |  2 +-
 .../compile/internal/types2/compilersupport.go  |  6 ------
 src/cmd/compile/internal/types2/conversions.go  |  6 +++---
 src/cmd/compile/internal/types2/decl.go         | 11 ++++++-----
 src/cmd/compile/internal/types2/expr.go         |  5 ++---
 src/cmd/compile/internal/types2/instantiate.go  |  8 ++++----
 src/cmd/compile/internal/types2/lookup.go       |  6 +-----
 src/cmd/compile/internal/types2/operand.go      |  6 +++---
 src/cmd/compile/internal/types2/predicates.go   |  2 +-
 src/cmd/compile/internal/types2/type.go         |  6 ------
 src/cmd/compile/internal/types2/typeset.go      |  8 --------
 src/cmd/compile/internal/types2/typexpr.go      |  2 +-
 src/cmd/compile/internal/types2/union.go        | 17 ++++++++---------
 15 files changed, 34 insertions(+), 60 deletions(-)

diff --git a/src/cmd/compile/internal/importer/iimport.go b/src/cmd/compile/internal/importer/iimport.go
index d04ef5c34d..1aa3b7b6a8 100644
--- a/src/cmd/compile/internal/importer/iimport.go
+++ b/src/cmd/compile/internal/importer/iimport.go
@@ -706,8 +706,7 @@ func (r *importReader) tparamList() []*types2.TypeParam {
 	}
 	xs := make([]*types2.TypeParam, n)
 	for i := range xs {
-		typ := r.typ()
-		xs[i] = types2.AsTypeParam(typ)
+		xs[i] = r.typ().(*types2.TypeParam)
 	}
 	return xs
 }
diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index 2bc084038f..99fe440340 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -293,7 +293,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		// the argument types must be of floating-point type
 		// (applyTypeFunc never calls f with a type parameter)
 		f := func(typ Type) Type {
-			assert(asTypeParam(typ) == nil)
+			assert(!isTypeParam(typ))
 			if t, _ := under(typ).(*Basic); t != nil {
 				switch t.kind {
 				case Float32:
@@ -436,7 +436,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		// the argument must be of complex type
 		// (applyTypeFunc never calls f with a type parameter)
 		f := func(typ Type) Type {
-			assert(asTypeParam(typ) == nil)
+			assert(!isTypeParam(typ))
 			if t, _ := under(typ).(*Basic); t != nil {
 				switch t.kind {
 				case Complex64:
@@ -813,7 +813,7 @@ func hasVarSize(t Type) bool {
 // applyTypeFunc returns nil.
 // If x is not a type parameter, the result is f(x).
 func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
-	if tp := asTypeParam(x); tp != nil {
+	if tp, _ := x.(*TypeParam); tp != nil {
 		// Test if t satisfies the requirements for the argument
 		// type and collect possible result types at the same time.
 		var terms []*Term
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 0540feaa78..b778d54b32 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -528,7 +528,7 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) {
 			check.errorf(e.Sel, "cannot call pointer method %s on %s", sel, x.typ)
 		default:
 			var why string
-			if tpar := asTypeParam(x.typ); tpar != nil {
+			if tpar, _ := x.typ.(*TypeParam); tpar != nil {
 				// Type parameter bounds don't specify fields, so don't mention "field".
 				if tname := tpar.iface().obj; tname != nil {
 					why = check.sprintf("interface %s has no method %s", tname.name, sel)
diff --git a/src/cmd/compile/internal/types2/compilersupport.go b/src/cmd/compile/internal/types2/compilersupport.go
index 31112d4e41..b35e752b8f 100644
--- a/src/cmd/compile/internal/types2/compilersupport.go
+++ b/src/cmd/compile/internal/types2/compilersupport.go
@@ -19,12 +19,6 @@ func AsSignature(t Type) *Signature {
 	return u
 }
 
-// If t is a type parameter, AsTypeParam returns that type, otherwise it returns nil.
-func AsTypeParam(t Type) *TypeParam {
-	u, _ := t.Underlying().(*TypeParam)
-	return u
-}
-
 // If typ is a type parameter, structuralType returns the single underlying
 // type of all types in the corresponding type constraint if it exists, or
 // nil otherwise. If the type set contains only unrestricted and restricted
diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index 7f93e2467f..968ac4d39f 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -48,7 +48,7 @@ func (check *Checker) conversion(x *operand, T Type) {
 		// If T's type set is empty, or if it doesn't
 		// have specific types, constant x cannot be
 		// converted.
-		ok = under(T).(*TypeParam).underIs(func(u Type) bool {
+		ok = T.(*TypeParam).underIs(func(u Type) bool {
 			// t is nil if there are no specific type terms
 			if u == nil {
 				cause = check.sprintf("%s does not contain specific types", T)
@@ -194,8 +194,8 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 	}
 
 	// optimization: if we don't have type parameters, we're done
-	Vp, _ := Vu.(*TypeParam)
-	Tp, _ := Tu.(*TypeParam)
+	Vp, _ := V.(*TypeParam)
+	Tp, _ := T.(*TypeParam)
 	if Vp == nil && Tp == nil {
 		return false
 	}
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 9b643fac99..bab90fbd9a 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -616,10 +616,11 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named
 	}
 
 	// Disallow a lone type parameter as the RHS of a type declaration (issue #45639).
-	// We can look directly at named.underlying because even if it is still a *Named
-	// type (underlying not fully resolved yet) it cannot become a type parameter due
-	// to this very restriction.
-	if tpar, _ := named.underlying.(*TypeParam); tpar != nil {
+	// We don't need this restriction anymore if we make the underlying type of a type
+	// parameter its constraint interface: if the RHS is a lone type parameter, we will
+	// use its underlying type (like we do for any RHS in a type declaration), and its
+	// underlying type is an interface and the type declaration is well defined.
+	if isTypeParam(rhs) {
 		check.error(tdecl.Type, "cannot use a type parameter as RHS in type declaration")
 		named.underlying = Typ[Invalid]
 	}
@@ -671,7 +672,7 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list []*syntax.Fiel
 
 	check.later(func() {
 		for i, bound := range bounds {
-			if _, ok := under(bound).(*TypeParam); ok {
+			if isTypeParam(bound) {
 				check.error(posers[i], "cannot use a type parameter as constraint")
 			}
 		}
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 0b3fe23e80..17096ee418 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -160,11 +160,10 @@ var op2str2 = [...]string{
 // If typ is a type parameter, underIs returns the result of typ.underIs(f).
 // Otherwise, underIs returns the result of f(under(typ)).
 func underIs(typ Type, f func(Type) bool) bool {
-	u := under(typ)
-	if tpar, _ := u.(*TypeParam); tpar != nil {
+	if tpar, _ := typ.(*TypeParam); tpar != nil {
 		return tpar.underIs(f)
 	}
-	return f(u)
+	return f(under(typ))
 }
 
 func (check *Checker) unary(x *operand, e *syntax.Operation) {
diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index f814619bb0..582d1e4763 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -143,7 +143,7 @@ func (check *Checker) satisfies(pos syntax.Pos, targ Type, tpar *TypeParam, smap
 
 	// A type argument that is a type parameter with an empty type set satisfies any constraint.
 	// (The empty set is a subset of any set.)
-	if targ := asTypeParam(targ); targ != nil && targ.iface().typeSet().IsEmpty() {
+	if targ, _ := targ.(*TypeParam); targ != nil && targ.iface().typeSet().IsEmpty() {
 		return nil
 	}
 
@@ -172,7 +172,7 @@ func (check *Checker) satisfies(pos syntax.Pos, targ Type, tpar *TypeParam, smap
 	// if iface is comparable, targ must be comparable
 	// TODO(gri) the error messages needs to be better, here
 	if iface.IsComparable() && !Comparable(targ) {
-		if tpar := asTypeParam(targ); tpar != nil && tpar.iface().typeSet().IsAll() {
+		if tpar, _ := targ.(*TypeParam); tpar != nil && tpar.iface().typeSet().IsAll() {
 			return errorf("%s has no constraints", targ)
 		}
 		return errorf("%s does not satisfy comparable", targ)
@@ -184,7 +184,7 @@ func (check *Checker) satisfies(pos syntax.Pos, targ Type, tpar *TypeParam, smap
 		// If the type argument is a pointer to a type parameter, the type argument's
 		// method set is empty.
 		// TODO(gri) is this what we want? (spec question)
-		if base, isPtr := deref(targ); isPtr && asTypeParam(base) != nil {
+		if base, isPtr := deref(targ); isPtr && isTypeParam(base) {
 			return errorf("%s has no methods", targ)
 		}
 		if m, wrong := check.missingMethod(targ, iface, true); m != nil {
@@ -212,7 +212,7 @@ func (check *Checker) satisfies(pos syntax.Pos, targ Type, tpar *TypeParam, smap
 	// If targ is itself a type parameter, each of its possible types must be in the set
 	// of iface types (i.e., the targ type set must be a subset of the iface type set).
 	// Type arguments with empty type sets were already excluded above.
-	if targ := asTypeParam(targ); targ != nil {
+	if targ, _ := targ.(*TypeParam); targ != nil {
 		targBound := targ.iface()
 		if !targBound.typeSet().subsetOf(iface.typeSet()) {
 			// TODO(gri) report which type is missing
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index 0612400590..5da51a23ab 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -134,12 +134,8 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 					continue // we can't have a matching field or interface method
 				}
 
-				// continue with underlying type, but only if it's not a type parameter
-				// TODO(gri) is this what we want to do for type parameters? (spec question)
+				// continue with underlying type
 				typ = named.under()
-				if asTypeParam(typ) != nil {
-					continue
-				}
 			}
 
 			tpar = nil
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index 2f85802701..762a7543a9 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -183,7 +183,7 @@ func operandString(x *operand, qf Qualifier) string {
 			}
 			buf.WriteString(intro)
 			WriteType(&buf, x.typ, qf)
-			if tpar := asTypeParam(x.typ); tpar != nil {
+			if tpar, _ := x.typ.(*TypeParam); tpar != nil {
 				buf.WriteString(" constrained by ")
 				WriteType(&buf, tpar.bound, qf) // do not compute interface type sets here
 			}
@@ -256,8 +256,8 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 
 	Vu := under(V)
 	Tu := under(T)
-	Vp, _ := Vu.(*TypeParam)
-	Tp, _ := Tu.(*TypeParam)
+	Vp, _ := V.(*TypeParam)
+	Tp, _ := T.(*TypeParam)
 
 	// x is an untyped value representable by a value of type T.
 	if isUntyped(Vu) {
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index f1fd33c5de..5cb1c33814 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -90,7 +90,7 @@ func IsInterface(t Type) bool {
 
 // isTypeParam reports whether t is a type parameter.
 func isTypeParam(t Type) bool {
-	_, ok := under(t).(*TypeParam)
+	_, ok := t.(*TypeParam)
 	return ok
 }
 
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index c8c0f36e5c..24d44442e9 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -88,9 +88,3 @@ func asNamed(t Type) *Named {
 	}
 	return e
 }
-
-// If t is a type parameter, asTypeParam returns that type, otherwise it returns nil.
-func asTypeParam(t Type) *TypeParam {
-	u, _ := under(t).(*TypeParam)
-	return u
-}
diff --git a/src/cmd/compile/internal/types2/typeset.go b/src/cmd/compile/internal/types2/typeset.go
index c37a20e73e..882f387c3c 100644
--- a/src/cmd/compile/internal/types2/typeset.go
+++ b/src/cmd/compile/internal/types2/typeset.go
@@ -291,10 +291,6 @@ func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *_
 				continue // ignore invalid unions
 			}
 			terms = tset.terms
-		case *TypeParam:
-			// Embedding stand-alone type parameters is not permitted.
-			// Union parsing reports a (delayed) error, so we can ignore this entry.
-			continue
 		default:
 			if u == Typ[Invalid] {
 				continue
@@ -372,10 +368,6 @@ func computeUnionTypeSet(check *Checker, pos syntax.Pos, utyp *Union) *_TypeSet
 		switch u := under(t.typ).(type) {
 		case *Interface:
 			terms = computeInterfaceTypeSet(check, pos, u).terms
-		case *TypeParam:
-			// A stand-alone type parameters is not permitted as union term.
-			// Union parsing reports a (delayed) error, so we can ignore this entry.
-			continue
 		default:
 			if t.typ == Typ[Invalid] {
 				continue
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 82c029cfd6..a2585179ee 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -356,7 +356,7 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
 		check.later(func() {
 			if !Comparable(typ.key) {
 				var why string
-				if asTypeParam(typ.key) != nil {
+				if isTypeParam(typ.key) {
 					why = " (missing comparable constraint)"
 				}
 				check.errorf(e.Key, "invalid map key type %s%s", typ.key, why)
diff --git a/src/cmd/compile/internal/types2/union.go b/src/cmd/compile/internal/types2/union.go
index 5379bde02c..2304b30280 100644
--- a/src/cmd/compile/internal/types2/union.go
+++ b/src/cmd/compile/internal/types2/union.go
@@ -115,15 +115,14 @@ func parseTilde(check *Checker, x syntax.Expr) (tilde bool, typ Type) {
 	}
 	typ = check.typ(x)
 	// Embedding stand-alone type parameters is not permitted (issue #47127).
-	// Do this check later because it requires computation of the underlying type (see also issue #46461).
-	// Note: If an underlying type cannot be a type parameter, the call to
-	//       under() will not be needed and then we don't need to delay this
-	//       check to later and could return Typ[Invalid] instead.
-	check.later(func() {
-		if _, ok := under(typ).(*TypeParam); ok {
-			check.error(x, "cannot embed a type parameter")
-		}
-	})
+	// We don't need this restriction anymore if we make the underlying type of a type
+	// parameter its constraint interface: if we embed a lone type parameter, we will
+	// simply use its underlying type (like we do for other named, embedded interfaces),
+	// and since the underlying type is an interface the embedding is well defined.
+	if isTypeParam(typ) {
+		check.error(x, "cannot embed a type parameter")
+		typ = Typ[Invalid]
+	}
 	return
 }
 

From f9dcda3fd83e83fb29cc6b0f710faa49ba98a54b Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Thu, 11 Nov 2021 16:32:16 -0800
Subject: [PATCH 132/752] cmd/compile/internal/types2: better error for type
 assertion/switch on type parameter value

Change-Id: I98751d0b2d8aefcf537b6d5200d0b52ffacf1105
Reviewed-on: https://go-review.googlesource.com/c/go/+/363439
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/expr.go               |  7 ++++++-
 src/cmd/compile/internal/types2/stmt.go               | 11 ++++++-----
 .../internal/types2/testdata/check/typeparams.go2     |  8 ++++----
 test/interface/explicit.go                            |  2 +-
 test/typeswitch3.go                                   |  4 ++--
 5 files changed, 19 insertions(+), 13 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 17096ee418..25e2060100 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1459,9 +1459,14 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		if x.mode == invalid {
 			goto Error
 		}
+		// TODO(gri) we may want to permit type assertions on type parameter values at some point
+		if isTypeParam(x.typ) {
+			check.errorf(x, invalidOp+"cannot use type assertion on type parameter value %s", x)
+			goto Error
+		}
 		xtyp, _ := under(x.typ).(*Interface)
 		if xtyp == nil {
-			check.errorf(x, "%s is not an interface type", x)
+			check.errorf(x, invalidOp+"%s is not an interface", x)
 			goto Error
 		}
 		// x.(type) expressions are encoded via TypeSwitchGuards
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index f9c07e38cd..6869c87929 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -733,13 +733,14 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu
 	if x.mode == invalid {
 		return
 	}
-	// Caution: We're not using asInterface here because we don't want
-	//          to switch on a suitably constrained type parameter (for
-	//          now).
-	// TODO(gri) Need to revisit this.
+	// TODO(gri) we may want to permit type switches on type parameter values at some point
+	if isTypeParam(x.typ) {
+		check.errorf(&x, "cannot use type switch on type parameter value %s", &x)
+		return
+	}
 	xtyp, _ := under(x.typ).(*Interface)
 	if xtyp == nil {
-		check.errorf(&x, "%s is not an interface type", &x)
+		check.errorf(&x, "%s is not an interface", &x)
 		return
 	}
 
diff --git a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
index b1d02efdb5..03c3f9a0b5 100644
--- a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
+++ b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
@@ -482,8 +482,8 @@ func (_ R2[X, Y]) m2(X) Y
 // type assertions and type switches over generic types lead to errors for now
 
 func _[T any](x T) {
-	_ = x /* ERROR not an interface */ .(int)
-	switch x /* ERROR not an interface */ .(type) {
+	_ = x /* ERROR cannot use type assertion */ .(int)
+	switch x /* ERROR cannot use type switch */ .(type) {
 	}
 
 	// work-around
@@ -494,8 +494,8 @@ func _[T any](x T) {
 }
 
 func _[T interface{~int}](x T) {
-	_ = x /* ERROR not an interface */ .(int)
-	switch x /* ERROR not an interface */ .(type) {
+	_ = x /* ERROR cannot use type assertion */ .(int)
+	switch x /* ERROR cannot use type switch */ .(type) {
 	}
 
 	// work-around
diff --git a/test/interface/explicit.go b/test/interface/explicit.go
index 1b7af6712b..f769f5878c 100644
--- a/test/interface/explicit.go
+++ b/test/interface/explicit.go
@@ -57,7 +57,7 @@ func main() {
 
 	// cannot type-assert non-interfaces
 	f := 2.0
-	_ = f.(int) // ERROR "non-interface type|only valid for interface types|not an interface type"
+	_ = f.(int) // ERROR "non-interface type|only valid for interface types|not an interface"
 
 }
 
diff --git a/test/typeswitch3.go b/test/typeswitch3.go
index a57889bc1d..2e144d81c0 100644
--- a/test/typeswitch3.go
+++ b/test/typeswitch3.go
@@ -42,7 +42,7 @@ func main() {
 
 func noninterface() {
 	var i int
-	switch i.(type) { // ERROR "cannot type switch on non-interface value|not an interface type"
+	switch i.(type) { // ERROR "cannot type switch on non-interface value|not an interface"
 	case string:
 	case int:
 	}
@@ -51,6 +51,6 @@ func noninterface() {
 		name string
 	}
 	var s S
-	switch s.(type) { // ERROR "cannot type switch on non-interface value|not an interface type"
+	switch s.(type) { // ERROR "cannot type switch on non-interface value|not an interface"
 	}
 }

From 1cd600301ea2a0b13d5e158282200114dc9de3fd Mon Sep 17 00:00:00 2001
From: Michael Matloob 
Date: Thu, 28 Oct 2021 14:54:30 -0400
Subject: [PATCH 133/752] cmd/go: use workspace modules' go.sum files to check
 sums

By default, use workspace modules' go.sum files to check sums. Any
missing sums will still be written to go.work.sum

For #45713

Change-Id: I0f537602523dfec44d423c3c80c7ef396e1397b1
Reviewed-on: https://go-review.googlesource.com/c/go/+/359478
Trust: Michael Matloob 
Run-TryBot: Michael Matloob 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
---
 src/cmd/go/internal/modfetch/fetch.go         | 79 ++++++++++++++++---
 src/cmd/go/internal/modload/init.go           |  6 +-
 src/cmd/go/testdata/script/work_sum.txt       |  5 +-
 .../go/testdata/script/work_sum_mismatch.txt  | 61 ++++++++++++++
 4 files changed, 134 insertions(+), 17 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/work_sum_mismatch.txt

diff --git a/src/cmd/go/internal/modfetch/fetch.go b/src/cmd/go/internal/modfetch/fetch.go
index 408b2860ad..e246c1a04d 100644
--- a/src/cmd/go/internal/modfetch/fetch.go
+++ b/src/cmd/go/internal/modfetch/fetch.go
@@ -384,7 +384,8 @@ func RemoveAll(dir string) error {
 	return robustio.RemoveAll(dir)
 }
 
-var GoSumFile string // path to go.sum; set by package modload
+var GoSumFile string             // path to go.sum; set by package modload
+var WorkspaceGoSumFiles []string // path to module go.sums in workspace; set by package modload
 
 type modSum struct {
 	mod module.Version
@@ -393,10 +394,11 @@ type modSum struct {
 
 var goSum struct {
 	mu        sync.Mutex
-	m         map[module.Version][]string // content of go.sum file
-	status    map[modSum]modSumStatus     // state of sums in m
-	overwrite bool                        // if true, overwrite go.sum without incorporating its contents
-	enabled   bool                        // whether to use go.sum at all
+	m         map[module.Version][]string            // content of go.sum file
+	w         map[string]map[module.Version][]string // sum file in workspace -> content of that sum file
+	status    map[modSum]modSumStatus                // state of sums in m
+	overwrite bool                                   // if true, overwrite go.sum without incorporating its contents
+	enabled   bool                                   // whether to use go.sum at all
 }
 
 type modSumStatus struct {
@@ -417,23 +419,38 @@ func initGoSum() (bool, error) {
 
 	goSum.m = make(map[module.Version][]string)
 	goSum.status = make(map[modSum]modSumStatus)
+	goSum.w = make(map[string]map[module.Version][]string)
+
+	for _, f := range WorkspaceGoSumFiles {
+		goSum.w[f] = make(map[module.Version][]string)
+		_, err := readGoSumFile(goSum.w[f], f)
+		if err != nil {
+			return false, err
+		}
+	}
+
+	enabled, err := readGoSumFile(goSum.m, GoSumFile)
+	goSum.enabled = enabled
+	return enabled, err
+}
+
+func readGoSumFile(dst map[module.Version][]string, file string) (bool, error) {
 	var (
 		data []byte
 		err  error
 	)
-	if actualSumFile, ok := fsys.OverlayPath(GoSumFile); ok {
+	if actualSumFile, ok := fsys.OverlayPath(file); ok {
 		// Don't lock go.sum if it's part of the overlay.
 		// On Plan 9, locking requires chmod, and we don't want to modify any file
 		// in the overlay. See #44700.
 		data, err = os.ReadFile(actualSumFile)
 	} else {
-		data, err = lockedfile.Read(GoSumFile)
+		data, err = lockedfile.Read(file)
 	}
 	if err != nil && !os.IsNotExist(err) {
 		return false, err
 	}
-	goSum.enabled = true
-	readGoSum(goSum.m, GoSumFile, data)
+	readGoSum(dst, file, data)
 
 	return true, nil
 }
@@ -485,6 +502,16 @@ func HaveSum(mod module.Version) bool {
 	if err != nil || !inited {
 		return false
 	}
+	for _, goSums := range goSum.w {
+		for _, h := range goSums[mod] {
+			if !strings.HasPrefix(h, "h1:") {
+				continue
+			}
+			if !goSum.status[modSum{mod, h}].dirty {
+				return true
+			}
+		}
+	}
 	for _, h := range goSum.m[mod] {
 		if !strings.HasPrefix(h, "h1:") {
 			continue
@@ -602,15 +629,32 @@ func checkModSum(mod module.Version, h string) error {
 // If it finds a conflicting pair instead, it calls base.Fatalf.
 // goSum.mu must be locked.
 func haveModSumLocked(mod module.Version, h string) bool {
+	sumFileName := "go.sum"
+	if strings.HasSuffix(GoSumFile, "go.work.sum") {
+		sumFileName = "go.work.sum"
+	}
 	for _, vh := range goSum.m[mod] {
 		if h == vh {
 			return true
 		}
 		if strings.HasPrefix(vh, "h1:") {
-			base.Fatalf("verifying %s@%s: checksum mismatch\n\tdownloaded: %v\n\tgo.sum:     %v"+goSumMismatch, mod.Path, mod.Version, h, vh)
+			base.Fatalf("verifying %s@%s: checksum mismatch\n\tdownloaded: %v\n\t%s:     %v"+goSumMismatch, mod.Path, mod.Version, h, sumFileName, vh)
 		}
 	}
-	return false
+	// Also check workspace sums.
+	foundMatch := false
+	// Check sums from all files in case there are conflicts between
+	// the files.
+	for goSumFile, goSums := range goSum.w {
+		for _, vh := range goSums[mod] {
+			if h == vh {
+				foundMatch = true
+			} else if strings.HasPrefix(vh, "h1:") {
+				base.Fatalf("verifying %s@%s: checksum mismatch\n\tdownloaded: %v\n\t%s:     %v"+goSumMismatch, mod.Path, mod.Version, h, goSumFile, vh)
+			}
+		}
+	}
+	return foundMatch
 }
 
 // addModSumLocked adds the pair mod,h to go.sum.
@@ -749,7 +793,7 @@ Outer:
 			goSum.m = make(map[module.Version][]string, len(goSum.m))
 			readGoSum(goSum.m, GoSumFile, data)
 			for ms, st := range goSum.status {
-				if st.used {
+				if st.used && !sumInWorkspaceModulesLocked(ms.mod) {
 					addModSumLocked(ms.mod, ms.sum)
 				}
 			}
@@ -767,7 +811,7 @@ Outer:
 			sort.Strings(list)
 			for _, h := range list {
 				st := goSum.status[modSum{m, h}]
-				if !st.dirty || (st.used && keep[m]) {
+				if (!st.dirty || (st.used && keep[m])) && !sumInWorkspaceModulesLocked(m) {
 					fmt.Fprintf(&buf, "%s %s %s\n", m.Path, m.Version, h)
 				}
 			}
@@ -784,6 +828,15 @@ Outer:
 	return nil
 }
 
+func sumInWorkspaceModulesLocked(m module.Version) bool {
+	for _, goSums := range goSum.w {
+		if _, ok := goSums[m]; ok {
+			return true
+		}
+	}
+	return false
+}
+
 // TrimGoSum trims go.sum to contain only the modules needed for reproducible
 // builds.
 //
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index a6e49c6c71..fcf6ce2620 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -624,8 +624,10 @@ func LoadModFile(ctx context.Context) *Requirements {
 		if err != nil {
 			base.Fatalf("reading go.work: %v", err)
 		}
-		_ = TODOWorkspaces("Support falling back to individual module go.sum " +
-			"files for sums not in the workspace sum file.")
+		for _, modRoot := range modRoots {
+			sumFile := strings.TrimSuffix(modFilePath(modRoot), ".mod") + ".sum"
+			modfetch.WorkspaceGoSumFiles = append(modfetch.WorkspaceGoSumFiles, sumFile)
+		}
 		modfetch.GoSumFile = workFilePath + ".sum"
 	} else if modRoots == nil {
 		// We're in module mode, but not inside a module.
diff --git a/src/cmd/go/testdata/script/work_sum.txt b/src/cmd/go/testdata/script/work_sum.txt
index 99f66a4003..20261e7cbd 100644
--- a/src/cmd/go/testdata/script/work_sum.txt
+++ b/src/cmd/go/testdata/script/work_sum.txt
@@ -8,8 +8,6 @@ golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c h1:pvCbr/wm8HzDD3fVywevekuf
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 rsc.io/quote v1.5.2 h1:3fEykkD9k7lYzXqCYrwGAf7iNhbk4yCjHmKBN9td4L0=
 rsc.io/quote v1.5.2/go.mod h1:LzX7hefJvL54yjefDEDHNONDjII0t9xZLPXsUe+TKr0=
-rsc.io/sampler v1.3.0 h1:HLGR/BgEtI3r0uymSP/nl2uPLsUnNJX8toRyhfpBTII=
-rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
 -- go.work --
 go 1.18
 
@@ -20,6 +18,9 @@ go 1.18
 module example.com/hi
 
 require "rsc.io/quote" v1.5.2
+-- go.sum --
+rsc.io/sampler v1.3.0 h1:HLGR/BgEtI3r0uymSP/nl2uPLsUnNJX8toRyhfpBTII=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
 -- main.go --
 package main
 
diff --git a/src/cmd/go/testdata/script/work_sum_mismatch.txt b/src/cmd/go/testdata/script/work_sum_mismatch.txt
new file mode 100644
index 0000000000..42994ea5d5
--- /dev/null
+++ b/src/cmd/go/testdata/script/work_sum_mismatch.txt
@@ -0,0 +1,61 @@
+# Test mismatched sums in go.sum files
+
+! go run ./a
+cmpenv stderr want-error
+
+-- want-error --
+verifying rsc.io/sampler@v1.3.0/go.mod: checksum mismatch
+	downloaded: h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+	$WORK${/}gopath${/}src${/}a${/}go.sum:     h1:U1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+
+SECURITY ERROR
+This download does NOT match an earlier download recorded in go.sum.
+The bits may have been replaced on the origin server, or an attacker may
+have intercepted the download attempt.
+
+For more information, see 'go help module-auth'.
+-- go.work --
+go 1.18
+
+directory ./a
+directory ./b
+-- a/go.mod --
+go 1.18
+
+module example.com/hi
+
+require "rsc.io/quote" v1.5.2
+-- a/go.sum --
+rsc.io/sampler v1.3.0 h1:HLGR/BgEtI3r0uymSP/nl2uPLsUnNJX8toRyhfpBTII=
+rsc.io/sampler v1.3.0/go.mod h1:U1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+-- a/main.go --
+package main
+
+import (
+	"fmt"
+	"rsc.io/quote"
+)
+
+func main() {
+	fmt.Println(quote.Hello())
+}
+-- b/go.mod --
+go 1.18
+
+module example.com/hi
+
+require "rsc.io/quote" v1.5.2
+-- b/go.sum --
+rsc.io/sampler v1.3.0 h1:HLGR/BgEtI3r0uymSP/nl2uPLsUnNJX8toRyhfpBTII=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+-- b/main.go --
+package main
+
+import (
+	"fmt"
+	"rsc.io/quote"
+)
+
+func main() {
+	fmt.Println(quote.Hello())
+}
\ No newline at end of file

From c8d6ee12d5eb1c64f2aff8a4d511f677a64e3aed Mon Sep 17 00:00:00 2001
From: Dan Scales 
Date: Wed, 10 Nov 2021 08:41:21 -0800
Subject: [PATCH 134/752] cmd/compile: match Go 1.17 compiler error messages
 more closely

When being used by the compiler, fix up types2 error messages to be more
like Go 1.17 compiler errors. In particular:

  - add information about which method is missing when a type is not
    assignable/convertible/etc. to an interface.

  - add information about any existing method which has the same name,
    but wrong type.

  - add extra hint in the case that the source or destination type is a
    pointer to an interface, rather than an interface.

  - add extra hint "need type assertion" in the case that the source is
    an interface that is implemented by the destination.

  - the following change in the CL stack also adds information about any
    existing method with a different name that only differs in case.

Include much of the new logic in a new common function
(*Checker).missingMethodReason().

types2 still adds a little more information in some cases then the Go
1.17 compiler. For example, it typically says "(value of type T)",
rather than "(type T)", where "value" could also be "constant",
"variable", etc.

I kept the types2 error messages almost all the same when types2 is not
used by the compiler. The only change (to reduce amount of compatibility
code) was to change "M method" phrasing in one case to "method M"
phrasing in one error message (which is the phrasing it uses in all
other cases). That is the reason that there are a few small changes in
types2/testdata/check/*.src.

Added new test test/fixedbugs/issue48471.go to test that the added
information is appearing correctly.

Also adjusted the pattern matching in a bunch of other
test/fixedbugs/*.go, now that types2 is producing error messages closer
to Go 1.17. Was able to remove a couple test files from the types2
exception list in run.go.

Updated #48471

Change-Id: I8af1eae6eb8a5541d8ea20b66f494e2e795e1956
Reviewed-on: https://go-review.googlesource.com/c/go/+/363436
Trust: Dan Scales 
Run-TryBot: Dan Scales 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 .../compile/internal/types2/assignments.go    |  6 +-
 .../compile/internal/types2/conversions.go    | 16 ++++-
 src/cmd/compile/internal/types2/expr.go       | 21 +++----
 src/cmd/compile/internal/types2/lookup.go     | 58 +++++++++++++++++++
 src/cmd/compile/internal/types2/operand.go    | 41 +++++++++----
 .../internal/types2/testdata/check/expr3.src  |  4 +-
 .../internal/types2/testdata/check/issues.src |  2 +-
 .../internal/types2/testdata/check/stmt0.src  |  2 +-
 .../types2/testdata/fixedbugs/issue49005.go   |  4 +-
 test/alias2.go                                | 10 ++--
 test/append1.go                               |  2 +-
 test/ddd1.go                                  |  2 +-
 test/fixedbugs/bug389.go                      |  2 +-
 test/fixedbugs/issue41247.go                  |  2 +-
 test/fixedbugs/issue48471.go                  | 41 +++++++++++++
 test/fixedbugs/issue6572.go                   |  2 +-
 test/fixedbugs/issue9521.go                   |  4 +-
 test/interface/explicit.go                    |  2 +-
 test/run.go                                   |  3 -
 19 files changed, 175 insertions(+), 49 deletions(-)
 create mode 100644 test/fixedbugs/issue48471.go

diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index 609d7d0962..da7f7dfa5c 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -85,7 +85,11 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 	reason := ""
 	if ok, _ := x.assignableTo(check, T, &reason); !ok {
 		if check.conf.CompilerErrorMessages {
-			check.errorf(x, "incompatible type: cannot use %s as %s value", x, T)
+			if reason != "" {
+				check.errorf(x, "cannot use %s as type %s in %s:\n\t%s", x, T, context, reason)
+			} else {
+				check.errorf(x, "cannot use %s as type %s in %s", x, T, context)
+			}
 		} else {
 			if reason != "" {
 				check.errorf(x, "cannot use %s as %s value in %s: %s", x, T, context, reason)
diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index 968ac4d39f..cc7b52099c 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -69,9 +69,19 @@ func (check *Checker) conversion(x *operand, T Type) {
 
 	if !ok {
 		var err error_
-		err.errorf(x, "cannot convert %s to %s", x, T)
-		if cause != "" {
-			err.errorf(nopos, cause)
+		if check.conf.CompilerErrorMessages {
+			if cause != "" {
+				// Add colon at end of line if we have a following cause.
+				err.errorf(x, "cannot convert %s to type %s:", x, T)
+				err.errorf(nopos, cause)
+			} else {
+				err.errorf(x, "cannot convert %s to type %s", x, T)
+			}
+		} else {
+			err.errorf(x, "cannot convert %s to %s", x, T)
+			if cause != "" {
+				err.errorf(nopos, cause)
+			}
 		}
 		check.report(&err)
 		x.mode = invalid
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 25e2060100..f86606375c 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -1626,25 +1626,20 @@ func (check *Checker) typeAssertion(e syntax.Expr, x *operand, xtyp *Interface,
 		return
 	}
 
-	var msg string
-	if wrongType != nil {
-		if Identical(method.typ, wrongType.typ) {
-			msg = fmt.Sprintf("%s method has pointer receiver", method.name)
-		} else {
-			msg = fmt.Sprintf("wrong type for method %s: have %s, want %s", method.name, wrongType.typ, method.typ)
-		}
-	} else {
-		msg = fmt.Sprintf("missing %s method", method.name)
-	}
-
 	var err error_
+	var msg string
 	if typeSwitch {
 		err.errorf(e.Pos(), "impossible type switch case: %s", e)
-		err.errorf(nopos, "%s cannot have dynamic type %s (%s)", x, T, msg)
+		msg = check.sprintf("%s cannot have dynamic type %s %s", x, T,
+			check.missingMethodReason(T, x.typ, method, wrongType))
+
 	} else {
 		err.errorf(e.Pos(), "impossible type assertion: %s", e)
-		err.errorf(nopos, "%s does not implement %s (%s)", T, x.typ, msg)
+		msg = check.sprintf("%s does not implement %s %s", T, x.typ,
+			check.missingMethodReason(T, x.typ, method, wrongType))
+
 	}
+	err.errorf(nopos, msg)
 	check.report(&err)
 }
 
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index 5da51a23ab..a05a5d6397 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -6,6 +6,11 @@
 
 package types2
 
+import (
+	"fmt"
+	"strings"
+)
+
 // Internal use of LookupFieldOrMethod: If the obj result is a method
 // associated with a concrete (non-interface) type, the method's signature
 // may not be fully set up. Call Checker.objDecl(obj, nil) before accessing
@@ -401,6 +406,59 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 	return
 }
 
+// missingMethodReason returns a string giving the detailed reason for a missing method m,
+// where m is missing from V, but required by T. It puts the reason in parentheses,
+// and may include more have/want info after that. If non-nil, wrongType is a relevant
+// method that matches in some way. It may have the correct name, but wrong type, or
+// it may have a pointer receiver.
+func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string {
+	var r string
+	var mname string
+	if check.conf.CompilerErrorMessages {
+		mname = m.Name() + " method"
+	} else {
+		mname = "method " + m.Name()
+	}
+	if wrongType != nil {
+		if Identical(m.typ, wrongType.typ) {
+			if m.Name() == wrongType.Name() {
+				r = fmt.Sprintf("(%s has pointer receiver)", mname)
+			} else {
+				r = fmt.Sprintf("(missing %s)\n\t\thave %s^^%s\n\t\twant %s^^%s",
+					mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ)
+			}
+		} else {
+			if check.conf.CompilerErrorMessages {
+				r = fmt.Sprintf("(wrong type for %s)\n\t\thave %s^^%s\n\t\twant %s^^%s",
+					mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ)
+			} else {
+				r = fmt.Sprintf("(wrong type for %s: have %s, want %s)",
+					mname, wrongType.typ, m.typ)
+			}
+		}
+		// This is a hack to print the function type without the leading
+		// 'func' keyword in the have/want printouts. We could change to have
+		// an extra formatting option for types2.Type that doesn't print out
+		// 'func'.
+		r = strings.Replace(r, "^^func", "", -1)
+	} else if IsInterface(T) {
+		if isInterfacePtr(V) {
+			r = fmt.Sprintf("(%s is pointer to interface, not interface)", V)
+		}
+	} else if isInterfacePtr(T) {
+		r = fmt.Sprintf("(%s is pointer to interface, not interface)", T)
+	}
+	if r == "" {
+		r = fmt.Sprintf("(missing %s)", mname)
+	}
+	return r
+}
+
+func isInterfacePtr(T Type) bool {
+	p, _ := under(T).(*Pointer)
+	return p != nil && IsInterface(p.base)
+}
+
 // assertableTo reports whether a value of type V can be asserted to have type T.
 // It returns (nil, false) as affirmative answer. Otherwise it returns a missing
 // method required by V and whether it is missing or just has the wrong type.
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index 762a7543a9..fee154a6bb 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -289,18 +289,21 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 
 	// T is an interface type and x implements T and T is not a type parameter
 	if Ti, ok := Tu.(*Interface); ok {
-		if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* Implements(V, Ti) */ {
+		if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* !Implements(V, Ti) */ {
 			if reason != nil {
-				// TODO(gri) the error messages here should follow the style in Checker.typeAssertion (factor!)
-				if wrongType != nil {
-					if Identical(m.typ, wrongType.typ) {
-						*reason = fmt.Sprintf("missing method %s (%s has pointer receiver)", m.name, m.name)
-					} else {
-						*reason = fmt.Sprintf("wrong type for method %s (have %s, want %s)", m.Name(), wrongType.typ, m.typ)
-					}
-
+				if check.conf.CompilerErrorMessages {
+					*reason = check.sprintf("%s does not implement %s %s", x.typ, T,
+						check.missingMethodReason(x.typ, T, m, wrongType))
 				} else {
-					*reason = "missing method " + m.Name()
+					if wrongType != nil {
+						if Identical(m.typ, wrongType.typ) {
+							*reason = fmt.Sprintf("missing method %s (%s has pointer receiver)", m.name, m.name)
+						} else {
+							*reason = fmt.Sprintf("wrong type for method %s (have %s, want %s)", m.Name(), wrongType.typ, m.typ)
+						}
+					} else {
+						*reason = "missing method " + m.Name()
+					}
 				}
 			}
 			return false, _InvalidIfaceAssign
@@ -308,6 +311,24 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 		return true, 0
 	}
 
+	// Provide extra detail in compiler error messages in some cases when T is
+	// not an interface.
+	if check != nil && check.conf.CompilerErrorMessages {
+		if isInterfacePtr(Tu) {
+			*reason = check.sprintf("%s does not implement %s (%s is pointer to interface, not interface)", x.typ, T, T)
+			return false, _InvalidIfaceAssign
+		}
+		if Vi, _ := Vu.(*Interface); Vi != nil {
+			if m, _ := check.missingMethod(T, Vi, true); m == nil {
+				// T implements Vi, so give hint about type assertion.
+				if reason != nil {
+					*reason = check.sprintf("need type assertion")
+				}
+				return false, _IncompatibleAssign
+			}
+		}
+	}
+
 	// x is a bidirectional channel value, T is a channel
 	// type, x's type V and T have identical element types,
 	// and at least one of V or T is not a named type.
diff --git a/src/cmd/compile/internal/types2/testdata/check/expr3.src b/src/cmd/compile/internal/types2/testdata/check/expr3.src
index df4cf6a840..d1e1dba9f4 100644
--- a/src/cmd/compile/internal/types2/testdata/check/expr3.src
+++ b/src/cmd/compile/internal/types2/testdata/check/expr3.src
@@ -459,9 +459,9 @@ func type_asserts() {
 
 	var t I
 	_ = t /* ERROR "use of .* outside type switch" */ .(type)
-	_ = t /* ERROR "m method has pointer receiver" */ .(T)
+	_ = t /* ERROR "method m has pointer receiver" */ .(T)
 	_ = t.(*T)
-	_ = t /* ERROR "missing m method" */ .(T1)
+	_ = t /* ERROR "missing method m" */ .(T1)
 	_ = t /* ERROR "wrong type for method m" */ .(T2)
 	_ = t /* STRICT "wrong type for method m" */ .(I2) // only an error in strict mode (issue 8561)
 
diff --git a/src/cmd/compile/internal/types2/testdata/check/issues.src b/src/cmd/compile/internal/types2/testdata/check/issues.src
index dfd51006b9..f4b6199b82 100644
--- a/src/cmd/compile/internal/types2/testdata/check/issues.src
+++ b/src/cmd/compile/internal/types2/testdata/check/issues.src
@@ -132,7 +132,7 @@ func issue10260() {
 
 	var x I1
 	x = T1 /* ERROR cannot use .*: missing method foo \(foo has pointer receiver\) */ {}
-	_ = x. /* ERROR impossible type assertion: x.\(T1\)\n\tT1 does not implement I1 \(foo method has pointer receiver\) */ (T1)
+	_ = x. /* ERROR impossible type assertion: x.\(T1\)\n\tT1 does not implement I1 \(method foo has pointer receiver\) */ (T1)
 
 	T1{}.foo /* ERROR cannot call pointer method foo on T1 */ ()
 	x.Foo /* ERROR "x.Foo undefined \(type I1 has no field or method Foo, but does have foo\)" */ ()
diff --git a/src/cmd/compile/internal/types2/testdata/check/stmt0.src b/src/cmd/compile/internal/types2/testdata/check/stmt0.src
index 5ec37b4ace..d744f2ba81 100644
--- a/src/cmd/compile/internal/types2/testdata/check/stmt0.src
+++ b/src/cmd/compile/internal/types2/testdata/check/stmt0.src
@@ -715,7 +715,7 @@ func typeswitches() {
 	var t I
 	switch t.(type) {
 	case T:
-	case T1 /* ERROR "missing m method" */ :
+	case T1 /* ERROR "missing method m" */ :
 	case T2 /* ERROR "wrong type for method m" */ :
 	case I2 /* STRICT "wrong type for method m" */ : // only an error in strict mode (issue 8561)
 	}
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49005.go b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49005.go
index 6225e68488..f152e7f55c 100644
--- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49005.go
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49005.go
@@ -23,12 +23,12 @@ type T2 interface{ M() }
 
 func F2() T2
 
-var _ = F2(). /* ERROR impossible type assertion: F2\(\).\(\*X2\)\n\t\*X2 does not implement T2 \(missing M method\) */ (*X2)
+var _ = F2(). /* ERROR impossible type assertion: F2\(\).\(\*X2\)\n\t\*X2 does not implement T2 \(missing method M\) */ (*X2)
 
 type X2 struct{}
 
 func _() {
 	switch F2().(type) {
-	case * /* ERROR impossible type switch case: \*X2\n\tF2\(\) \(value of type T2\) cannot have dynamic type \*X2 \(missing M method\) */ X2:
+	case * /* ERROR impossible type switch case: \*X2\n\tF2\(\) \(value of type T2\) cannot have dynamic type \*X2 \(missing method M\) */ X2:
 	}
 }
diff --git a/test/alias2.go b/test/alias2.go
index d7b5dccb68..61c7551f79 100644
--- a/test/alias2.go
+++ b/test/alias2.go
@@ -46,8 +46,8 @@ var _ A0 = T0{}
 var _ T0 = A0{}
 
 // But aliases and original types cannot be used with new types based on them.
-var _ N0 = T0{} // ERROR "cannot use T0{} \(type T0\) as type N0 in assignment|incompatible type"
-var _ N0 = A0{} // ERROR "cannot use T0{} \(type T0\) as type N0 in assignment|incompatible type"
+var _ N0 = T0{} // ERROR "cannot use T0{} \(type T0\) as type N0 in assignment|cannot use T0{} \(value of type T0\) as type N0 in variable declaration"
+var _ N0 = A0{} // ERROR "cannot use T0{} \(type T0\) as type N0 in assignment|cannot use A0{} \(value of type T0\) as type N0 in variable declaration"
 
 var _ A5 = Value{}
 
@@ -82,10 +82,10 @@ func _() {
 	var _ A0 = T0{}
 	var _ T0 = A0{}
 
-	var _ N0 = T0{} // ERROR "cannot use T0{} \(type T0\) as type N0 in assignment|incompatible type"
-	var _ N0 = A0{} // ERROR "cannot use T0{} \(type T0\) as type N0 in assignment|incompatible type"
+	var _ N0 = T0{} // ERROR "cannot use T0{} \(type T0\) as type N0 in assignment|cannot use T0{} \(value of type T0\) as type N0 in variable declaration"
+	var _ N0 = A0{} // ERROR "cannot use T0{} \(type T0\) as type N0 in assignment|cannot use A0{} \(value of type T0\) as type N0 in variable declaration"
 
-	var _ A5 = Value{} // ERROR "cannot use reflect\.Value{} \(type reflect.Value\) as type A5 in assignment|incompatible type"
+	var _ A5 = Value{} // ERROR "cannot use reflect\.Value{} \(type reflect.Value\) as type A5 in assignment|cannot use Value{} \(value of type reflect.Value\) as type A5 in variable declaration"
 }
 
 // Invalid type alias declarations.
diff --git a/test/append1.go b/test/append1.go
index 9dab120b25..397be570d9 100644
--- a/test/append1.go
+++ b/test/append1.go
@@ -17,6 +17,6 @@ func main() {
 	_ = append(s...)       // ERROR "cannot use ... on first argument|not enough arguments in call to append"
 	_ = append(s, 2, s...) // ERROR "too many arguments to append|too many arguments in call to append"
 
-	_ = append(s, make([]int, 0))     // ERROR "cannot use make.* as type int in append|cannot use make.* as int value"
+	_ = append(s, make([]int, 0))     // ERROR "cannot use make.* as type int in append|cannot use make.* \(value of type \[\]int\) as type int in argument to append"
 	_ = append(s, make([]int, -1)...) // ERROR "negative len argument in make|index -1.* must not be negative"
 }
diff --git a/test/ddd1.go b/test/ddd1.go
index f7381b7c94..639b0bfdbd 100644
--- a/test/ddd1.go
+++ b/test/ddd1.go
@@ -19,7 +19,7 @@ var (
 	_ = sum(1.0, 2.0)
 	_ = sum(1.5)      // ERROR "1\.5 .untyped float constant. as int|integer"
 	_ = sum("hello")  // ERROR ".hello. (.untyped string constant. as int|.type untyped string. as type int)|incompatible"
-	_ = sum([]int{1}) // ERROR "\[\]int{...}.*as type int|incompatible"
+	_ = sum([]int{1}) // ERROR "\[\]int{.*}.*as type int"
 )
 
 func sum3(int, int, int) int { return 0 }
diff --git a/test/fixedbugs/bug389.go b/test/fixedbugs/bug389.go
index 167e64e72c..209be8e6f7 100644
--- a/test/fixedbugs/bug389.go
+++ b/test/fixedbugs/bug389.go
@@ -9,4 +9,4 @@ package foo
 
 func fn(a float32) {}
 
-var f func(arg int) = fn  // ERROR "cannot use fn .type func.float32.. as type func.int. in assignment|different parameter types|incompatible type"
+var f func(arg int) = fn // ERROR "cannot use fn .type func.float32.. as type func.int. in assignment|different parameter types|cannot use fn .*type func.*float32.. as type func.*int. in variable declaration"
diff --git a/test/fixedbugs/issue41247.go b/test/fixedbugs/issue41247.go
index c5e495ba93..05889a9ce8 100644
--- 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\)|incompatible type"
+	return [...]int{2: 0} // ERROR "cannot use \[\.\.\.\]int{.*} \(.*type \[3\]int\)"
 }
diff --git a/test/fixedbugs/issue48471.go b/test/fixedbugs/issue48471.go
new file mode 100644
index 0000000000..0412d23b99
--- /dev/null
+++ b/test/fixedbugs/issue48471.go
@@ -0,0 +1,41 @@
+// 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
+
+type I interface{ M(int) }
+
+type T struct{}
+
+type T2 struct{}
+
+func (*T2) m(int)
+
+type T3 struct{}
+
+func (*T3) M(string) {}
+
+type T4 struct{}
+
+func (*T4) M(int)
+
+func f(I)
+
+func g() {
+	f(new(T)) // ERROR "cannot use new\(T\) \(.*type \*T\) as type I in argument to f:\n\t\*T does not implement I \(missing M method\)"
+	var i I
+	i = new(T)    // ERROR "cannot use new\(T\) \(.*type \*T\) as type I in assignment:\n\t\*T does not implement I \(missing M method\)"
+	i = I(new(T)) // ERROR "cannot convert new\(T\) \(.*type \*T\) to type I:\n\t\*T does not implement I \(missing M method\)"
+	i = new(T2)   // ERROR "cannot use new\(T2\) \(.*type \*T2\) as type I in assignment:\n\t\*T2 does not implement I \(missing M method\)"
+	i = new(T3)   // ERROR "cannot use new\(T3\) \(.*type \*T3\) as type I in assignment:\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\)\n\t\twant M\(int\)"
+	i = T4{}      // ERROR "cannot use T4\{\} \(.*type T4\) as type I in assignment:\n\tT4 does not implement I \(M method has pointer receiver\)"
+	i = new(I)    // ERROR "cannot use new\(I\) \(.*type \*I\) as type I in assignment:\n\t\*I does not implement I \(\*I is pointer to interface, not interface\)"
+	_ = i.(*T2)   // ERROR "impossible type assertion: i.\(\*T2\)\n\t\*T2 does not implement I \(missing M method\)"
+	_ = i.(*T3)   // ERROR "impossible type assertion: i.\(\*T3\)\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\)\n\t\twant M\(int\)"
+	var t *T4
+	t = i // ERROR "cannot use i \(variable of type I\) as type \*T4 in assignment:\n\tneed type assertion"
+	_ = i
+}
diff --git a/test/fixedbugs/issue6572.go b/test/fixedbugs/issue6572.go
index 9f4d2de0e3..d69bf5aee2 100644
--- a/test/fixedbugs/issue6572.go
+++ b/test/fixedbugs/issue6572.go
@@ -17,6 +17,6 @@ func bar() (T, string, T) { // ERROR "undefined"
 func main() {
 	var x, y, z int
 	x, y = foo()
-	x, y, z = bar() // ERROR "cannot (use type|assign) string|incompatible type"
+	x, y, z = bar() // ERROR "cannot (use type|assign|use.*type) string|"
 	_, _, _ = x, y, z
 }
diff --git a/test/fixedbugs/issue9521.go b/test/fixedbugs/issue9521.go
index 1ad40bdfda..a029ec145e 100644
--- 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|incompatible type"
-	_ = append(g()) // ERROR "cannot use float64 value as type int in append|incompatible type"
+	_ = append(f()) // ERROR "cannot use \[\]int value as type int in append|cannot use.*type \[\]int.*to append"
+	_ = append(g()) // ERROR "cannot use float64 value as type int in append|cannot use.*type float64.*to append"
 }
diff --git a/test/interface/explicit.go b/test/interface/explicit.go
index f769f5878c..e18d6843ec 100644
--- a/test/interface/explicit.go
+++ b/test/interface/explicit.go
@@ -38,7 +38,7 @@ var e E
 
 func main() {
 	e = t // ok
-	t = e // ERROR "need explicit|need type assertion|incompatible type"
+	t = e // ERROR "need explicit|need type assertion"
 
 	// neither of these can work,
 	// because i has an extra method
diff --git a/test/run.go b/test/run.go
index 942fd032f2..ad64304ec8 100644
--- a/test/run.go
+++ b/test/run.go
@@ -2125,14 +2125,11 @@ var types2Failures = setOf(
 	"shift1.go",       // issue #42989
 	"typecheck.go",    // invalid function is not causing errors when called
 
-	"interface/private.go", // types2 phrases errors differently (doesn't use non-spec "private" term)
-
 	"fixedbugs/bug176.go", // types2 reports all errors (pref: types2)
 	"fixedbugs/bug195.go", // types2 reports slightly different (but correct) bugs
 	"fixedbugs/bug228.go", // types2 doesn't run when there are syntax errors
 	"fixedbugs/bug231.go", // types2 bug? (same error reported twice)
 	"fixedbugs/bug255.go", // types2 reports extra errors
-	"fixedbugs/bug374.go", // types2 reports extra errors
 	"fixedbugs/bug388.go", // types2 not run due to syntax errors
 	"fixedbugs/bug412.go", // types2 produces a follow-on error
 

From 429d1e01557f95bba29837f2190441696484fd41 Mon Sep 17 00:00:00 2001
From: Dan Scales 
Date: Thu, 11 Nov 2021 10:28:17 -0800
Subject: [PATCH 135/752] cmd/compile: add missing method info for method with
 correct name except for case

When being used by the compiler, augment the types2 missing method
message with extra info, if a method is missing, but a method with the
correct name except for case (i.e. equal via string.EqualFold()) is
present. In that case, print out the wanted method and the method that
is present (that has the wrong case).

In the 1.17 compiler, we don't do this case-folding check when assigning
an interface to an interface, so I didn't add that check, but we could
add that.

Fixes #48471

Change-Id: Ic54549c1f66297c9221d979d49c1daa719aa66cd
Reviewed-on: https://go-review.googlesource.com/c/go/+/363437
Trust: Dan Scales 
Run-TryBot: Dan Scales 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/cmd/compile/internal/types2/lookup.go | 48 ++++++++++++++++++-----
 test/fixedbugs/issue48471.go              |  4 +-
 2 files changed, 40 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index a05a5d6397..8ed5ca837a 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -52,7 +52,7 @@ func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 	// not have found it for T (see also issue 8590).
 	if t := asNamed(T); t != nil {
 		if p, _ := safeUnderlying(t).(*Pointer); p != nil {
-			obj, index, indirect = lookupFieldOrMethod(p, false, pkg, name)
+			obj, index, indirect = lookupFieldOrMethod(p, false, false, pkg, name)
 			if _, ok := obj.(*Func); ok {
 				return nil, nil, false
 			}
@@ -60,7 +60,7 @@ func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 		}
 	}
 
-	return lookupFieldOrMethod(T, addressable, pkg, name)
+	return lookupFieldOrMethod(T, addressable, false, pkg, name)
 }
 
 // TODO(gri) The named type consolidation and seen maps below must be
@@ -69,7 +69,9 @@ func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 //           indirectly via different packages.)
 
 // lookupFieldOrMethod should only be called by LookupFieldOrMethod and missingMethod.
-func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) {
+// If checkFold is true, the lookup for methods will include looking for any method
+// which case-folds to the same as 'name' (used for giving helpful error messages).
+func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name string) (obj Object, index []int, indirect bool) {
 	// WARNING: The code in this function is extremely subtle - do not modify casually!
 
 	if name == "_" {
@@ -127,7 +129,7 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 				seen[named] = true
 
 				// look for a matching attached method
-				if i, m := lookupMethod(named.methods, pkg, name); m != nil {
+				if i, m := lookupMethodFold(named.methods, pkg, name, checkFold); m != nil {
 					// potential match
 					// caution: method may not have a proper signature yet
 					index = concat(e.index, i)
@@ -178,7 +180,7 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 
 			case *Interface:
 				// look for a matching method
-				if i, m := t.typeSet().LookupMethod(pkg, name); m != nil {
+				if i, m := lookupMethodFold(t.typeSet().methods, pkg, name, checkFold); m != nil {
 					assert(m.typ != nil)
 					index = concat(e.index, i)
 					if obj != nil || e.multiples {
@@ -189,7 +191,7 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 				}
 
 			case *TypeParam:
-				if i, m := t.iface().typeSet().LookupMethod(pkg, name); m != nil {
+				if i, m := lookupMethodFold(t.iface().typeSet().methods, pkg, name, checkFold); m != nil {
 					assert(m.typ != nil)
 					index = concat(e.index, i)
 					if obj != nil || e.multiples {
@@ -315,6 +317,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 				if !static {
 					continue
 				}
+				// We don't do any case-fold check if V is an interface.
 				return m, f
 			}
 
@@ -345,13 +348,20 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 
 	// A concrete type implements T if it implements all methods of T.
 	for _, m := range T.typeSet().methods {
-		// TODO(gri) should this be calling lookupFieldOrMethod instead (and why not)?
-		obj, _, _ := lookupFieldOrMethod(V, false, m.pkg, m.name)
+		// TODO(gri) should this be calling LookupFieldOrMethod instead (and why not)?
+		obj, _, _ := lookupFieldOrMethod(V, false, false, m.pkg, m.name)
 
 		// Check if *V implements this method of T.
 		if obj == nil {
 			ptr := NewPointer(V)
-			obj, _, _ = lookupFieldOrMethod(ptr, false, m.pkg, m.name)
+			obj, _, _ = lookupFieldOrMethod(ptr, false, false, m.pkg, m.name)
+			if obj != nil {
+				return m, obj.(*Func)
+			}
+			// If we didn't find the exact method (even with pointer
+			// receiver), look to see if there is a method that
+			// matches m.name with case-folding.
+			obj, _, _ := lookupFieldOrMethod(V, false, true, m.pkg, m.name)
 			if obj != nil {
 				return m, obj.(*Func)
 			}
@@ -410,7 +420,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 // where m is missing from V, but required by T. It puts the reason in parentheses,
 // and may include more have/want info after that. If non-nil, wrongType is a relevant
 // method that matches in some way. It may have the correct name, but wrong type, or
-// it may have a pointer receiver.
+// it may have a pointer receiver, or it may have the correct name except wrong case.
 func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string {
 	var r string
 	var mname string
@@ -527,3 +537,21 @@ func lookupMethod(methods []*Func, pkg *Package, name string) (int, *Func) {
 	}
 	return -1, nil
 }
+
+// lookupMethodFold is like lookupMethod, but if checkFold is true, it matches a method
+// name if the names are equal with case folding.
+func lookupMethodFold(methods []*Func, pkg *Package, name string, checkFold bool) (int, *Func) {
+	if name != "_" {
+		for i, m := range methods {
+			if m.name != name && !(checkFold && strings.EqualFold(m.name, name)) {
+				continue
+			}
+			// Use m.name, since we've already checked that m.name and
+			// name are equal with folding.
+			if m.sameId(pkg, m.name) {
+				return i, m
+			}
+		}
+	}
+	return -1, nil
+}
diff --git a/test/fixedbugs/issue48471.go b/test/fixedbugs/issue48471.go
index 0412d23b99..2e00c87c6a 100644
--- a/test/fixedbugs/issue48471.go
+++ b/test/fixedbugs/issue48471.go
@@ -29,11 +29,11 @@ func g() {
 	var i I
 	i = new(T)    // ERROR "cannot use new\(T\) \(.*type \*T\) as type I in assignment:\n\t\*T does not implement I \(missing M method\)"
 	i = I(new(T)) // ERROR "cannot convert new\(T\) \(.*type \*T\) to type I:\n\t\*T does not implement I \(missing M method\)"
-	i = new(T2)   // ERROR "cannot use new\(T2\) \(.*type \*T2\) as type I in assignment:\n\t\*T2 does not implement I \(missing M method\)"
+	i = new(T2)   // ERROR "cannot use new\(T2\) \(.*type \*T2\) as type I in assignment:\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\)\n\t\twant M\(int\)"
 	i = new(T3)   // ERROR "cannot use new\(T3\) \(.*type \*T3\) as type I in assignment:\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\)\n\t\twant M\(int\)"
 	i = T4{}      // ERROR "cannot use T4\{\} \(.*type T4\) as type I in assignment:\n\tT4 does not implement I \(M method has pointer receiver\)"
 	i = new(I)    // ERROR "cannot use new\(I\) \(.*type \*I\) as type I in assignment:\n\t\*I does not implement I \(\*I is pointer to interface, not interface\)"
-	_ = i.(*T2)   // ERROR "impossible type assertion: i.\(\*T2\)\n\t\*T2 does not implement I \(missing M method\)"
+	_ = i.(*T2)   // ERROR "impossible type assertion: i.\(\*T2\)\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\)\n\t\twant M\(int\)"
 	_ = i.(*T3)   // ERROR "impossible type assertion: i.\(\*T3\)\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\)\n\t\twant M\(int\)"
 	var t *T4
 	t = i // ERROR "cannot use i \(variable of type I\) as type \*T4 in assignment:\n\tneed type assertion"

From 3a4b95073a9fd7bca6e9fd80016275ef04bc1987 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Fri, 12 Nov 2021 13:23:45 -0800
Subject: [PATCH 136/752] cmd/compile/internal/types2: make sure we are safe
 for nil in underIs

Reviewed all uses of underIs (global function and method) and made
sure we are ok with a nil incoming argument (indicating a type set
with no specific types).

Added a couple of checks where we didn't have them (and somehow
didn't run into a problem yet).

Change-Id: Ifde45a3a80ddf2b1a19c83f79258ad8207dfb09f
Reviewed-on: https://go-review.googlesource.com/c/go/+/363658
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/expr.go       | 3 +++
 src/cmd/compile/internal/types2/predicates.go | 4 +++-
 src/cmd/compile/internal/types2/type.go       | 3 +++
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index f86606375c..77e497b9cc 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -740,6 +740,9 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 	case *TypeParam:
 		// TODO(gri) review this code - doesn't look quite right
 		ok := u.underIs(func(t Type) bool {
+			if t == nil {
+				return false
+			}
 			target, _, _ := check.implicitTypeAndValue(x, t)
 			return target != nil
 		})
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index 5cb1c33814..ab490372fc 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -147,7 +147,9 @@ func hasNil(t Type) bool {
 	case *Slice, *Pointer, *Signature, *Interface, *Map, *Chan:
 		return true
 	case *TypeParam:
-		return u.underIs(hasNil)
+		return u.underIs(func(u Type) bool {
+			return u != nil && hasNil(u)
+		})
 	}
 	return false
 }
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 24d44442e9..ba260d2b7d 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -65,6 +65,9 @@ func match(x, y Type) Type {
 func structuralType(typ Type) Type {
 	var su Type
 	if underIs(typ, func(u Type) bool {
+		if u == nil {
+			return false
+		}
 		if su != nil {
 			u = match(su, u)
 			if u == nil {

From fdee1b297438a64c553ecc7468a7647f5a070404 Mon Sep 17 00:00:00 2001
From: Michael Matloob 
Date: Thu, 28 Oct 2021 16:28:32 -0400
Subject: [PATCH 137/752] cmd/go: add go work use command

For #45713, #48257

Change-Id: I7e9248f22fe7ab33b151e07cc296d64c194154e2
Reviewed-on: https://go-review.googlesource.com/c/go/+/359534
Trust: Michael Matloob 
Run-TryBot: Michael Matloob 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
---
 src/cmd/go/alldocs.go                   |  13 +++
 src/cmd/go/internal/workcmd/use.go      | 129 ++++++++++++++++++++++++
 src/cmd/go/internal/workcmd/work.go     |   1 +
 src/cmd/go/testdata/script/work_use.txt |  32 ++++++
 4 files changed, 175 insertions(+)
 create mode 100644 src/cmd/go/internal/workcmd/use.go
 create mode 100644 src/cmd/go/testdata/script/work_use.txt

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index dfb88ab78d..a53ff7c66d 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1388,6 +1388,7 @@
 // 	edit        edit go.work from tools or scripts
 // 	init        initialize workspace file
 // 	sync        sync workspace build list to modules
+// 	use         add modules to workspace file
 //
 // Use "go help work " for more information about a command.
 //
@@ -1488,6 +1489,18 @@
 // go work sync
 //
 //
+// Add modules to workspace file
+//
+// Usage:
+//
+// 	go work use [-r] [moddirs]
+//
+// Use provides a command-line interface for adding directories,
+// optionally recursively, to a go.work file.
+//
+// The -r flag searches recursively for modules in the argument directories.
+//
+//
 // Compile and run Go program
 //
 // Usage:
diff --git a/src/cmd/go/internal/workcmd/use.go b/src/cmd/go/internal/workcmd/use.go
new file mode 100644
index 0000000000..10c25da396
--- /dev/null
+++ b/src/cmd/go/internal/workcmd/use.go
@@ -0,0 +1,129 @@
+// 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.
+
+// go work use
+
+package workcmd
+
+import (
+	"cmd/go/internal/base"
+	"cmd/go/internal/fsys"
+	"cmd/go/internal/lockedfile"
+	"cmd/go/internal/modload"
+	"context"
+	"io/fs"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"golang.org/x/mod/modfile"
+)
+
+var _ = modload.TODOWorkspaces("Add more documentation below. Though this is" +
+	"enough for those trying workspaces out, there should be more through" +
+	"documentation if the proposal is accepted and released.")
+
+var cmdUse = &base.Command{
+	UsageLine: "go work use [-r] [moddirs]",
+	Short:     "add modules to workspace file",
+	Long: `Use provides a command-line interface for adding directories,
+optionally recursively, to a go.work file.
+
+The -r flag searches recursively for modules in the argument directories.`,
+}
+
+var useR = cmdUse.Flag.Bool("r", false, "")
+
+func init() {
+	cmdUse.Run = runUse // break init cycle
+
+	base.AddModCommonFlags(&cmdUse.Flag)
+	base.AddWorkfileFlag(&cmdUse.Flag)
+}
+
+func runUse(ctx context.Context, cmd *base.Command, args []string) {
+	modload.InitWorkfile()
+
+	modload.ForceUseModules = true
+
+	var gowork string
+	modload.InitWorkfile()
+	gowork = modload.WorkFilePath()
+
+	data, err := lockedfile.Read(gowork)
+	if err != nil {
+		base.Fatalf("goX: %v", err)
+	}
+
+	workFile, err := modfile.ParseWork(gowork, data, nil)
+	if err != nil {
+		base.Fatalf("go: errors parsing %s:\n%s", base.ShortPath(gowork), err)
+	}
+
+	haveDirs := make(map[string]bool)
+	for _, dir := range workFile.Directory {
+		haveDirs[filepath.Join(filepath.Dir(gowork), filepath.FromSlash(dir.Path))] = true
+	}
+
+	addDirs := make(map[string]bool)
+	removeDirs := make(map[string]bool)
+	lookDir := func(dir string) {
+		absDir := filepath.Join(base.Cwd(), dir)
+		// If the path is absolute, keep it absolute. If it's relative,
+		// make it relative to the go.work file rather than the working directory.
+		if !filepath.IsAbs(dir) {
+			rel, err := filepath.Rel(filepath.Dir(gowork), absDir)
+			if err == nil {
+				dir = rel
+			}
+		}
+		fi, err := os.Stat(filepath.Join(dir, "go.mod"))
+		if err != nil {
+			if os.IsNotExist(err) {
+
+				if haveDirs[absDir] {
+					removeDirs[dir] = true
+				}
+				return
+			}
+			base.Errorf("go: %v", err)
+		}
+
+		if !fi.Mode().IsRegular() {
+			base.Errorf("go: %v is not regular", filepath.Join(dir, "go.mod"))
+		}
+
+		if !haveDirs[absDir] {
+			addDirs[dir] = true
+		}
+	}
+
+	for _, useDir := range args {
+		if *useR {
+			fsys.Walk(useDir, func(path string, info fs.FileInfo, err error) error {
+				if !info.IsDir() {
+					return nil
+				}
+				lookDir(path)
+				return nil
+			})
+			continue
+		}
+		lookDir(useDir)
+	}
+
+	for dir := range removeDirs {
+		workFile.DropDirectory(filepath.ToSlash(dir))
+	}
+	for dir := range addDirs {
+		workFile.AddDirectory(filepath.ToSlash(dir), "")
+	}
+	workFile.SortBlocks()
+	workFile.Cleanup() // clean file after edits
+	out := modfile.Format(workFile.Syntax)
+
+	if err := ioutil.WriteFile(gowork, out, 0666); err != nil {
+		base.Fatalf("go: %v", err)
+	}
+}
diff --git a/src/cmd/go/internal/workcmd/work.go b/src/cmd/go/internal/workcmd/work.go
index dc1164fb77..98d5a01de6 100644
--- a/src/cmd/go/internal/workcmd/work.go
+++ b/src/cmd/go/internal/workcmd/work.go
@@ -25,5 +25,6 @@ which workspaces are a part.
 		cmdEdit,
 		cmdInit,
 		cmdSync,
+		cmdUse,
 	},
 }
diff --git a/src/cmd/go/testdata/script/work_use.txt b/src/cmd/go/testdata/script/work_use.txt
new file mode 100644
index 0000000000..dddce0fe22
--- /dev/null
+++ b/src/cmd/go/testdata/script/work_use.txt
@@ -0,0 +1,32 @@
+go work use -r foo
+cmp go.work go.want_work_r
+
+go work use other
+cmp go.work go.want_work_other
+-- go.work --
+go 1.18
+
+directory (
+	foo
+	foo/bar // doesn't exist
+)
+-- go.want_work_r --
+go 1.18
+
+directory (
+	foo
+	foo/bar/baz
+)
+-- go.want_work_other --
+go 1.18
+
+directory (
+	foo
+	foo/bar/baz
+	other
+)
+-- foo/go.mod --
+module foo
+-- foo/bar/baz/go.mod --
+module baz
+-- other/go.mod --

From b69b2f63d65609b400b4a40ae01e4a48638f050f Mon Sep 17 00:00:00 2001
From: Damien Neil 
Date: Wed, 27 Oct 2021 14:03:24 -0700
Subject: [PATCH 138/752] net/http: do not send Transfer-Encoding: identity in
 responses

Server handlers may set a "Transfer-Encoding: identity" header on
responses to disable chunking, but this header should not be sent
on the wire.

Fixes #49194.

Change-Id: I46a9e3b8ff9d93edd7d1c34d264fc309fa322ad5
Reviewed-on: https://go-review.googlesource.com/c/go/+/359176
Trust: Damien Neil 
Run-TryBot: Damien Neil 
TryBot-Result: Go Bot 
Reviewed-by: Brad Fitzpatrick 
---
 src/net/http/clientserver_test.go | 34 +++++++++++++++++++++++++++++++
 src/net/http/server.go            |  7 ++++---
 2 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/src/net/http/clientserver_test.go b/src/net/http/clientserver_test.go
index 5e227181ac..125d63566b 100644
--- a/src/net/http/clientserver_test.go
+++ b/src/net/http/clientserver_test.go
@@ -1582,3 +1582,37 @@ func TestH12_WebSocketUpgrade(t *testing.T) {
 		},
 	}.run(t)
 }
+
+func TestIdentityTransferEncoding_h1(t *testing.T) { testIdentityTransferEncoding(t, h1Mode) }
+func TestIdentityTransferEncoding_h2(t *testing.T) { testIdentityTransferEncoding(t, h2Mode) }
+
+func testIdentityTransferEncoding(t *testing.T, h2 bool) {
+	setParallel(t)
+	defer afterTest(t)
+
+	const body = "body"
+	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
+		gotBody, _ := io.ReadAll(r.Body)
+		if got, want := string(gotBody), body; got != want {
+			t.Errorf("got request body = %q; want %q", got, want)
+		}
+		w.Header().Set("Transfer-Encoding", "identity")
+		w.WriteHeader(StatusOK)
+		w.(Flusher).Flush()
+		io.WriteString(w, body)
+	}))
+	defer cst.close()
+	req, _ := NewRequest("GET", cst.ts.URL, strings.NewReader(body))
+	res, err := cst.c.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer res.Body.Close()
+	gotBody, err := io.ReadAll(res.Body)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got, want := string(gotBody), body; got != want {
+		t.Errorf("got response body = %q; want %q", got, want)
+	}
+}
diff --git a/src/net/http/server.go b/src/net/http/server.go
index c4a2d57dd4..f0b0e86e91 100644
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -1426,11 +1426,11 @@ func (cw *chunkWriter) writeHeader(p []byte) {
 		hasCL = false
 	}
 
-	if w.req.Method == "HEAD" || !bodyAllowedForStatus(code) {
-		// do nothing
-	} else if code == StatusNoContent {
+	if w.req.Method == "HEAD" || !bodyAllowedForStatus(code) || code == StatusNoContent {
+		// Response has no body.
 		delHeader("Transfer-Encoding")
 	} else if hasCL {
+		// Content-Length has been provided, so no chunking is to be done.
 		delHeader("Transfer-Encoding")
 	} else if w.req.ProtoAtLeast(1, 1) {
 		// HTTP/1.1 or greater: Transfer-Encoding has been set to identity, and no
@@ -1441,6 +1441,7 @@ func (cw *chunkWriter) writeHeader(p []byte) {
 		if hasTE && te == "identity" {
 			cw.chunking = false
 			w.closeAfterReply = true
+			delHeader("Transfer-Encoding")
 		} else {
 			// HTTP/1.1 or greater: use chunked transfer encoding
 			// to avoid closing the connection at EOF.

From 39bc666430b3340c3de0e815cfc1fbfc7b2f7e99 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 26 Oct 2021 10:06:55 -0700
Subject: [PATCH 139/752] cmd/compile/internal/types2: underlying type of a
 type parameter is its constraint interface

Until now, the type checker operated with the definition that the
underlying type of a type parameter is itself. This leads to some
inconcistencies and caused us to disallow type declarations where
the RHS is a stand-alone type parameter.

This change implements an alernative definition: the underlying
type of a type parameter is the underlying type of its constraint;
i.e., the underlying type of a type parameter is always an interface
(because constraints must be interfaces). This matches the theory
closely and also resolves some inconsistencies. For example, we
don't need to prohibit stand-alone type parameters on the RHS of
a type declaration (though, for the sake of keeping the tests the
same, we still do in this CL). We also get a clear understanding of
what it would mean to use a type assertion or type switch on a type
parameter (still disabled with this CL). Finally, the declaration
of a type parameter now very closely matches the definition of an
ordinary type.

The main consequence is that the rules for assignment need to be
slightly modified: even though a type parameter is an interface,
we cannot simply assign to it per the rules for interfaces: the
type parameter's type is fixed for the instantiation and we need
to reflect that accordingly when checking for assignability.

This CL does not enable the new mode, it implements it in parallel
to the existing mode; the internal flag tparamIsIface is used to
switch between the modes.

The changes to the code are numerous, but straight-forward: when-
ever we deal with an underlying type that might be a type parameter
(or newly, an interface), we need to act slightly differently. For
the time being this leads to some code duplication because the code
supports both modes.

While some of the code for the new mode seems more complicated
(e.g., when we have an interface, the code checks that it is not
the underlying type of a type parameter), in reality many of the
extra checks are redundant and only present because of an abundance
of caution: interfaces with specific type sets are not permitted as
types for ordinary variables, and so even if we were to hit those
cases w/o excluding type parameters the behavior would be the same.

Runs all tests with tparamIsIface enabled and disabled.
Current setting: disabled.

Change-Id: I7bb6453f4fe2569d92face222058fb4e17b12f25
Reviewed-on: https://go-review.googlesource.com/c/go/+/359016
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 .../compile/internal/types2/assignments.go    |  2 +-
 src/cmd/compile/internal/types2/builtins.go   | 30 ++++++-
 src/cmd/compile/internal/types2/call.go       |  2 +-
 .../compile/internal/types2/conversions.go    | 16 ++--
 src/cmd/compile/internal/types2/expr.go       | 30 ++++++-
 src/cmd/compile/internal/types2/index.go      | 86 +++++++++++++++++++
 src/cmd/compile/internal/types2/lookup.go     |  6 +-
 src/cmd/compile/internal/types2/operand.go    |  9 +-
 src/cmd/compile/internal/types2/predicates.go | 27 ++++--
 src/cmd/compile/internal/types2/sizes.go      |  1 +
 src/cmd/compile/internal/types2/struct.go     |  9 +-
 src/cmd/compile/internal/types2/type.go       |  9 +-
 src/cmd/compile/internal/types2/typeparam.go  | 23 ++++-
 src/cmd/compile/internal/types2/typeset.go    |  4 +
 src/cmd/compile/internal/types2/typexpr.go    | 11 ++-
 15 files changed, 226 insertions(+), 39 deletions(-)

diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index da7f7dfa5c..a3d32093d6 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -43,7 +43,7 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 				x.mode = invalid
 				return
 			}
-		} else if T == nil || IsInterface(T) {
+		} else if T == nil || IsInterface(T) && !isTypeParam(T) {
 			target = Default(x.typ)
 		}
 		newType, val, code := check.implicitTypeAndValue(x, target)
diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index 99fe440340..c4b897e80f 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -178,7 +178,28 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 				mode = value
 			}
 
+		case *Interface:
+			if tparamIsIface && isTypeParam(x.typ) {
+				if t.typeSet().underIs(func(t Type) bool {
+					switch t := arrayPtrDeref(t).(type) {
+					case *Basic:
+						if isString(t) && id == _Len {
+							return true
+						}
+					case *Array, *Slice, *Chan:
+						return true
+					case *Map:
+						if id == _Len {
+							return true
+						}
+					}
+					return false
+				}) {
+					mode = value
+				}
+			}
 		case *TypeParam:
+			assert(!tparamIsIface)
 			if t.underIs(func(t Type) bool {
 				switch t := arrayPtrDeref(t).(type) {
 				case *Basic:
@@ -788,16 +809,19 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 
 // hasVarSize reports if the size of type t is variable due to type parameters.
 func hasVarSize(t Type) bool {
-	switch t := under(t).(type) {
+	switch u := under(t).(type) {
 	case *Array:
-		return hasVarSize(t.elem)
+		return hasVarSize(u.elem)
 	case *Struct:
-		for _, f := range t.fields {
+		for _, f := range u.fields {
 			if hasVarSize(f.typ) {
 				return true
 			}
 		}
+	case *Interface:
+		return isTypeParam(t)
 	case *TypeParam:
+		assert(!tparamIsIface)
 		return true
 	case *Named, *Union:
 		unreachable()
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index b778d54b32..fef493b2ae 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -132,7 +132,7 @@ func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind {
 		case 1:
 			check.expr(x, call.ArgList[0])
 			if x.mode != invalid {
-				if t, _ := under(T).(*Interface); t != nil {
+				if t, _ := under(T).(*Interface); t != nil && !isTypeParam(T) {
 					if !t.IsMethodSet() {
 						check.errorf(call, "cannot use interface %s in conversion (contains specific type constraints or is comparable)", T)
 						break
diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index cc7b52099c..47f9ac0a5a 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -102,7 +102,7 @@ func (check *Checker) conversion(x *operand, T Type) {
 		//   (See also the TODO below.)
 		if x.typ == Typ[UntypedNil] {
 			// ok
-		} else if IsInterface(T) || constArg && !isConstType(T) {
+		} else if IsInterface(T) && !isTypeParam(T) || constArg && !isConstType(T) {
 			final = Default(x.typ)
 		} else if isInteger(x.typ) && allString(T) {
 			final = x.typ
@@ -133,19 +133,23 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 		return true
 	}
 
-	// "V and T have identical underlying types if tags are ignored"
+	// "V and T have identical underlying types if tags are ignored
+	// and V and T are not type parameters"
 	V := x.typ
 	Vu := under(V)
 	Tu := under(T)
-	if IdenticalIgnoreTags(Vu, Tu) {
+	Vp, _ := V.(*TypeParam)
+	Tp, _ := T.(*TypeParam)
+	if IdenticalIgnoreTags(Vu, Tu) && Vp == nil && Tp == nil {
 		return true
 	}
 
 	// "V and T are unnamed pointer types and their pointer base types
-	// have identical underlying types if tags are ignored"
+	// have identical underlying types if tags are ignored
+	// and their pointer base types are not type parameters"
 	if V, ok := V.(*Pointer); ok {
 		if T, ok := T.(*Pointer); ok {
-			if IdenticalIgnoreTags(under(V.base), under(T.base)) {
+			if IdenticalIgnoreTags(under(V.base), under(T.base)) && !isTypeParam(V.base) && !isTypeParam(T.base) {
 				return true
 			}
 		}
@@ -204,8 +208,6 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 	}
 
 	// optimization: if we don't have type parameters, we're done
-	Vp, _ := V.(*TypeParam)
-	Tp, _ := T.(*TypeParam)
 	if Vp == nil && Tp == nil {
 		return false
 	}
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 77e497b9cc..d72ee8c340 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -658,7 +658,11 @@ func (check *Checker) updateExprVal(x syntax.Expr, val constant.Value) {
 func (check *Checker) convertUntyped(x *operand, target Type) {
 	newType, val, code := check.implicitTypeAndValue(x, target)
 	if code != 0 {
-		check.invalidConversion(code, x, safeUnderlying(target))
+		t := target
+		if !tparamIsIface || !isTypeParam(target) {
+			t = safeUnderlying(target)
+		}
+		check.invalidConversion(code, x, t)
 		x.mode = invalid
 		return
 	}
@@ -739,6 +743,7 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 		}
 	case *TypeParam:
 		// TODO(gri) review this code - doesn't look quite right
+		assert(!tparamIsIface)
 		ok := u.underIs(func(t Type) bool {
 			if t == nil {
 				return false
@@ -750,6 +755,20 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 			return nil, nil, _InvalidUntypedConversion
 		}
 	case *Interface:
+		if tparamIsIface && isTypeParam(target) {
+			// TODO(gri) review this code - doesn't look quite right
+			ok := u.typeSet().underIs(func(t Type) bool {
+				if t == nil {
+					return false
+				}
+				target, _, _ := check.implicitTypeAndValue(x, t)
+				return target != nil
+			})
+			if !ok {
+				return nil, nil, _InvalidUntypedConversion
+			}
+			break
+		}
 		// Update operand types to the default type rather than the target
 		// (interface) type: values must have concrete dynamic types.
 		// Untyped nil was handled upfront.
@@ -989,8 +1008,9 @@ func (check *Checker) binary(x *operand, e syntax.Expr, lhs, rhs syntax.Expr, op
 		return
 	}
 
+	// TODO(gri) make canMix more efficient - called for each binary operation
 	canMix := func(x, y *operand) bool {
-		if IsInterface(x.typ) || IsInterface(y.typ) {
+		if IsInterface(x.typ) && !isTypeParam(x.typ) || IsInterface(y.typ) && !isTypeParam(y.typ) {
 			return true
 		}
 		if allBoolean(x.typ) != allBoolean(y.typ) {
@@ -1248,7 +1268,11 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
 		case hint != nil:
 			// no composite literal type present - use hint (element type of enclosing type)
 			typ = hint
-			base, _ = deref(under(typ)) // *T implies &T{}
+			base = typ
+			if !isTypeParam(typ) {
+				base = under(typ)
+			}
+			base, _ = deref(base) // *T implies &T{}
 
 		default:
 			// TODO(gri) provide better error messages depending on context
diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index 10fb57c321..97d153dfe4 100644
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -99,8 +99,94 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
 		x.expr = e
 		return false
 
+	case *Interface:
+		// Note: The body of this 'if' statement is the same as the body
+		//       of the case for type parameters below. If we keep both
+		//       these branches we should factor out the code.
+		if tparamIsIface && isTypeParam(x.typ) {
+			// TODO(gri) report detailed failure cause for better error messages
+			var key, elem Type // key != nil: we must have all maps
+			mode := variable   // non-maps result mode
+			// TODO(gri) factor out closure and use it for non-typeparam cases as well
+			if typ.typeSet().underIs(func(u Type) bool {
+				l := int64(-1) // valid if >= 0
+				var k, e Type  // k is only set for maps
+				switch t := u.(type) {
+				case *Basic:
+					if isString(t) {
+						e = universeByte
+						mode = value
+					}
+				case *Array:
+					l = t.len
+					e = t.elem
+					if x.mode != variable {
+						mode = value
+					}
+				case *Pointer:
+					if t, _ := under(t.base).(*Array); t != nil {
+						l = t.len
+						e = t.elem
+					}
+				case *Slice:
+					e = t.elem
+				case *Map:
+					k = t.key
+					e = t.elem
+				}
+				if e == nil {
+					return false
+				}
+				if elem == nil {
+					// first type
+					length = l
+					key, elem = k, e
+					return true
+				}
+				// all map keys must be identical (incl. all nil)
+				// (that is, we cannot mix maps with other types)
+				if !Identical(key, k) {
+					return false
+				}
+				// all element types must be identical
+				if !Identical(elem, e) {
+					return false
+				}
+				// track the minimal length for arrays, if any
+				if l >= 0 && l < length {
+					length = l
+				}
+				return true
+			}) {
+				// For maps, the index expression must be assignable to the map key type.
+				if key != nil {
+					index := check.singleIndex(e)
+					if index == nil {
+						x.mode = invalid
+						return false
+					}
+					var k operand
+					check.expr(&k, index)
+					check.assignment(&k, key, "map index")
+					// ok to continue even if indexing failed - map element type is known
+					x.mode = mapindex
+					x.typ = elem
+					x.expr = e
+					return false
+				}
+
+				// no maps
+				valid = true
+				x.mode = mode
+				x.typ = elem
+			}
+		}
 	case *TypeParam:
+		// Note: The body of this case is the same as the body of the 'if'
+		//       statement in the interface case above. If we keep both
+		//       these branches we should factor out the code.
 		// TODO(gri) report detailed failure cause for better error messages
+		assert(!tparamIsIface)
 		var key, elem Type // key != nil: we must have all maps
 		mode := variable   // non-maps result mode
 		// TODO(gri) factor out closure and use it for non-typeparam cases as well
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index 8ed5ca837a..cf6c6c7111 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -451,11 +451,11 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string
 		// an extra formatting option for types2.Type that doesn't print out
 		// 'func'.
 		r = strings.Replace(r, "^^func", "", -1)
-	} else if IsInterface(T) {
+	} else if IsInterface(T) && !isTypeParam(T) {
 		if isInterfacePtr(V) {
 			r = fmt.Sprintf("(%s is pointer to interface, not interface)", V)
 		}
-	} else if isInterfacePtr(T) {
+	} else if isInterfacePtr(T) && !isTypeParam(T) {
 		r = fmt.Sprintf("(%s is pointer to interface, not interface)", T)
 	}
 	if r == "" {
@@ -466,7 +466,7 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string
 
 func isInterfacePtr(T Type) bool {
 	p, _ := under(T).(*Pointer)
-	return p != nil && IsInterface(p.base)
+	return p != nil && IsInterface(p.base) && !isTypeParam(p.base)
 }
 
 // assertableTo reports whether a value of type V can be asserted to have type T.
diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index fee154a6bb..8a905f3fd0 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -282,13 +282,14 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 	// Vu is typed
 
 	// x's type V and T have identical underlying types
-	// and at least one of V or T is not a named type.
-	if Identical(Vu, Tu) && (!hasName(V) || !hasName(T)) {
+	// and at least one of V or T is not a named type
+	// and neither V nor T is a type parameter.
+	if Identical(Vu, Tu) && (!hasName(V) || !hasName(T)) && Vp == nil && Tp == nil {
 		return true, 0
 	}
 
 	// T is an interface type and x implements T and T is not a type parameter
-	if Ti, ok := Tu.(*Interface); ok {
+	if Ti, ok := Tu.(*Interface); ok && Tp == nil {
 		if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* !Implements(V, Ti) */ {
 			if reason != nil {
 				if check.conf.CompilerErrorMessages {
@@ -318,7 +319,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 			*reason = check.sprintf("%s does not implement %s (%s is pointer to interface, not interface)", x.typ, T, T)
 			return false, _InvalidIfaceAssign
 		}
-		if Vi, _ := Vu.(*Interface); Vi != nil {
+		if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil {
 			if m, _ := check.missingMethod(T, Vi, true); m == nil {
 				// T implements Vi, so give hint about type assertion.
 				if reason != nil {
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index ab490372fc..62db3861ed 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -47,13 +47,10 @@ func allNumericOrString(t Type) bool { return allBasic(t, IsNumeric|IsString) }
 // for all specific types of the type parameter's type set.
 // allBasic(t, info) is an optimized version of isBasic(structuralType(t), info).
 func allBasic(t Type, info BasicInfo) bool {
-	switch u := under(t).(type) {
-	case *Basic:
-		return u.info&info != 0
-	case *TypeParam:
-		return u.is(func(t *term) bool { return t != nil && isBasic(t.typ, info) })
+	if tpar, _ := t.(*TypeParam); tpar != nil {
+		return tpar.is(func(t *term) bool { return t != nil && isBasic(t.typ, info) })
 	}
-	return false
+	return isBasic(t, info)
 }
 
 // hasName reports whether t has a name. This includes
@@ -122,7 +119,7 @@ func comparable(T Type, seen map[Type]bool) bool {
 		// assume invalid types to be comparable
 		// to avoid follow-up errors
 		return t.kind != UntypedNil
-	case *Pointer, *Interface, *Chan:
+	case *Pointer, *Chan:
 		return true
 	case *Struct:
 		for _, f := range t.fields {
@@ -133,7 +130,13 @@ func comparable(T Type, seen map[Type]bool) bool {
 		return true
 	case *Array:
 		return comparable(t.elem, seen)
+	case *Interface:
+		if tparamIsIface && isTypeParam(T) {
+			return t.IsComparable()
+		}
+		return true
 	case *TypeParam:
+		assert(!tparamIsIface)
 		return t.iface().IsComparable()
 	}
 	return false
@@ -144,9 +147,17 @@ func hasNil(t Type) bool {
 	switch u := under(t).(type) {
 	case *Basic:
 		return u.kind == UnsafePointer
-	case *Slice, *Pointer, *Signature, *Interface, *Map, *Chan:
+	case *Slice, *Pointer, *Signature, *Map, *Chan:
+		return true
+	case *Interface:
+		if tparamIsIface && isTypeParam(t) {
+			return u.typeSet().underIs(func(u Type) bool {
+				return u != nil && hasNil(u)
+			})
+		}
 		return true
 	case *TypeParam:
+		assert(!tparamIsIface)
 		return u.underIs(func(u Type) bool {
 			return u != nil && hasNil(u)
 		})
diff --git a/src/cmd/compile/internal/types2/sizes.go b/src/cmd/compile/internal/types2/sizes.go
index 609b6f585e..b23cec435d 100644
--- a/src/cmd/compile/internal/types2/sizes.go
+++ b/src/cmd/compile/internal/types2/sizes.go
@@ -67,6 +67,7 @@ func (s *StdSizes) Alignof(T Type) int64 {
 	case *Slice, *Interface:
 		// Multiword data structures are effectively structs
 		// in which each element has size WordSize.
+		assert(!tparamIsIface || !isTypeParam(T))
 		return s.WordSize
 	case *Basic:
 		// Strings are like slices and interfaces.
diff --git a/src/cmd/compile/internal/types2/struct.go b/src/cmd/compile/internal/types2/struct.go
index 8c39f5e3c4..3e271039d1 100644
--- a/src/cmd/compile/internal/types2/struct.go
+++ b/src/cmd/compile/internal/types2/struct.go
@@ -144,21 +144,26 @@ func (check *Checker) structType(styp *Struct, e *syntax.StructType) {
 			embeddedPos := pos
 			check.later(func() {
 				t, isPtr := deref(embeddedTyp)
-				switch t := under(t).(type) {
+				switch u := under(t).(type) {
 				case *Basic:
 					if t == Typ[Invalid] {
 						// error was reported before
 						return
 					}
 					// unsafe.Pointer is treated like a regular pointer
-					if t.kind == UnsafePointer {
+					if u.kind == UnsafePointer {
 						check.error(embeddedPos, "embedded field type cannot be unsafe.Pointer")
 					}
 				case *Pointer:
 					check.error(embeddedPos, "embedded field type cannot be a pointer")
 				case *TypeParam:
+					assert(!tparamIsIface)
 					check.error(embeddedPos, "embedded field type cannot be a (pointer to a) type parameter")
 				case *Interface:
+					if tparamIsIface && isTypeParam(t) {
+						check.error(embeddedPos, "embedded field type cannot be a (pointer to a) type parameter")
+						break
+					}
 					if isPtr {
 						check.error(embeddedPos, "embedded field type cannot be a pointer to an interface")
 					}
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index ba260d2b7d..77dc7db896 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -21,8 +21,13 @@ type Type interface {
 // under must only be called when a type is known
 // to be fully set up.
 func under(t Type) Type {
-	if n := asNamed(t); n != nil {
-		return n.under()
+	switch t := t.(type) {
+	case *Named:
+		return t.under()
+	case *TypeParam:
+		if tparamIsIface {
+			return t.iface()
+		}
 	}
 	return t
 }
diff --git a/src/cmd/compile/internal/types2/typeparam.go b/src/cmd/compile/internal/types2/typeparam.go
index 099bc429c3..e430319476 100644
--- a/src/cmd/compile/internal/types2/typeparam.go
+++ b/src/cmd/compile/internal/types2/typeparam.go
@@ -6,6 +6,12 @@ package types2
 
 import "sync/atomic"
 
+// If set, the underlying type of a type parameter is
+// is the underlying type of its type constraint, i.e.,
+// an interface. With that, a type parameter satisfies
+// isInterface.
+const tparamIsIface = false
+
 // Note: This is a uint32 rather than a uint64 because the
 // respective 64 bit atomic instructions are not available
 // on all platforms.
@@ -69,13 +75,21 @@ func (t *TypeParam) SetConstraint(bound Type) {
 	t.bound = bound
 }
 
-func (t *TypeParam) Underlying() Type { return t }
-func (t *TypeParam) String() string   { return TypeString(t, nil) }
+func (t *TypeParam) Underlying() Type {
+	if tparamIsIface {
+		return t.iface()
+	}
+	return t
+}
+
+func (t *TypeParam) String() string { return TypeString(t, nil) }
 
 // ----------------------------------------------------------------------------
 // Implementation
 
 // iface returns the constraint interface of t.
+// TODO(gri) If we make tparamIsIface the default, this should be renamed to under
+//           (similar to Named.under).
 func (t *TypeParam) iface() *Interface {
 	bound := t.bound
 
@@ -88,8 +102,13 @@ func (t *TypeParam) iface() *Interface {
 			return &emptyInterface
 		}
 	case *Interface:
+		if tparamIsIface && isTypeParam(bound) {
+			// error is reported in Checker.collectTypeParams
+			return &emptyInterface
+		}
 		ityp = u
 	case *TypeParam:
+		assert(!tparamIsIface)
 		// error is reported in Checker.collectTypeParams
 		return &emptyInterface
 	}
diff --git a/src/cmd/compile/internal/types2/typeset.go b/src/cmd/compile/internal/types2/typeset.go
index 882f387c3c..54a8266838 100644
--- a/src/cmd/compile/internal/types2/typeset.go
+++ b/src/cmd/compile/internal/types2/typeset.go
@@ -268,6 +268,8 @@ func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *_
 		var terms termlist
 		switch u := under(typ).(type) {
 		case *Interface:
+			// For now we don't permit type parameters as constraints.
+			assert(!isTypeParam(typ))
 			tset := computeInterfaceTypeSet(check, pos, u)
 			// If typ is local, an error was already reported where typ is specified/defined.
 			if check != nil && check.isImportedConstraint(typ) && !check.allowVersion(check.pkg, 1, 18) {
@@ -367,6 +369,8 @@ func computeUnionTypeSet(check *Checker, pos syntax.Pos, utyp *Union) *_TypeSet
 		var terms termlist
 		switch u := under(t.typ).(type) {
 		case *Interface:
+			// For now we don't permit type parameters as constraints.
+			assert(!isTypeParam(t.typ))
 			terms = computeInterfaceTypeSet(check, pos, u).terms
 		default:
 			if t.typ == Typ[Invalid] {
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index a2585179ee..e22b1ff0a0 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -144,9 +144,14 @@ func (check *Checker) typ(e syntax.Expr) Type {
 func (check *Checker) varType(e syntax.Expr) Type {
 	typ := check.definedType(e, nil)
 
-	// We don't want to call under() (via toInterface) or complete interfaces while we
-	// are in the middle of type-checking parameter declarations that might belong to
-	// interface methods. Delay this check to the end of type-checking.
+	// If we have a type parameter there's nothing to do.
+	if isTypeParam(typ) {
+		return typ
+	}
+
+	// We don't want to call under() or complete interfaces while we are in
+	// the middle of type-checking parameter declarations that might belong
+	// to interface methods. Delay this check to the end of type-checking.
 	check.later(func() {
 		if t, _ := under(typ).(*Interface); t != nil {
 			pos := syntax.StartPos(e)

From c09d854f0961a997ac41a740a6e8d1892b7e6ee0 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Wed, 10 Nov 2021 15:50:35 -0800
Subject: [PATCH 140/752] cmd/compile/internal/types2: set tparamsIsIface to
 true

This CL enables the mode in which the underlying type of
type parameters is the underlying type of their constraints.

Change-Id: Id3471578dab098695dbd1e0429356ebcc9c5e224
Reviewed-on: https://go-review.googlesource.com/c/go/+/363155
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/typeparam.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/compile/internal/types2/typeparam.go b/src/cmd/compile/internal/types2/typeparam.go
index e430319476..5499d975a1 100644
--- a/src/cmd/compile/internal/types2/typeparam.go
+++ b/src/cmd/compile/internal/types2/typeparam.go
@@ -10,7 +10,7 @@ import "sync/atomic"
 // is the underlying type of its type constraint, i.e.,
 // an interface. With that, a type parameter satisfies
 // isInterface.
-const tparamIsIface = false
+const tparamIsIface = true
 
 // Note: This is a uint32 rather than a uint64 because the
 // respective 64 bit atomic instructions are not available

From 56e55a388986ed9c770a21e9c58df38e021b577b Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Thu, 11 Nov 2021 17:32:15 -0800
Subject: [PATCH 141/752] cmd/compile/internal/types2: remove a review comment
 in implicitTypeAndValue

Reviewed the code and simplified slightly. No semantic changes.

Change-Id: Ib785b912fbee97746324af87ac0c14a4bdb69477
Reviewed-on: https://go-review.googlesource.com/c/go/+/363440
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/expr.go | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index d72ee8c340..6faa54475b 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -742,29 +742,25 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 			return nil, nil, _InvalidUntypedConversion
 		}
 	case *TypeParam:
-		// TODO(gri) review this code - doesn't look quite right
 		assert(!tparamIsIface)
-		ok := u.underIs(func(t Type) bool {
-			if t == nil {
+		if !u.underIs(func(u Type) bool {
+			if u == nil {
 				return false
 			}
-			target, _, _ := check.implicitTypeAndValue(x, t)
-			return target != nil
-		})
-		if !ok {
+			t, _, _ := check.implicitTypeAndValue(x, u)
+			return t != nil
+		}) {
 			return nil, nil, _InvalidUntypedConversion
 		}
 	case *Interface:
 		if tparamIsIface && isTypeParam(target) {
-			// TODO(gri) review this code - doesn't look quite right
-			ok := u.typeSet().underIs(func(t Type) bool {
-				if t == nil {
+			if !u.typeSet().underIs(func(u Type) bool {
+				if u == nil {
 					return false
 				}
-				target, _, _ := check.implicitTypeAndValue(x, t)
-				return target != nil
-			})
-			if !ok {
+				t, _, _ := check.implicitTypeAndValue(x, u)
+				return t != nil
+			}) {
 				return nil, nil, _InvalidUntypedConversion
 			}
 			break

From bc0b98eeffa64f155e7f2a2dc6b883a97c4d0580 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Thu, 11 Nov 2021 22:21:48 -0800
Subject: [PATCH 142/752] cmd/compile/internal/types2: remove asNamed

In the few remaining places where we use asNamed, if the argument
is indeed a *Named, we either don't need to look "inside" it, or
we call under() (which calls Named.underlying() which does resolve);
so there's no need for an implicit resolution (which was done by
asNamed). The only place where we do need to resolve is in lookup,
so added the explicit resolve call in that case.

Change-Id: Iff0a19fde7581e94149e89b9e48157c1981db105
Reviewed-on: https://go-review.googlesource.com/c/go/+/363441
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/decl.go     |  2 +-
 src/cmd/compile/internal/types2/lookup.go   |  7 ++++---
 src/cmd/compile/internal/types2/type.go     |  9 ---------
 src/cmd/compile/internal/types2/unify.go    | 14 ++++++--------
 src/cmd/compile/internal/types2/universe.go |  2 +-
 5 files changed, 12 insertions(+), 22 deletions(-)

diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index bab90fbd9a..d58fac5dbb 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -727,7 +727,7 @@ func (check *Checker) collectMethods(obj *TypeName) {
 
 	// spec: "If the base type is a struct type, the non-blank method
 	// and field names must be distinct."
-	base := asNamed(obj.typ) // shouldn't fail but be conservative
+	base, _ := obj.typ.(*Named) // shouldn't fail but be conservative
 	if base != nil {
 		u := base.under()
 		if t, _ := u.(*Struct); t != nil {
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index cf6c6c7111..fbfe3c81ff 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -50,8 +50,8 @@ func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 	// Thus, if we have a named pointer type, proceed with the underlying
 	// pointer type but discard the result if it is a method since we would
 	// not have found it for T (see also issue 8590).
-	if t := asNamed(T); t != nil {
-		if p, _ := safeUnderlying(t).(*Pointer); p != nil {
+	if t, _ := T.(*Named); t != nil {
+		if p, _ := t.Underlying().(*Pointer); p != nil {
 			obj, index, indirect = lookupFieldOrMethod(p, false, false, pkg, name)
 			if _, ok := obj.(*Func); ok {
 				return nil, nil, false
@@ -114,7 +114,7 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name
 
 			// If we have a named type, we may have associated methods.
 			// Look for those first.
-			if named := asNamed(typ); named != nil {
+			if named, _ := typ.(*Named); named != nil {
 				if seen[named] {
 					// We have seen this type before, at a more shallow depth
 					// (note that multiples of this type at the current depth
@@ -129,6 +129,7 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name
 				seen[named] = true
 
 				// look for a matching attached method
+				named.resolve(nil)
 				if i, m := lookupMethodFold(named.methods, pkg, name, checkFold); m != nil {
 					// potential match
 					// caution: method may not have a proper signature yet
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 77dc7db896..3fea8d1776 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -87,12 +87,3 @@ func structuralType(typ Type) Type {
 	}
 	return nil
 }
-
-// If t is a defined type, asNamed returns that type (possibly after resolving it), otherwise it returns nil.
-func asNamed(t Type) *Named {
-	e, _ := t.(*Named)
-	if e != nil {
-		e.resolve(nil)
-	}
-	return e
-}
diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go
index 7f636c30d3..ccb6ee8709 100644
--- a/src/cmd/compile/internal/types2/unify.go
+++ b/src/cmd/compile/internal/types2/unify.go
@@ -235,14 +235,12 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool {
 		// If exact unification is known to fail because we attempt to
 		// match a type name against an unnamed type literal, consider
 		// the underlying type of the named type.
-		// (Subtle: We use hasName to include any type with a name (incl.
-		// basic types and type parameters. We use asNamed because we only
-		// want *Named types.)
-		switch {
-		case !hasName(x) && y != nil && asNamed(y) != nil:
-			return u.nify(x, under(y), p)
-		case x != nil && asNamed(x) != nil && !hasName(y):
-			return u.nify(under(x), y, p)
+		// (We use !hasName to exclude any type with a name, including
+		// basic types and type parameters; the rest are unamed types.)
+		if nx, _ := x.(*Named); nx != nil && !hasName(y) {
+			return u.nify(nx.under(), y, p)
+		} else if ny, _ := y.(*Named); ny != nil && !hasName(x) {
+			return u.nify(x, ny.under(), p)
 		}
 	}
 
diff --git a/src/cmd/compile/internal/types2/universe.go b/src/cmd/compile/internal/types2/universe.go
index 92fa32524c..fccab145f8 100644
--- a/src/cmd/compile/internal/types2/universe.go
+++ b/src/cmd/compile/internal/types2/universe.go
@@ -240,7 +240,7 @@ func def(obj Object) {
 		return // nothing to do
 	}
 	// fix Obj link for named types
-	if typ := asNamed(obj.Type()); typ != nil {
+	if typ, _ := obj.Type().(*Named); typ != nil {
 		typ.obj = obj.(*TypeName)
 	}
 	// exported identifiers go into package unsafe

From 787708a6ff66092678cd4312358e90a5085eac89 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Fri, 12 Nov 2021 08:59:49 -0800
Subject: [PATCH 143/752] cmd/compile/internal/types2: remove tparamIsIface
 flag and corresponding dead code

Added/clarified some comments.

Change-Id: Ib08d3343ff08c23cc8880a27a0148d1ff077a80f
Reviewed-on: https://go-review.googlesource.com/c/go/+/363654
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/builtins.go   | 27 +-----
 src/cmd/compile/internal/types2/decl.go       |  4 +
 src/cmd/compile/internal/types2/expr.go       | 15 +---
 src/cmd/compile/internal/types2/index.go      | 89 +------------------
 src/cmd/compile/internal/types2/predicates.go | 18 +---
 src/cmd/compile/internal/types2/sizes.go      |  7 +-
 src/cmd/compile/internal/types2/struct.go     |  5 +-
 src/cmd/compile/internal/types2/type.go       |  4 +-
 src/cmd/compile/internal/types2/typeparam.go  | 17 +---
 9 files changed, 24 insertions(+), 162 deletions(-)

diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index c4b897e80f..5b4ffd0dad 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -179,28 +179,10 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 			}
 
 		case *Interface:
-			if tparamIsIface && isTypeParam(x.typ) {
-				if t.typeSet().underIs(func(t Type) bool {
-					switch t := arrayPtrDeref(t).(type) {
-					case *Basic:
-						if isString(t) && id == _Len {
-							return true
-						}
-					case *Array, *Slice, *Chan:
-						return true
-					case *Map:
-						if id == _Len {
-							return true
-						}
-					}
-					return false
-				}) {
-					mode = value
-				}
+			if !isTypeParam(x.typ) {
+				break
 			}
-		case *TypeParam:
-			assert(!tparamIsIface)
-			if t.underIs(func(t Type) bool {
+			if t.typeSet().underIs(func(t Type) bool {
 				switch t := arrayPtrDeref(t).(type) {
 				case *Basic:
 					if isString(t) && id == _Len {
@@ -820,9 +802,6 @@ func hasVarSize(t Type) bool {
 		}
 	case *Interface:
 		return isTypeParam(t)
-	case *TypeParam:
-		assert(!tparamIsIface)
-		return true
 	case *Named, *Union:
 		unreachable()
 	}
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index d58fac5dbb..739fc163de 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -673,6 +673,10 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list []*syntax.Fiel
 	check.later(func() {
 		for i, bound := range bounds {
 			if isTypeParam(bound) {
+				// We may be able to allow this since it is now well-defined what
+				// the underlying type and thus type set of a type parameter is.
+				// But we may need some additional form of cycle detection within
+				// type parameter lists.
 				check.error(posers[i], "cannot use a type parameter as constraint")
 			}
 		}
diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 6faa54475b..b700716b0c 100644
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -659,7 +659,7 @@ func (check *Checker) convertUntyped(x *operand, target Type) {
 	newType, val, code := check.implicitTypeAndValue(x, target)
 	if code != 0 {
 		t := target
-		if !tparamIsIface || !isTypeParam(target) {
+		if !isTypeParam(target) {
 			t = safeUnderlying(target)
 		}
 		check.invalidConversion(code, x, t)
@@ -741,19 +741,8 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 		default:
 			return nil, nil, _InvalidUntypedConversion
 		}
-	case *TypeParam:
-		assert(!tparamIsIface)
-		if !u.underIs(func(u Type) bool {
-			if u == nil {
-				return false
-			}
-			t, _, _ := check.implicitTypeAndValue(x, u)
-			return t != nil
-		}) {
-			return nil, nil, _InvalidUntypedConversion
-		}
 	case *Interface:
-		if tparamIsIface && isTypeParam(target) {
+		if isTypeParam(target) {
 			if !u.typeSet().underIs(func(u Type) bool {
 				if u == nil {
 					return false
diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index 97d153dfe4..648c7abe6f 100644
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -100,97 +100,14 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
 		return false
 
 	case *Interface:
-		// Note: The body of this 'if' statement is the same as the body
-		//       of the case for type parameters below. If we keep both
-		//       these branches we should factor out the code.
-		if tparamIsIface && isTypeParam(x.typ) {
-			// TODO(gri) report detailed failure cause for better error messages
-			var key, elem Type // key != nil: we must have all maps
-			mode := variable   // non-maps result mode
-			// TODO(gri) factor out closure and use it for non-typeparam cases as well
-			if typ.typeSet().underIs(func(u Type) bool {
-				l := int64(-1) // valid if >= 0
-				var k, e Type  // k is only set for maps
-				switch t := u.(type) {
-				case *Basic:
-					if isString(t) {
-						e = universeByte
-						mode = value
-					}
-				case *Array:
-					l = t.len
-					e = t.elem
-					if x.mode != variable {
-						mode = value
-					}
-				case *Pointer:
-					if t, _ := under(t.base).(*Array); t != nil {
-						l = t.len
-						e = t.elem
-					}
-				case *Slice:
-					e = t.elem
-				case *Map:
-					k = t.key
-					e = t.elem
-				}
-				if e == nil {
-					return false
-				}
-				if elem == nil {
-					// first type
-					length = l
-					key, elem = k, e
-					return true
-				}
-				// all map keys must be identical (incl. all nil)
-				// (that is, we cannot mix maps with other types)
-				if !Identical(key, k) {
-					return false
-				}
-				// all element types must be identical
-				if !Identical(elem, e) {
-					return false
-				}
-				// track the minimal length for arrays, if any
-				if l >= 0 && l < length {
-					length = l
-				}
-				return true
-			}) {
-				// For maps, the index expression must be assignable to the map key type.
-				if key != nil {
-					index := check.singleIndex(e)
-					if index == nil {
-						x.mode = invalid
-						return false
-					}
-					var k operand
-					check.expr(&k, index)
-					check.assignment(&k, key, "map index")
-					// ok to continue even if indexing failed - map element type is known
-					x.mode = mapindex
-					x.typ = elem
-					x.expr = e
-					return false
-				}
-
-				// no maps
-				valid = true
-				x.mode = mode
-				x.typ = elem
-			}
+		if !isTypeParam(x.typ) {
+			break
 		}
-	case *TypeParam:
-		// Note: The body of this case is the same as the body of the 'if'
-		//       statement in the interface case above. If we keep both
-		//       these branches we should factor out the code.
 		// TODO(gri) report detailed failure cause for better error messages
-		assert(!tparamIsIface)
 		var key, elem Type // key != nil: we must have all maps
 		mode := variable   // non-maps result mode
 		// TODO(gri) factor out closure and use it for non-typeparam cases as well
-		if typ.underIs(func(u Type) bool {
+		if typ.typeSet().underIs(func(u Type) bool {
 			l := int64(-1) // valid if >= 0
 			var k, e Type  // k is only set for maps
 			switch t := u.(type) {
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index 62db3861ed..8ba534ce77 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -131,13 +131,7 @@ func comparable(T Type, seen map[Type]bool) bool {
 	case *Array:
 		return comparable(t.elem, seen)
 	case *Interface:
-		if tparamIsIface && isTypeParam(T) {
-			return t.IsComparable()
-		}
-		return true
-	case *TypeParam:
-		assert(!tparamIsIface)
-		return t.iface().IsComparable()
+		return !isTypeParam(T) || t.IsComparable()
 	}
 	return false
 }
@@ -150,15 +144,7 @@ func hasNil(t Type) bool {
 	case *Slice, *Pointer, *Signature, *Map, *Chan:
 		return true
 	case *Interface:
-		if tparamIsIface && isTypeParam(t) {
-			return u.typeSet().underIs(func(u Type) bool {
-				return u != nil && hasNil(u)
-			})
-		}
-		return true
-	case *TypeParam:
-		assert(!tparamIsIface)
-		return u.underIs(func(u Type) bool {
+		return !isTypeParam(t) || u.typeSet().underIs(func(u Type) bool {
 			return u != nil && hasNil(u)
 		})
 	}
diff --git a/src/cmd/compile/internal/types2/sizes.go b/src/cmd/compile/internal/types2/sizes.go
index b23cec435d..6f981964be 100644
--- a/src/cmd/compile/internal/types2/sizes.go
+++ b/src/cmd/compile/internal/types2/sizes.go
@@ -67,7 +67,9 @@ func (s *StdSizes) Alignof(T Type) int64 {
 	case *Slice, *Interface:
 		// Multiword data structures are effectively structs
 		// in which each element has size WordSize.
-		assert(!tparamIsIface || !isTypeParam(T))
+		// Type parameters lead to variable sizes/alignments;
+		// StdSizes.Alignof won't be called for them.
+		assert(!isTypeParam(T))
 		return s.WordSize
 	case *Basic:
 		// Strings are like slices and interfaces.
@@ -152,6 +154,9 @@ func (s *StdSizes) Sizeof(T Type) int64 {
 		offsets := s.Offsetsof(t.fields)
 		return offsets[n-1] + s.Sizeof(t.fields[n-1].typ)
 	case *Interface:
+		// Type parameters lead to variable sizes/alignments;
+		// StdSizes.Sizeof won't be called for them.
+		assert(!isTypeParam(T))
 		return s.WordSize * 2
 	case *TypeParam, *Union:
 		unreachable()
diff --git a/src/cmd/compile/internal/types2/struct.go b/src/cmd/compile/internal/types2/struct.go
index 3e271039d1..31a3b1af5b 100644
--- a/src/cmd/compile/internal/types2/struct.go
+++ b/src/cmd/compile/internal/types2/struct.go
@@ -156,11 +156,8 @@ func (check *Checker) structType(styp *Struct, e *syntax.StructType) {
 					}
 				case *Pointer:
 					check.error(embeddedPos, "embedded field type cannot be a pointer")
-				case *TypeParam:
-					assert(!tparamIsIface)
-					check.error(embeddedPos, "embedded field type cannot be a (pointer to a) type parameter")
 				case *Interface:
-					if tparamIsIface && isTypeParam(t) {
+					if isTypeParam(t) {
 						check.error(embeddedPos, "embedded field type cannot be a (pointer to a) type parameter")
 						break
 					}
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 3fea8d1776..7fcb196c5a 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -25,9 +25,7 @@ func under(t Type) Type {
 	case *Named:
 		return t.under()
 	case *TypeParam:
-		if tparamIsIface {
-			return t.iface()
-		}
+		return t.iface()
 	}
 	return t
 }
diff --git a/src/cmd/compile/internal/types2/typeparam.go b/src/cmd/compile/internal/types2/typeparam.go
index 5499d975a1..8dd04ff408 100644
--- a/src/cmd/compile/internal/types2/typeparam.go
+++ b/src/cmd/compile/internal/types2/typeparam.go
@@ -6,12 +6,6 @@ package types2
 
 import "sync/atomic"
 
-// If set, the underlying type of a type parameter is
-// is the underlying type of its type constraint, i.e.,
-// an interface. With that, a type parameter satisfies
-// isInterface.
-const tparamIsIface = true
-
 // Note: This is a uint32 rather than a uint64 because the
 // respective 64 bit atomic instructions are not available
 // on all platforms.
@@ -76,10 +70,7 @@ func (t *TypeParam) SetConstraint(bound Type) {
 }
 
 func (t *TypeParam) Underlying() Type {
-	if tparamIsIface {
-		return t.iface()
-	}
-	return t
+	return t.iface()
 }
 
 func (t *TypeParam) String() string { return TypeString(t, nil) }
@@ -102,15 +93,11 @@ func (t *TypeParam) iface() *Interface {
 			return &emptyInterface
 		}
 	case *Interface:
-		if tparamIsIface && isTypeParam(bound) {
+		if isTypeParam(bound) {
 			// error is reported in Checker.collectTypeParams
 			return &emptyInterface
 		}
 		ityp = u
-	case *TypeParam:
-		assert(!tparamIsIface)
-		// error is reported in Checker.collectTypeParams
-		return &emptyInterface
 	}
 
 	// If we don't have an interface, wrap constraint into an implicit interface.

From bfbe5ac9ce58fb59aa38ef69dee4933f20aac039 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Tue, 9 Nov 2021 22:31:59 -0500
Subject: [PATCH 144/752] go/types: deduplicate signatures with the context

Extend the type checking context to allow de-duplicating *Signature
instances, in addition to *Named instances.

Naively we would deduplicate instances of different-but-identical origin
*Signature types. That may be OK, but it seems a bit strange to get the
same signature when instantiating two different functions. For now,
differentiate *Signature types by prepending a unique identifier for the
origin pointer, thus guaranteeing that instances de-duplicated if they
come from the exact same (pointer identical) origin type.

Updates #47103

Change-Id: I93cc3cacad195267fe0a5801f9c5a3b1e61eb907
Reviewed-on: https://go-review.googlesource.com/c/go/+/362801
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/api_test.go         |  14 ++--
 src/go/types/context.go          |  39 +++++-----
 src/go/types/instantiate.go      |  43 ++++++-----
 src/go/types/instantiate_test.go | 118 ++++++++++++++++++++++++-------
 src/go/types/named.go            |   2 +-
 src/go/types/subst.go            |   2 +-
 src/go/types/typestring.go       |   2 +-
 src/go/types/typexpr.go          |   2 +-
 8 files changed, 150 insertions(+), 72 deletions(-)

diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index 3e10be5985..c9127f366a 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -28,8 +28,12 @@ import (
 // If source begins with "package generic_" and type parameters are enabled,
 // generic code is permitted.
 func pkgFor(path, source string, info *Info) (*Package, error) {
-	fset := token.NewFileSet()
 	mode := modeForSource(source)
+	return pkgForMode(path, source, info, mode)
+}
+
+func pkgForMode(path, source string, info *Info, mode parser.Mode) (*Package, error) {
+	fset := token.NewFileSet()
 	f, err := parser.ParseFile(fset, path, source, mode)
 	if err != nil {
 		return nil, err
@@ -1938,8 +1942,8 @@ func f(x T) T { return foo.F(x) }
 
 func TestInstantiate(t *testing.T) {
 	// eventually we like more tests but this is a start
-	const src = genericPkg + "p; type T[P any] *T[P]"
-	pkg, err := pkgFor(".", src, nil)
+	const src = "package p; type T[P any] *T[P]"
+	pkg, err := pkgForMode(".", src, nil, 0)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1976,8 +1980,8 @@ func TestInstantiateErrors(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		src := genericPkg + "p; " + test.src
-		pkg, err := pkgFor(".", src, nil)
+		src := "package p; " + test.src
+		pkg, err := pkgForMode(".", src, nil, 0)
 		if err != nil {
 			t.Fatal(err)
 		}
diff --git a/src/go/types/context.go b/src/go/types/context.go
index 1f102f0b8b..ff4bf89f3c 100644
--- a/src/go/types/context.go
+++ b/src/go/types/context.go
@@ -7,6 +7,7 @@ package types
 import (
 	"bytes"
 	"fmt"
+	"strconv"
 	"strings"
 	"sync"
 )
@@ -17,10 +18,10 @@ import (
 //
 // It is safe for concurrent use.
 type Context struct {
-	mu      sync.Mutex
-	typeMap map[string][]ctxtEntry // type hash -> instances entries
-	nextID  int                    // next unique ID
-	seen    map[*Named]int         // assigned unique IDs
+	mu        sync.Mutex
+	typeMap   map[string][]ctxtEntry // type hash -> instances entries
+	nextID    int                    // next unique ID
+	originIDs map[Type]int           // origin type -> unique ID
 }
 
 type ctxtEntry struct {
@@ -32,23 +33,25 @@ type ctxtEntry struct {
 // NewContext creates a new Context.
 func NewContext() *Context {
 	return &Context{
-		typeMap: make(map[string][]ctxtEntry),
-		seen:    make(map[*Named]int),
+		typeMap:   make(map[string][]ctxtEntry),
+		originIDs: make(map[Type]int),
 	}
 }
 
-// typeHash returns a string representation of typ instantiated with targs,
-// which can be used as an exact type hash: types that are identical produce
-// identical string representations. If targs is not empty, typ is printed as
-// if it were instantiated with targs. The result is guaranteed to not contain
-// blanks (" ").
-func (ctxt *Context) typeHash(typ Type, targs []Type) string {
+// instanceHash returns a string representation of typ instantiated with targs.
+// The hash should be a perfect hash, though out of caution the type checker
+// does not assume this. The result is guaranteed to not contain blanks.
+func (ctxt *Context) instanceHash(orig Type, targs []Type) string {
 	assert(ctxt != nil)
-	assert(typ != nil)
+	assert(orig != nil)
 	var buf bytes.Buffer
 
 	h := newTypeHasher(&buf, ctxt)
-	h.typ(typ)
+	h.string(strconv.Itoa(ctxt.getID(orig)))
+	// Because we've already written the unique origin ID this call to h.typ is
+	// unnecessary, but we leave it for hash readability. It can be removed later
+	// if performance is an issue.
+	h.typ(orig)
 	if len(targs) > 0 {
 		// TODO(rfindley): consider asserting on isGeneric(typ) here, if and when
 		// isGeneric handles *Signature types.
@@ -106,14 +109,14 @@ func (ctxt *Context) update(h string, orig Type, targs []Type, inst Type) Type {
 	return inst
 }
 
-// idForType returns a unique ID for the pointer n.
-func (ctxt *Context) idForType(n *Named) int {
+// getID returns a unique ID for the type t.
+func (ctxt *Context) getID(t Type) int {
 	ctxt.mu.Lock()
 	defer ctxt.mu.Unlock()
-	id, ok := ctxt.seen[n]
+	id, ok := ctxt.originIDs[t]
 	if !ok {
 		id = ctxt.nextID
-		ctxt.seen[n] = id
+		ctxt.originIDs[t] = id
 		ctxt.nextID++
 	}
 	return id
diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index 62d9e18401..ec646e1a5c 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -52,30 +52,26 @@ func Instantiate(ctxt *Context, typ Type, targs []Type, validate bool) (Type, er
 // instance creates a type or function instance using the given original type
 // typ and arguments targs. For Named types the resulting instance will be
 // unexpanded.
-func (check *Checker) instance(pos token.Pos, orig Type, targs []Type, ctxt *Context) Type {
+func (check *Checker) instance(pos token.Pos, orig Type, targs []Type, ctxt *Context) (res Type) {
+	var h string
+	if ctxt != nil {
+		h = ctxt.instanceHash(orig, targs)
+		// typ may already have been instantiated with identical type arguments. In
+		// that case, re-use the existing instance.
+		if inst := ctxt.lookup(h, orig, targs); inst != nil {
+			return inst
+		}
+	}
+
 	switch orig := orig.(type) {
 	case *Named:
-		var h string
-		if ctxt != nil {
-			h = ctxt.typeHash(orig, targs)
-			// typ may already have been instantiated with identical type arguments. In
-			// that case, re-use the existing instance.
-			if inst := ctxt.lookup(h, orig, targs); inst != nil {
-				return inst
-			}
-		}
 		tname := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil)
 		named := check.newNamed(tname, orig, nil, nil, nil) // underlying, tparams, and methods are set when named is resolved
 		named.targs = NewTypeList(targs)
 		named.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) {
 			return expandNamed(ctxt, n, pos)
 		}
-		if ctxt != nil {
-			// It's possible that we've lost a race to add named to the context.
-			// In this case, use whichever instance is recorded in the context.
-			named = ctxt.update(h, orig, targs, named).(*Named)
-		}
-		return named
+		res = named
 
 	case *Signature:
 		tparams := orig.TypeParams()
@@ -96,10 +92,19 @@ func (check *Checker) instance(pos token.Pos, orig Type, targs []Type, ctxt *Con
 		// After instantiating a generic signature, it is not generic
 		// anymore; we need to set tparams to nil.
 		sig.tparams = nil
-		return sig
+		res = sig
+	default:
+		// only types and functions can be generic
+		panic(fmt.Sprintf("%v: cannot instantiate %v", pos, orig))
 	}
-	// only types and functions can be generic
-	panic(fmt.Sprintf("%v: cannot instantiate %v", pos, orig))
+
+	if ctxt != nil {
+		// It's possible that we've lost a race to add named to the context.
+		// In this case, use whichever instance is recorded in the context.
+		res = ctxt.update(h, orig, targs, res)
+	}
+
+	return res
 }
 
 // validateTArgLen verifies that the length of targs and tparams matches,
diff --git a/src/go/types/instantiate_test.go b/src/go/types/instantiate_test.go
index 832c822224..a4ed581e35 100644
--- a/src/go/types/instantiate_test.go
+++ b/src/go/types/instantiate_test.go
@@ -11,40 +11,106 @@ import (
 )
 
 func TestInstantiateEquality(t *testing.T) {
-	const src = genericPkg + "p; type T[P any] int"
-
-	pkg, err := pkgFor(".", src, nil)
-	if err != nil {
-		t.Fatal(err)
+	tests := []struct {
+		src       string
+		name1     string
+		targs1    []Type
+		name2     string
+		targs2    []Type
+		wantEqual bool
+	}{
+		{
+			"package basictype; type T[P any] int",
+			"T", []Type{Typ[Int]},
+			"T", []Type{Typ[Int]},
+			true,
+		},
+		{
+			"package differenttypeargs; type T[P any] int",
+			"T", []Type{Typ[Int]},
+			"T", []Type{Typ[String]},
+			false,
+		},
+		{
+			"package typeslice; type T[P any] int",
+			"T", []Type{NewSlice(Typ[Int])},
+			"T", []Type{NewSlice(Typ[Int])},
+			true,
+		},
+		{
+			"package basicfunc; func F[P any]() {}",
+			"F", []Type{Typ[Int]},
+			"F", []Type{Typ[Int]},
+			true,
+		},
+		{
+			"package funcslice; func F[P any]() {}",
+			"F", []Type{NewSlice(Typ[Int])},
+			"F", []Type{NewSlice(Typ[Int])},
+			true,
+		},
+		{
+			"package funcwithparams; func F[P any](x string) float64 { return 0 }",
+			"F", []Type{Typ[Int]},
+			"F", []Type{Typ[Int]},
+			true,
+		},
+		{
+			"package differentfuncargs; func F[P any](x string) float64 { return 0 }",
+			"F", []Type{Typ[Int]},
+			"F", []Type{Typ[String]},
+			false,
+		},
+		{
+			"package funcequality; func F1[P any](x int) {}; func F2[Q any](x int) {}",
+			"F1", []Type{Typ[Int]},
+			"F2", []Type{Typ[Int]},
+			false,
+		},
+		{
+			"package funcsymmetry; func F1[P any](x P) {}; func F2[Q any](x Q) {}",
+			"F1", []Type{Typ[Int]},
+			"F2", []Type{Typ[Int]},
+			false,
+		},
 	}
 
-	T := pkg.Scope().Lookup("T").Type().(*Named)
+	for _, test := range tests {
+		pkg, err := pkgForMode(".", test.src, nil, 0)
+		if err != nil {
+			t.Fatal(err)
+		}
 
-	// Instantiating the same type twice should result in pointer-equivalent
-	// instances.
-	ctxt := NewContext()
-	res1, err := Instantiate(ctxt, T, []Type{Typ[Int]}, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	res2, err := Instantiate(ctxt, T, []Type{Typ[Int]}, false)
-	if err != nil {
-		t.Fatal(err)
-	}
+		t.Run(pkg.Name(), func(t *testing.T) {
+			ctxt := NewContext()
 
-	if res1 != res2 {
-		t.Errorf("first instance (%s) not pointer-equivalent to second instance (%s)", res1, res2)
+			T1 := pkg.Scope().Lookup(test.name1).Type()
+			res1, err := Instantiate(ctxt, T1, test.targs1, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			T2 := pkg.Scope().Lookup(test.name2).Type()
+			res2, err := Instantiate(ctxt, T2, test.targs2, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if gotEqual := res1 == res2; gotEqual != test.wantEqual {
+				t.Errorf("%s == %s: %t, want %t", res1, res2, gotEqual, test.wantEqual)
+			}
+		})
 	}
 }
 
 func TestInstantiateNonEquality(t *testing.T) {
-	const src = genericPkg + "p; type T[P any] int"
+	const src = "package p; type T[P any] int"
 
-	pkg1, err := pkgFor(".", src, nil)
+	pkg1, err := pkgForMode(".", src, nil, 0)
 	if err != nil {
 		t.Fatal(err)
 	}
-	pkg2, err := pkgFor(".", src, nil)
+	pkg2, err := pkgForMode(".", src, nil, 0)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -73,7 +139,7 @@ func TestInstantiateNonEquality(t *testing.T) {
 }
 
 func TestMethodInstantiation(t *testing.T) {
-	const prefix = genericPkg + `p
+	const prefix = `package p
 
 type T[P any] struct{}
 
@@ -95,7 +161,7 @@ var X T[int]
 
 	for _, test := range tests {
 		src := prefix + test.decl
-		pkg, err := pkgFor(".", src, nil)
+		pkg, err := pkgForMode(".", src, nil, 0)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -112,7 +178,7 @@ var X T[int]
 }
 
 func TestImmutableSignatures(t *testing.T) {
-	const src = genericPkg + `p
+	const src = `package p
 
 type T[P any] struct{}
 
@@ -120,7 +186,7 @@ func (T[P]) m() {}
 
 var _ T[int]
 `
-	pkg, err := pkgFor(".", src, nil)
+	pkg, err := pkgForMode(".", src, nil, 0)
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/src/go/types/named.go b/src/go/types/named.go
index ed3c426a12..06b6d4692b 100644
--- a/src/go/types/named.go
+++ b/src/go/types/named.go
@@ -253,7 +253,7 @@ func expandNamed(ctxt *Context, n *Named, instPos token.Pos) (tparams *TypeParam
 	if n.orig.tparams.Len() == n.targs.Len() {
 		// We must always have a context, to avoid infinite recursion.
 		ctxt = check.bestContext(ctxt)
-		h := ctxt.typeHash(n.orig, n.targs.list())
+		h := ctxt.instanceHash(n.orig, n.targs.list())
 		// ensure that an instance is recorded for h to avoid infinite recursion.
 		ctxt.update(h, n.orig, n.TypeArgs().list(), n)
 
diff --git a/src/go/types/subst.go b/src/go/types/subst.go
index 0e3eafdaf1..3ff81a06b6 100644
--- a/src/go/types/subst.go
+++ b/src/go/types/subst.go
@@ -207,7 +207,7 @@ func (subst *subster) typ(typ Type) Type {
 		}
 
 		// before creating a new named type, check if we have this one already
-		h := subst.ctxt.typeHash(t.orig, newTArgs)
+		h := subst.ctxt.instanceHash(t.orig, newTArgs)
 		dump(">>> new type hash: %s", h)
 		if named := subst.ctxt.lookup(h, t.orig, newTArgs); named != nil {
 			dump(">>> found %s", named)
diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index c448d25458..9192b0423b 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -291,7 +291,7 @@ func (w *typeWriter) typ(typ Type) {
 // nothing.
 func (w *typeWriter) typePrefix(t *Named) {
 	if w.ctxt != nil {
-		w.string(strconv.Itoa(w.ctxt.idForType(t)))
+		w.string(strconv.Itoa(w.ctxt.getID(t)))
 	}
 }
 
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 048bc95e15..09d1471985 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -409,7 +409,7 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 	}
 
 	// create the instance
-	h := check.conf.Context.typeHash(orig, targs)
+	h := check.conf.Context.instanceHash(orig, targs)
 	// targs may be incomplete, and require inference. In any case we should de-duplicate.
 	inst, _ := check.conf.Context.lookup(h, orig, targs).(*Named)
 	// If inst is non-nil, we can't just return here. Inst may have been

From c97d6817a3a47ce7ec30f1eebae48def30b64ad8 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 10 Nov 2021 15:53:16 -0500
Subject: [PATCH 145/752] go/types: when type hashing, use placeholders for
 type parameters

Type parameter names don't matter for the purposes of generic type
identity, so mask them with numeric placeholders when hashing.

Change-Id: Iacb4c23abecdd733fc292ae13ecac6baa2c5524c
Reviewed-on: https://go-review.googlesource.com/c/go/+/363114
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/typestring.go | 53 +++++++++++++++++++++++---------------
 1 file changed, 32 insertions(+), 21 deletions(-)

diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index 9192b0423b..cb41abd2ac 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -8,6 +8,7 @@ package types
 
 import (
 	"bytes"
+	"fmt"
 	"go/token"
 	"strconv"
 	"unicode/utf8"
@@ -71,20 +72,21 @@ func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier) {
 }
 
 type typeWriter struct {
-	buf   *bytes.Buffer
-	seen  map[Type]bool
-	qf    Qualifier
-	ctxt  *Context // if non-nil, we are type hashing
-	debug bool     // if true, write debug annotations
+	buf     *bytes.Buffer
+	seen    map[Type]bool
+	qf      Qualifier
+	ctxt    *Context       // if non-nil, we are type hashing
+	tparams *TypeParamList // local type parameters
+	debug   bool           // if true, write debug annotations
 }
 
 func newTypeWriter(buf *bytes.Buffer, qf Qualifier) *typeWriter {
-	return &typeWriter{buf, make(map[Type]bool), qf, nil, false}
+	return &typeWriter{buf, make(map[Type]bool), qf, nil, nil, false}
 }
 
 func newTypeHasher(buf *bytes.Buffer, ctxt *Context) *typeWriter {
 	assert(ctxt != nil)
-	return &typeWriter{buf, make(map[Type]bool), nil, ctxt, false}
+	return &typeWriter{buf, make(map[Type]bool), nil, ctxt, nil, false}
 }
 
 func (w *typeWriter) byte(b byte) {
@@ -259,8 +261,12 @@ func (w *typeWriter) typ(typ Type) {
 		}
 
 	case *Named:
-		w.typePrefix(t)
-		w.typeName(t.obj)
+		// If hashing, write a unique prefix for t to represent its identity, since
+		// named type identity is pointer identity.
+		if w.ctxt != nil {
+			w.string(strconv.Itoa(w.ctxt.getID(t)))
+		}
+		w.typeName(t.obj) // when hashing written for readability of the hash only
 		if t.targs != nil {
 			// instantiated type
 			w.typeList(t.targs.list())
@@ -274,9 +280,16 @@ func (w *typeWriter) typ(typ Type) {
 			w.error("unnamed type parameter")
 			break
 		}
-		w.string(t.obj.name)
-		if w.debug || w.ctxt != nil {
-			w.string(subscript(t.id))
+		if i := tparamIndex(w.tparams.list(), t); i >= 0 {
+			// The names of type parameters that are declared by the type being
+			// hashed are not part of the type identity. Replace them with a
+			// placeholder indicating their index.
+			w.string(fmt.Sprintf("$%d", i))
+		} else {
+			w.string(t.obj.name)
+			if w.debug || w.ctxt != nil {
+				w.string(subscript(t.id))
+			}
 		}
 
 	default:
@@ -286,15 +299,6 @@ func (w *typeWriter) typ(typ Type) {
 	}
 }
 
-// If w.ctxt is non-nil, typePrefix writes a unique prefix for the named type t
-// based on the types already observed by w.ctxt. If w.ctxt is nil, it does
-// nothing.
-func (w *typeWriter) typePrefix(t *Named) {
-	if w.ctxt != nil {
-		w.string(strconv.Itoa(w.ctxt.getID(t)))
-	}
-}
-
 func (w *typeWriter) typeList(list []Type) {
 	w.byte('[')
 	for i, typ := range list {
@@ -379,6 +383,13 @@ func (w *typeWriter) tuple(tup *Tuple, variadic bool) {
 
 func (w *typeWriter) signature(sig *Signature) {
 	if sig.TypeParams().Len() != 0 {
+		if w.ctxt != nil {
+			assert(w.tparams == nil)
+			w.tparams = sig.TypeParams()
+			defer func() {
+				w.tparams = nil
+			}()
+		}
 		w.tParamList(sig.TypeParams().list())
 	}
 

From 958f405371d942d988aef325b2103fa64028af45 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 10 Nov 2021 15:54:00 -0500
Subject: [PATCH 146/752] go/types: when type hashing, canonicalize interfaces

The interface type string preserves certain non-semantic attributes of
the type, such as embedded interfaces. We want the hash to represent the
interface identity, so hash the type set representation of the interface
instead.

Change-Id: I14081ac20b738c5fe11785e0846a9b4358594768
Reviewed-on: https://go-review.googlesource.com/c/go/+/363115
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/instantiate_test.go | 33 ++++++++++++++++
 src/go/types/typestring.go       | 66 ++++++++++++++++++++++++++------
 2 files changed, 87 insertions(+), 12 deletions(-)

diff --git a/src/go/types/instantiate_test.go b/src/go/types/instantiate_test.go
index a4ed581e35..281c8bbcad 100644
--- a/src/go/types/instantiate_test.go
+++ b/src/go/types/instantiate_test.go
@@ -5,12 +5,14 @@
 package types_test
 
 import (
+	"go/token"
 	. "go/types"
 	"strings"
 	"testing"
 )
 
 func TestInstantiateEquality(t *testing.T) {
+	emptySignature := NewSignatureType(nil, nil, nil, nil, nil, false)
 	tests := []struct {
 		src       string
 		name1     string
@@ -37,6 +39,37 @@ func TestInstantiateEquality(t *testing.T) {
 			"T", []Type{NewSlice(Typ[Int])},
 			true,
 		},
+		{
+			// interface{interface{...}} is equivalent to interface{...}
+			"package equivalentinterfaces; type T[P any] int",
+			"T", []Type{
+				NewInterfaceType([]*Func{NewFunc(token.NoPos, nil, "M", emptySignature)}, nil),
+			},
+			"T", []Type{
+				NewInterfaceType(
+					nil,
+					[]Type{
+						NewInterfaceType([]*Func{NewFunc(token.NoPos, nil, "M", emptySignature)}, nil),
+					},
+				),
+			},
+			true,
+		},
+		{
+			// int|string is equivalent to string|int
+			"package equivalenttypesets; type T[P any] int",
+			"T", []Type{
+				NewInterfaceType(nil, []Type{
+					NewUnion([]*Term{NewTerm(false, Typ[Int]), NewTerm(false, Typ[String])}),
+				}),
+			},
+			"T", []Type{
+				NewInterfaceType(nil, []Type{
+					NewUnion([]*Term{NewTerm(false, Typ[String]), NewTerm(false, Typ[Int])}),
+				}),
+			},
+			true,
+		},
 		{
 			"package basicfunc; func F[P any]() {}",
 			"F", []Type{Typ[Int]},
diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index cb41abd2ac..f33175f97e 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -10,7 +10,9 @@ import (
 	"bytes"
 	"fmt"
 	"go/token"
+	"sort"
 	"strconv"
+	"strings"
 	"unicode/utf8"
 )
 
@@ -211,20 +213,24 @@ func (w *typeWriter) typ(typ Type) {
 		}
 		w.string("interface{")
 		first := true
-		for _, m := range t.methods {
-			if !first {
-				w.byte(';')
+		if w.ctxt != nil {
+			w.typeSet(t.typeSet())
+		} else {
+			for _, m := range t.methods {
+				if !first {
+					w.byte(';')
+				}
+				first = false
+				w.string(m.name)
+				w.signature(m.typ.(*Signature))
 			}
-			first = false
-			w.string(m.name)
-			w.signature(m.typ.(*Signature))
-		}
-		for _, typ := range t.embeddeds {
-			if !first {
-				w.byte(';')
+			for _, typ := range t.embeddeds {
+				if !first {
+					w.byte(';')
+				}
+				first = false
+				w.typ(typ)
 			}
-			first = false
-			w.typ(typ)
 		}
 		w.byte('}')
 
@@ -299,6 +305,42 @@ func (w *typeWriter) typ(typ Type) {
 	}
 }
 
+// typeSet writes a canonical hash for an interface type set.
+func (w *typeWriter) typeSet(s *_TypeSet) {
+	assert(w.ctxt != nil)
+	first := true
+	for _, m := range s.methods {
+		if !first {
+			w.byte(';')
+		}
+		first = false
+		w.string(m.name)
+		w.signature(m.typ.(*Signature))
+	}
+	switch {
+	case s.terms.isAll():
+		// nothing to do
+	case s.terms.isEmpty():
+		w.string(s.terms.String())
+	default:
+		var termHashes []string
+		for _, term := range s.terms {
+			// terms are not canonically sorted, so we sort their hashes instead.
+			var buf bytes.Buffer
+			if term.tilde {
+				buf.WriteByte('~')
+			}
+			newTypeHasher(&buf, w.ctxt).typ(term.typ)
+			termHashes = append(termHashes, buf.String())
+		}
+		sort.Strings(termHashes)
+		if !first {
+			w.byte(';')
+		}
+		w.string(strings.Join(termHashes, "|"))
+	}
+}
+
 func (w *typeWriter) typeList(list []Type) {
 	w.byte('[')
 	for i, typ := range list {

From 530e320b2a9ed08f2bba39507b877fd66352d7ca Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 10 Nov 2021 16:52:17 -0500
Subject: [PATCH 147/752] go/types: don't set a Config.Context if none is
 provided

Users can re-use a type checking context by passing it via types.Config.
There is no need for us to expose the internal type checking context
when the config context is unset, and in fact doing so could lead to a
memory leak for users that re-use types.Config, expecting it to be small
and immutable.

Keep track of the Context on Checker instead, and zero it out at the end
of type checking.

Change-Id: Iff5b328a09cd0af76fcd4869f5f15352131b5986
Reviewed-on: https://go-review.googlesource.com/c/go/+/363175
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/call.go      | 2 +-
 src/go/types/check.go     | 8 +++-----
 src/go/types/decl.go      | 2 +-
 src/go/types/named.go     | 8 +++++---
 src/go/types/signature.go | 2 +-
 src/go/types/typexpr.go   | 9 +++++----
 6 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/src/go/types/call.go b/src/go/types/call.go
index 890a2c7c5a..da4b72a0c7 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -81,7 +81,7 @@ func (check *Checker) instantiateSignature(pos token.Pos, typ *Signature, targs
 		}()
 	}
 
-	inst := check.instance(pos, typ, targs, check.conf.Context).(*Signature)
+	inst := check.instance(pos, typ, targs, check.bestContext(nil)).(*Signature)
 	assert(len(posList) <= len(targs))
 	tparams := typ.TypeParams().list()
 	if i, err := check.verify(pos, tparams, targs); err != nil {
diff --git a/src/go/types/check.go b/src/go/types/check.go
index 93e6ffa761..ba7d26455f 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -105,6 +105,7 @@ type Checker struct {
 	// package information
 	// (initialized by NewChecker, valid for the life-time of checker)
 	conf *Config
+	ctxt *Context // context for de-duplicating instances
 	fset *token.FileSet
 	pkg  *Package
 	*Info
@@ -203,11 +204,6 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
 		conf = new(Config)
 	}
 
-	// make sure we have a context
-	if conf.Context == nil {
-		conf.Context = NewContext()
-	}
-
 	// make sure we have an info struct
 	if info == nil {
 		info = new(Info)
@@ -220,6 +216,7 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch
 
 	return &Checker{
 		conf:    conf,
+		ctxt:    conf.Context,
 		fset:    fset,
 		pkg:     pkg,
 		Info:    info,
@@ -322,6 +319,7 @@ func (check *Checker) checkFiles(files []*ast.File) (err error) {
 	check.seenPkgMap = nil
 	check.recvTParamMap = nil
 	check.defTypes = nil
+	check.ctxt = nil
 
 	// TODO(rFindley) There's more memory we should release at this point.
 
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 64d5bd195e..6adace3484 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -68,7 +68,7 @@ func (check *Checker) objDecl(obj Object, def *Named) {
 	// Funcs with m.instRecv set have not yet be completed. Complete them now
 	// so that they have a type when objDecl exits.
 	if m, _ := obj.(*Func); m != nil && m.instRecv != nil {
-		check.completeMethod(check.conf.Context, m)
+		check.completeMethod(nil, m)
 	}
 
 	// Checking the declaration of obj means inferring its type
diff --git a/src/go/types/named.go b/src/go/types/named.go
index 06b6d4692b..82a053dd0d 100644
--- a/src/go/types/named.go
+++ b/src/go/types/named.go
@@ -222,15 +222,17 @@ func (n *Named) setUnderlying(typ Type) {
 
 // bestContext returns the best available context. In order of preference:
 // - the given ctxt, if non-nil
-// - check.Config.Context, if check is non-nil
+// - check.ctxt, if check is non-nil
 // - a new Context
 func (check *Checker) bestContext(ctxt *Context) *Context {
 	if ctxt != nil {
 		return ctxt
 	}
 	if check != nil {
-		assert(check.conf.Context != nil)
-		return check.conf.Context
+		if check.ctxt == nil {
+			check.ctxt = NewContext()
+		}
+		return check.ctxt
 	}
 	return NewContext()
 }
diff --git a/src/go/types/signature.go b/src/go/types/signature.go
index 3e0a046afa..698b89c462 100644
--- a/src/go/types/signature.go
+++ b/src/go/types/signature.go
@@ -211,7 +211,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 			var err string
 			switch T := rtyp.(type) {
 			case *Named:
-				T.resolve(check.conf.Context)
+				T.resolve(check.bestContext(nil))
 				// The receiver type may be an instantiated type referred to
 				// by an alias (which cannot have receiver parameters for now).
 				if T.TypeArgs() != nil && sig.RecvTypeParams() == nil {
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 09d1471985..cff9917185 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -409,9 +409,10 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 	}
 
 	// create the instance
-	h := check.conf.Context.instanceHash(orig, targs)
+	ctxt := check.bestContext(nil)
+	h := ctxt.instanceHash(orig, targs)
 	// targs may be incomplete, and require inference. In any case we should de-duplicate.
-	inst, _ := check.conf.Context.lookup(h, orig, targs).(*Named)
+	inst, _ := ctxt.lookup(h, orig, targs).(*Named)
 	// If inst is non-nil, we can't just return here. Inst may have been
 	// constructed via recursive substitution, in which case we wouldn't do the
 	// validation below. Ensure that the validation (and resulting errors) runs
@@ -420,7 +421,7 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 		tname := NewTypeName(x.Pos(), orig.obj.pkg, orig.obj.name, nil)
 		inst = check.newNamed(tname, orig, nil, nil, nil) // underlying, methods and tparams are set when named is resolved
 		inst.targs = NewTypeList(targs)
-		inst = check.conf.Context.update(h, orig, targs, inst).(*Named)
+		inst = ctxt.update(h, orig, targs, inst).(*Named)
 	}
 	def.setUnderlying(inst)
 
@@ -446,7 +447,7 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 		// This is an instance from the source, not from recursive substitution,
 		// and so it must be resolved during type-checking so that we can report
 		// errors.
-		inst.resolve(check.conf.Context)
+		inst.resolve(ctxt)
 		// Since check is non-nil, we can still mutate inst. Unpinning the resolver
 		// frees some memory.
 		inst.resolver = nil

From c893a85f21d0e5448c687254e50cc6936b36548e Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 10 Nov 2021 16:58:45 -0500
Subject: [PATCH 148/752] go/types: rename types.context to types.environment

Now that we have a Context type the context (unexported) type is
particularly confusing. Rename it to environment.

Change-Id: I7d280439b8263d9ebfd561fc4d59c6d43c8d3e3f
Reviewed-on: https://go-review.googlesource.com/c/go/+/363176
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/check.go | 17 +++++++++--------
 src/go/types/decl.go  | 16 ++++++++--------
 src/go/types/stmt.go  | 10 +++++-----
 3 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/src/go/types/check.go b/src/go/types/check.go
index ba7d26455f..aef53b20de 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -41,8 +41,9 @@ type exprInfo struct {
 	val   constant.Value // constant value; or nil (if not a constant)
 }
 
-// A context represents the context within which an object is type-checked.
-type context struct {
+// An environment represents the environment within which an object is
+// type-checked.
+type environment struct {
 	decl          *declInfo              // package-level declaration whose init expression/function body is checked
 	scope         *Scope                 // top-most scope for lookups
 	pos           token.Pos              // if valid, identifiers are looked up as if at position pos (used by Eval)
@@ -55,9 +56,9 @@ type context struct {
 	hasCallOrRecv bool                   // set if an expression contains a function call or channel receive operation
 }
 
-// lookup looks up name in the current context and returns the matching object, or nil.
-func (ctxt *context) lookup(name string) Object {
-	_, obj := ctxt.scope.LookupParent(name, ctxt.pos)
+// lookup looks up name in the current environment and returns the matching object, or nil.
+func (env *environment) lookup(name string) Object {
+	_, obj := env.scope.LookupParent(name, env.pos)
 	return obj
 }
 
@@ -140,9 +141,9 @@ type Checker struct {
 	objPath  []Object              // path of object dependencies during type inference (for cycle reporting)
 	defTypes []*Named              // defined types created during type checking, for final validation.
 
-	// context within which the current object is type-checked
-	// (valid only for the duration of type-checking a specific object)
-	context
+	// environment within which the current object is type-checked (valid only
+	// for the duration of type-checking a specific object)
+	environment
 
 	// debugging
 	indent int // indentation for tracing
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 6adace3484..7e89e7be3a 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -50,7 +50,7 @@ func pathString(path []Object) string {
 	return s
 }
 
-// objDecl type-checks the declaration of obj in its respective (file) context.
+// objDecl type-checks the declaration of obj in its respective (file) environment.
 // For the meaning of def, see Checker.definedType, in typexpr.go.
 func (check *Checker) objDecl(obj Object, def *Named) {
 	if trace && obj.Type() == nil {
@@ -177,11 +177,11 @@ func (check *Checker) objDecl(obj Object, def *Named) {
 		unreachable()
 	}
 
-	// save/restore current context and setup object context
-	defer func(ctxt context) {
-		check.context = ctxt
-	}(check.context)
-	check.context = context{
+	// save/restore current environment and set up object environment
+	defer func(env environment) {
+		check.environment = env
+	}(check.environment)
+	check.environment = environment{
 		scope: d.file,
 	}
 
@@ -239,7 +239,7 @@ loop:
 			// If we reach a generic type that is part of a cycle
 			// and we are in a type parameter list, we have a cycle
 			// through a type parameter list, which is invalid.
-			if check.context.inTParamList && isGeneric(obj.typ) {
+			if check.environment.inTParamList && isGeneric(obj.typ) {
 				tparCycle = true
 				break loop
 			}
@@ -697,7 +697,7 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list *ast.FieldList
 	// function closures may appear inside a type parameter list but they
 	// cannot be generic, and their bodies are processed in delayed and
 	// sequential fashion. Note that with each new declaration, we save
-	// the existing context and restore it when done; thus inTPList is
+	// the existing environment and restore it when done; thus inTPList is
 	// true exactly only when we are in a specific type parameter list.
 	assert(!check.inTParamList)
 	check.inTParamList = true
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index 11032f44dd..c000d935d6 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -29,13 +29,13 @@ func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body
 	sig.scope.pos = body.Pos()
 	sig.scope.end = body.End()
 
-	// save/restore current context and setup function context
+	// save/restore current environment and set up function environment
 	// (and use 0 indentation at function start)
-	defer func(ctxt context, indent int) {
-		check.context = ctxt
+	defer func(env environment, indent int) {
+		check.environment = env
 		check.indent = indent
-	}(check.context, check.indent)
-	check.context = context{
+	}(check.environment, check.indent)
+	check.environment = environment{
 		decl:  decl,
 		scope: sig.scope,
 		iota:  iota,

From 2fd720b78086eaa57559e38f6ad4fe51c09c3a17 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Fri, 12 Nov 2021 20:15:49 -0500
Subject: [PATCH 149/752] test: fix longtest failures on
 fixedbugs/issue48471.go

This test is failing with -G=0, so specify -G=3.

Change-Id: I4c74707d0a43f8191cb0b156204604458ba85136
Reviewed-on: https://go-review.googlesource.com/c/go/+/363699
Trust: Robert Findley 
Trust: Dan Scales 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Dan Scales 
---
 test/fixedbugs/issue48471.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/fixedbugs/issue48471.go b/test/fixedbugs/issue48471.go
index 2e00c87c6a..88caeede15 100644
--- a/test/fixedbugs/issue48471.go
+++ b/test/fixedbugs/issue48471.go
@@ -1,4 +1,4 @@
-// errorcheck
+// errorcheck -G=3
 
 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

From e658c42ba460b91d5b6934829ddffa802d4ca524 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Thu, 11 Nov 2021 20:15:02 -0500
Subject: [PATCH 150/752] go/types: add a test for Context deduplication of
 hash collisions

Add a test that exercises the fall-back logic in Context to handle hash
collisions by de-duplicating using Identical.

This has to be a somewhat invasive test because we don't know any actual
cases of hash collisions.

Change-Id: Idf00f7a6ab8c7517ed0f91fdc42d54f5e736b1b9
Reviewed-on: https://go-review.googlesource.com/c/go/+/363517
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/context_test.go | 70 ++++++++++++++++++++++++++++++++++++
 src/go/types/types_test.go   |  8 -----
 2 files changed, 70 insertions(+), 8 deletions(-)
 create mode 100644 src/go/types/context_test.go
 delete mode 100644 src/go/types/types_test.go

diff --git a/src/go/types/context_test.go b/src/go/types/context_test.go
new file mode 100644
index 0000000000..ec30050202
--- /dev/null
+++ b/src/go/types/context_test.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 types
+
+import (
+	"go/token"
+	"testing"
+)
+
+func TestContextHashCollisions(t *testing.T) {
+	if debug {
+		t.Skip("hash collisions are expected, and would fail debug assertions")
+	}
+	// Unit test the de-duplication fall-back logic in Context.
+	//
+	// We can't test this via Instantiate because this is only a fall-back in
+	// case our hash is imperfect.
+	//
+	// These lookups and updates use reasonable looking types in an attempt to
+	// make them robust to internal type assertions, but could equally well use
+	// arbitrary types.
+
+	// Create some distinct origin types. nullaryP and nullaryQ have no
+	// parameters and are identical (but have different type parameter names).
+	// unaryP has a parameter.
+	var nullaryP, nullaryQ, unaryP Type
+	{
+		// type nullaryP = func[P any]()
+		tparam := NewTypeParam(NewTypeName(token.NoPos, nil, "P", nil), &emptyInterface)
+		nullaryP = NewSignatureType(nil, nil, []*TypeParam{tparam}, nil, nil, false)
+	}
+	{
+		// type nullaryQ = func[Q any]()
+		tparam := NewTypeParam(NewTypeName(token.NoPos, nil, "Q", nil), &emptyInterface)
+		nullaryQ = NewSignatureType(nil, nil, []*TypeParam{tparam}, nil, nil, false)
+	}
+	{
+		// type unaryP = func[P any](_ P)
+		tparam := NewTypeParam(NewTypeName(token.NoPos, nil, "P", nil), &emptyInterface)
+		params := NewTuple(NewVar(token.NoPos, nil, "_", tparam))
+		unaryP = NewSignatureType(nil, nil, []*TypeParam{tparam}, params, nil, false)
+	}
+
+	ctxt := NewContext()
+
+	// Update the context with an instantiation of nullaryP.
+	inst := NewSignatureType(nil, nil, nil, nil, nil, false)
+	if got := ctxt.update("", nullaryP, []Type{Typ[Int]}, inst); got != inst {
+		t.Error("bad")
+	}
+
+	// unaryP is not identical to nullaryP, so we should not get inst when
+	// instantiated with identical type arguments.
+	if got := ctxt.lookup("", unaryP, []Type{Typ[Int]}); got != nil {
+		t.Error("bad")
+	}
+
+	// nullaryQ is identical to nullaryP, so we *should* get inst when
+	// instantiated with identical type arguments.
+	if got := ctxt.lookup("", nullaryQ, []Type{Typ[Int]}); got != inst {
+		t.Error("bad")
+	}
+
+	// ...but verify we don't get inst with different type arguments.
+	if got := ctxt.lookup("", nullaryQ, []Type{Typ[String]}); got != nil {
+		t.Error("bad")
+	}
+}
diff --git a/src/go/types/types_test.go b/src/go/types/types_test.go
deleted file mode 100644
index f2358c6e19..0000000000
--- a/src/go/types/types_test.go
+++ /dev/null
@@ -1,8 +0,0 @@
-// 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
-
-// Debug is set if go/types is built with debug mode enabled.
-const Debug = debug

From c78a267bd4ccdd8699a9dbe9bad3597bf3de47e9 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Fri, 12 Nov 2021 11:46:23 -0500
Subject: [PATCH 151/752] go/types: return an error from Instantiate on
 incorrect len(targs)

Instantiate already returns an error when validation fails. Panicking on
an incorrect number of type arguments means that callers must both
pre-validate the number of type arguments and handle resulting errors.
Returning an error rather than panicking allows eliminating
pre-validation at the call-site.

Also update the Instantiate docstring to correct some stale/inaccurate
information, and to clarify its behavior more precisely.

Updates #47916

Change-Id: I997ef30b3486760a90b0db4c3ea7111280d74a81
Reviewed-on: https://go-review.googlesource.com/c/go/+/363635
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/instantiate.go | 50 ++++++++++++++++++++++---------------
 1 file changed, 30 insertions(+), 20 deletions(-)

diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index ec646e1a5c..2d2d1718f4 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -13,40 +13,50 @@ import (
 	"go/token"
 )
 
-// Instantiate instantiates the type typ with the given type arguments targs.
-// typ must be a *Named or a *Signature type, and its number of type parameters
-// must match the number of provided type arguments. The result is a new,
-// instantiated (not parameterized) type of the same kind (either a *Named or a
-// *Signature). Any methods attached to a *Named are simply copied; they are
-// not instantiated.
+// Instantiate instantiates the type orig with the given type arguments targs.
+// orig must be a *Named or a *Signature type. If there is no error, the
+// resulting Type is a new, instantiated (not parameterized) type of the same
+// kind (either a *Named or a *Signature). Methods attached to a *Named type
+// are also instantiated, and associated with a new *Func that has the same
+// position as the original method, but nil function scope.
 //
-// If ctxt is non-nil, it may be used to de-dupe the instance against previous
-// instances with the same identity.
+// If ctxt is non-nil, it may be used to de-duplicate the instance against
+// previous instances with the same identity. As a special case, generic
+// *Signature origin types are only considered identical if they are pointer
+// equivalent, so that instantiating distinct (but possibly identical)
+// signatures will yield different instances.
 //
-// If verify is set and constraint satisfaction fails, the returned error may
-// wrap an *ArgumentError indicating which type argument did not satisfy its
-// corresponding type parameter constraint, and why.
+// If validate is set, Instantiate verifies that the number of type arguments
+// and parameters match, and that the type arguments satisfy their
+// corresponding type constraints. If verification fails, the resulting error
+// may wrap an *ArgumentError indicating which type argument did not satisfy
+// its corresponding type parameter constraint, and why.
 //
-// TODO(rfindley): change this function to also return an error if lengths of
-// tparams and targs do not match.
-func Instantiate(ctxt *Context, typ Type, targs []Type, validate bool) (Type, error) {
-	inst := (*Checker)(nil).instance(token.NoPos, typ, targs, ctxt)
-
-	var err error
+// If validate is not set, Instantiate does not verify the type argument count
+// or whether the type arguments satisfy their constraints. Instantiate is
+// guaranteed to not return an error, but may panic. Specifically, for
+// *Signature types, Instantiate will panic immediately if the type argument
+// count is incorrect; for *Named types, a panic may occur later inside the
+// *Named API.
+func Instantiate(ctxt *Context, orig Type, targs []Type, validate bool) (Type, error) {
 	if validate {
 		var tparams []*TypeParam
-		switch t := typ.(type) {
+		switch t := orig.(type) {
 		case *Named:
 			tparams = t.TypeParams().list()
 		case *Signature:
 			tparams = t.TypeParams().list()
 		}
+		if len(targs) != len(tparams) {
+			return nil, fmt.Errorf("got %d type arguments but %s has %d type parameters", len(targs), orig, len(tparams))
+		}
 		if i, err := (*Checker)(nil).verify(token.NoPos, tparams, targs); err != nil {
-			return inst, &ArgumentError{i, err}
+			return nil, &ArgumentError{i, err}
 		}
 	}
 
-	return inst, err
+	inst := (*Checker)(nil).instance(token.NoPos, orig, targs, ctxt)
+	return inst, nil
 }
 
 // instance creates a type or function instance using the given original type

From c54605266b746dd4d81e3753b55910e5c8dde5f0 Mon Sep 17 00:00:00 2001
From: Michael Matloob 
Date: Fri, 29 Oct 2021 16:47:22 -0400
Subject: [PATCH 152/752] cmd/go: remove remaining uses of TODOWorkspaces

Most of them are fixed, but some of them have been rewritten to refer
to specific issues.

For #45713

Change-Id: Id24d9bd47afeac089835f7a26e7025332fb6119c
Reviewed-on: https://go-review.googlesource.com/c/go/+/359794
Trust: Michael Matloob 
Run-TryBot: Michael Matloob 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
---
 src/cmd/go/internal/modcmd/download.go        | 27 ++++---
 src/cmd/go/internal/modload/init.go           | 75 ++++++++++++++-----
 src/cmd/go/internal/workcmd/edit.go           | 27 ++-----
 src/cmd/go/internal/workcmd/init.go           |  6 +-
 src/cmd/go/internal/workcmd/sync.go           | 17 ++++-
 src/cmd/go/internal/workcmd/use.go            | 28 ++-----
 .../script/work_why_download_graph.txt        | 59 +++++++++++++++
 7 files changed, 160 insertions(+), 79 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/work_why_download_graph.txt

diff --git a/src/cmd/go/internal/modcmd/download.go b/src/cmd/go/internal/modcmd/download.go
index f252133762..6b8a010fd9 100644
--- a/src/cmd/go/internal/modcmd/download.go
+++ b/src/cmd/go/internal/modcmd/download.go
@@ -93,24 +93,27 @@ func runDownload(ctx context.Context, cmd *base.Command, args []string) {
 	modload.ExplicitWriteGoMod = true
 	haveExplicitArgs := len(args) > 0
 
-	if modload.HasModRoot() {
+	if modload.HasModRoot() || modload.WorkFilePath() != "" {
 		modload.LoadModFile(ctx) // to fill MainModules
 
-		if len(modload.MainModules.Versions()) != 1 {
-			panic(modload.TODOWorkspaces("Support workspace mode in go mod download"))
-		}
-		mainModule := modload.MainModules.Versions()[0]
-
 		if haveExplicitArgs {
-			targetAtUpgrade := mainModule.Path + "@upgrade"
-			targetAtPatch := mainModule.Path + "@patch"
-			for _, arg := range args {
-				switch arg {
-				case mainModule.Path, targetAtUpgrade, targetAtPatch:
-					os.Stderr.WriteString("go: skipping download of " + arg + " that resolves to the main module\n")
+			for _, mainModule := range modload.MainModules.Versions() {
+				targetAtUpgrade := mainModule.Path + "@upgrade"
+				targetAtPatch := mainModule.Path + "@patch"
+				for _, arg := range args {
+					switch arg {
+					case mainModule.Path, targetAtUpgrade, targetAtPatch:
+						os.Stderr.WriteString("go: skipping download of " + arg + " that resolves to the main module\n")
+					}
 				}
 			}
+		} else if modload.WorkFilePath() != "" {
+			// TODO(#44435): Think about what the correct query is to download the
+			// right set of modules. Also see code review comment at
+			// https://go-review.googlesource.com/c/go/+/359794/comments/ce946a80_6cf53992.
+			args = []string{"all"}
 		} else {
+			mainModule := modload.MainModules.Versions()[0]
 			modFile := modload.MainModules.ModFile(mainModule)
 			if modFile.Go == nil || semver.Compare("v"+modFile.Go.Version, modload.ExplicitIndirectVersionV) < 0 {
 				if len(modFile.Require) > 0 {
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index fcf6ce2620..ab899fac1e 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -12,6 +12,7 @@ import (
 	"fmt"
 	"go/build"
 	"internal/lazyregexp"
+	"io/ioutil"
 	"os"
 	"path"
 	"path/filepath"
@@ -56,10 +57,6 @@ var (
 	ExplicitWriteGoMod bool
 )
 
-func TODOWorkspaces(s string) error {
-	return fmt.Errorf("need to support this for workspaces: %s", s)
-}
-
 // Variables set in Init.
 var (
 	initialized bool
@@ -417,9 +414,6 @@ func Init() {
 	// We're in module mode. Set any global variables that need to be set.
 	cfg.ModulesEnabled = true
 	setDefaultBuildMod()
-	_ = TODOWorkspaces("In workspace mode, mod will not be readonly for go mod download," +
-		"verify, graph, and why. Implement support for go mod download and add test cases" +
-		"to ensure verify, graph, and why work properly.")
 	list := filepath.SplitList(cfg.BuildContext.GOPATH)
 	if len(list) > 0 && list[0] != "" {
 		gopath = list[0]
@@ -562,13 +556,8 @@ func (goModDirtyError) Error() string {
 var errGoModDirty error = goModDirtyError{}
 
 func loadWorkFile(path string) (goVersion string, modRoots []string, replaces []*modfile.Replace, err error) {
-	_ = TODOWorkspaces("Clean up and write back the go.work file: add module paths for workspace modules.")
 	workDir := filepath.Dir(path)
-	workData, err := lockedfile.Read(path)
-	if err != nil {
-		return "", nil, nil, err
-	}
-	wf, err := modfile.ParseWork(path, workData, nil)
+	wf, err := ReadWorkFile(path)
 	if err != nil {
 		return "", nil, nil, err
 	}
@@ -581,15 +570,60 @@ func loadWorkFile(path string) (goVersion string, modRoots []string, replaces []
 		if !filepath.IsAbs(modRoot) {
 			modRoot = filepath.Join(workDir, modRoot)
 		}
+
 		if seen[modRoot] {
 			return "", nil, nil, fmt.Errorf("path %s appears multiple times in workspace", modRoot)
 		}
 		seen[modRoot] = true
 		modRoots = append(modRoots, modRoot)
 	}
+
 	return goVersion, modRoots, wf.Replace, nil
 }
 
+// ReadWorkFile reads and parses the go.work file at the given path.
+func ReadWorkFile(path string) (*modfile.WorkFile, error) {
+	workData, err := ioutil.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	wf, err := modfile.ParseWork(path, workData, nil)
+
+	return wf, nil
+}
+
+// WriteWorkFile cleans and writes out the go.work file to the given path.
+func WriteWorkFile(path string, wf *modfile.WorkFile) error {
+	wf.SortBlocks()
+	wf.Cleanup()
+	out := modfile.Format(wf.Syntax)
+
+	return ioutil.WriteFile(path, out, 0666)
+}
+
+// UpdateWorkFile updates comments on directory directives in the go.work
+// file to include the associated module path.
+func UpdateWorkFile(wf *modfile.WorkFile) {
+	missingModulePaths := map[string]string{} // module directory listed in file -> abspath modroot
+
+	for _, d := range wf.Directory {
+		modRoot := d.Path
+		if d.ModulePath == "" {
+			missingModulePaths[d.Path] = modRoot
+		}
+	}
+
+	// Clean up and annotate directories.
+	// TODO(matloob): update x/mod to actually add module paths.
+	for moddir, absmodroot := range missingModulePaths {
+		_, f, err := ReadModFile(filepath.Join(absmodroot, "go.mod"), nil)
+		if err != nil {
+			continue // Error will be reported if modules are loaded.
+		}
+		wf.AddDirectory(moddir, f.Module.Mod.Path)
+	}
+}
+
 // LoadModFile sets Target and, if there is a main module, parses the initial
 // build list from its go.mod file.
 //
@@ -651,7 +685,9 @@ func LoadModFile(ctx context.Context) *Requirements {
 		modfetch.GoSumFile = strings.TrimSuffix(modFilePath(modRoots[0]), ".mod") + ".sum"
 	}
 	if len(modRoots) == 0 {
-		_ = TODOWorkspaces("Instead of creating a fake module with an empty modroot, make MainModules.Len() == 0 mean that we're in module mode but not inside any module.")
+		// TODO(#49228): Instead of creating a fake module with an empty modroot,
+		// make MainModules.Len() == 0 mean that we're in module mode but not inside
+		// any module.
 		mainModule := module.Version{Path: "command-line-arguments"}
 		MainModules = makeMainModules([]module.Version{mainModule}, []string{""}, []*modfile.File{nil}, []*modFileIndex{nil}, "", nil)
 		goVersion := LatestGoVersion()
@@ -854,8 +890,8 @@ func CreateWorkFile(ctx context.Context, workFile string, modDirs []string) {
 		workF.AddDirectory(ToDirectoryPath(dir), f.Module.Mod.Path)
 	}
 
-	data := modfile.Format(workF.Syntax)
-	lockedfile.Write(workFile, bytes.NewReader(data), 0666)
+	UpdateWorkFile(workF)
+	WriteWorkFile(workFile, workF)
 }
 
 // fixVersion returns a modfile.VersionFixer implemented using the Query function.
@@ -1233,9 +1269,10 @@ func findWorkspaceFile(dir string) (root string) {
 			break
 		}
 		if d == cfg.GOROOT {
-			_ = TODOWorkspaces("If we end up checking in a go.work file to GOROOT/src," +
-				"remove this case.")
-			return "" // As a special case, don't cross GOROOT to find a go.work file.
+			// As a special case, don't cross GOROOT to find a go.work file.
+			// The standard library and commands built in go always use the vendored
+			// dependencies, so avoid using a most likely irrelevant go.work file.
+			return ""
 		}
 		dir = d
 	}
diff --git a/src/cmd/go/internal/workcmd/edit.go b/src/cmd/go/internal/workcmd/edit.go
index f4e630f43f..5158ac9b49 100644
--- a/src/cmd/go/internal/workcmd/edit.go
+++ b/src/cmd/go/internal/workcmd/edit.go
@@ -7,13 +7,10 @@
 package workcmd
 
 import (
-	"bytes"
 	"cmd/go/internal/base"
-	"cmd/go/internal/lockedfile"
 	"cmd/go/internal/modload"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -150,12 +147,7 @@ func runEditwork(ctx context.Context, cmd *base.Command, args []string) {
 		}
 	}
 
-	data, err := lockedfile.Read(gowork)
-	if err != nil {
-		base.Fatalf("go: %v", err)
-	}
-
-	workFile, err := modfile.ParseWork(gowork, data, nil)
+	workFile, err := modload.ReadWorkFile(gowork)
 	if err != nil {
 		base.Fatalf("go: errors parsing %s:\n%s", base.ShortPath(gowork), err)
 	}
@@ -171,6 +163,9 @@ func runEditwork(ctx context.Context, cmd *base.Command, args []string) {
 			edit(workFile)
 		}
 	}
+
+	modload.UpdateWorkFile(workFile)
+
 	workFile.SortBlocks()
 	workFile.Cleanup() // clean file after edits
 
@@ -179,22 +174,12 @@ func runEditwork(ctx context.Context, cmd *base.Command, args []string) {
 		return
 	}
 
-	out := modfile.Format(workFile.Syntax)
-
 	if *editPrint {
-		os.Stdout.Write(out)
+		os.Stdout.Write(modfile.Format(workFile.Syntax))
 		return
 	}
 
-	err = lockedfile.Transform(gowork, func(lockedData []byte) ([]byte, error) {
-		if !bytes.Equal(lockedData, data) {
-			return nil, errors.New("go.work changed during editing; not overwriting")
-		}
-		return out, nil
-	})
-	if err != nil {
-		base.Fatalf("go: %v", err)
-	}
+	modload.WriteWorkFile(gowork, workFile)
 }
 
 // flagEditworkDirectory implements the -directory flag.
diff --git a/src/cmd/go/internal/workcmd/init.go b/src/cmd/go/internal/workcmd/init.go
index 1342748023..fde1483efb 100644
--- a/src/cmd/go/internal/workcmd/init.go
+++ b/src/cmd/go/internal/workcmd/init.go
@@ -13,9 +13,9 @@ import (
 	"path/filepath"
 )
 
-var _ = modload.TODOWorkspaces("Add more documentation below. Though this is" +
-	"enough for those trying workspaces out, there should be more through" +
-	"documentation if the proposal is accepted and released.")
+// TODO(#49232) Add more documentation below. Though this is
+// enough for those trying workspaces out, there should be more through
+// documentation before Go 1.18 is released.
 
 var cmdInit = &base.Command{
 	UsageLine: "go work init [moddirs]",
diff --git a/src/cmd/go/internal/workcmd/sync.go b/src/cmd/go/internal/workcmd/sync.go
index 2723013bf8..6f35dc4ff3 100644
--- a/src/cmd/go/internal/workcmd/sync.go
+++ b/src/cmd/go/internal/workcmd/sync.go
@@ -15,9 +15,9 @@ import (
 	"golang.org/x/mod/module"
 )
 
-var _ = modload.TODOWorkspaces("Add more documentation below. Though this is" +
-	"enough for those trying workspaces out, there should be more through" +
-	"documentation if the proposal is accepted and released.")
+// TODO(#49232) Add more documentation below. Though this is
+// enough for those trying workspaces out, there should be more thorough
+// documentation before Go 1.18 is released.
 
 var cmdSync = &base.Command{
 	UsageLine: "go work sync [moddirs]",
@@ -71,6 +71,8 @@ func runSync(ctx context.Context, cmd *base.Command, args []string) {
 		mustSelectFor[m] = mustSelect
 	}
 
+	workFilePath := modload.WorkFilePath() // save go.work path because EnterModule clobbers it.
+
 	for _, m := range mms.Versions() {
 		// Use EnterModule to reset the global state in modload to be in
 		// single-module mode using the modroot of m.
@@ -98,4 +100,13 @@ func runSync(ctx context.Context, cmd *base.Command, args []string) {
 		}, "all")
 		modload.WriteGoMod(ctx)
 	}
+
+	wf, err := modload.ReadWorkFile(workFilePath)
+	if err != nil {
+		base.Fatalf("go: %v", err)
+	}
+	modload.UpdateWorkFile(wf)
+	if err := modload.WriteWorkFile(workFilePath, wf); err != nil {
+		base.Fatalf("go: %v", err)
+	}
 }
diff --git a/src/cmd/go/internal/workcmd/use.go b/src/cmd/go/internal/workcmd/use.go
index 10c25da396..b2218280e4 100644
--- a/src/cmd/go/internal/workcmd/use.go
+++ b/src/cmd/go/internal/workcmd/use.go
@@ -9,20 +9,16 @@ package workcmd
 import (
 	"cmd/go/internal/base"
 	"cmd/go/internal/fsys"
-	"cmd/go/internal/lockedfile"
 	"cmd/go/internal/modload"
 	"context"
 	"io/fs"
-	"io/ioutil"
 	"os"
 	"path/filepath"
-
-	"golang.org/x/mod/modfile"
 )
 
-var _ = modload.TODOWorkspaces("Add more documentation below. Though this is" +
-	"enough for those trying workspaces out, there should be more through" +
-	"documentation if the proposal is accepted and released.")
+// TODO(#49232) Add more documentation below. Though this is
+// enough for those trying workspaces out, there should be more thorough
+// documentation before Go 1.18 is released.
 
 var cmdUse = &base.Command{
 	UsageLine: "go work use [-r] [moddirs]",
@@ -51,14 +47,9 @@ func runUse(ctx context.Context, cmd *base.Command, args []string) {
 	modload.InitWorkfile()
 	gowork = modload.WorkFilePath()
 
-	data, err := lockedfile.Read(gowork)
+	workFile, err := modload.ReadWorkFile(gowork)
 	if err != nil {
-		base.Fatalf("goX: %v", err)
-	}
-
-	workFile, err := modfile.ParseWork(gowork, data, nil)
-	if err != nil {
-		base.Fatalf("go: errors parsing %s:\n%s", base.ShortPath(gowork), err)
+		base.Fatalf("go: %v", err)
 	}
 
 	haveDirs := make(map[string]bool)
@@ -119,11 +110,6 @@ func runUse(ctx context.Context, cmd *base.Command, args []string) {
 	for dir := range addDirs {
 		workFile.AddDirectory(filepath.ToSlash(dir), "")
 	}
-	workFile.SortBlocks()
-	workFile.Cleanup() // clean file after edits
-	out := modfile.Format(workFile.Syntax)
-
-	if err := ioutil.WriteFile(gowork, out, 0666); err != nil {
-		base.Fatalf("go: %v", err)
-	}
+	modload.UpdateWorkFile(workFile)
+	modload.WriteWorkFile(gowork, workFile)
 }
diff --git a/src/cmd/go/testdata/script/work_why_download_graph.txt b/src/cmd/go/testdata/script/work_why_download_graph.txt
new file mode 100644
index 0000000000..c03b4a7a62
--- /dev/null
+++ b/src/cmd/go/testdata/script/work_why_download_graph.txt
@@ -0,0 +1,59 @@
+# Test go mod download, why, and graph work in workspace mode.
+# TODO(bcmills): clarify the interaction with #44435
+
+go mod download rsc.io/quote
+exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.info
+exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.mod
+exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.zip
+! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.0.info
+! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.0.mod
+
+go mod download
+exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.info
+exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.mod
+exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.zip
+! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.0.info
+! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.0.mod
+
+go mod why rsc.io/quote
+stdout '# rsc.io/quote\nexample.com/a\nrsc.io/quote'
+
+go mod graph
+stdout 'example.com/a rsc.io/quote@v1.5.2\nexample.com/b example.com/c@v1.0.0\nrsc.io/quote@v1.5.2 rsc.io/sampler@v1.3.0\nrsc.io/sampler@v1.3.0 golang.org/x/text@v0.0.0-20170915032832-14c0d48ead0c'
+
+-- go.work --
+go 1.18
+
+directory (
+    ./a
+    ./b
+)
+-- a/go.mod --
+go 1.18
+
+module example.com/a
+
+require "rsc.io/quote" v1.5.2
+-- a/main.go --
+package main
+
+import (
+	"fmt"
+	"rsc.io/quote"
+)
+
+func main() {
+	fmt.Println(quote.Hello())
+}
+-- b/go.mod --
+go 1.18
+
+module example.com/b
+
+require example.com/c v1.0.0
+replace example.com/c => ../c
+-- c/go.mod --
+go 1.18
+
+module example.com/c
+

From c2397905e027cdbab3a28d02813adcb82368422c Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Fri, 12 Nov 2021 18:24:54 -0800
Subject: [PATCH 153/752] cmd/compile/internal/types2: simplify under() and fix
 a crash

The simplified version of under exposed a bug (by crashing):
When a pointer base is used before the pointer is fully set
up, the base is nil. Set the pointer base to Typ[Invalid]
when creating the pointer, and add an extra safety check
into deref. Reviewed all code that creates pointers.

The same error cannot happen with other types because
accessing parts of another type results in an expression
that is not a type, and thus these kids of cycles cannot
happen.

Change-Id: I8332a281a534c094cfbb3623a636960865813ff6
Reviewed-on: https://go-review.googlesource.com/c/go/+/363665
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/lookup.go                 | 7 +++++++
 src/cmd/compile/internal/types2/testdata/check/cycles.src | 1 +
 src/cmd/compile/internal/types2/type.go                   | 7 ++-----
 src/cmd/compile/internal/types2/typexpr.go                | 1 +
 4 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index fbfe3c81ff..b4035e16b3 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -491,6 +491,13 @@ func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Fun
 // Otherwise it returns (typ, false).
 func deref(typ Type) (Type, bool) {
 	if p, _ := typ.(*Pointer); p != nil {
+		// p.base should never be nil, but be conservative
+		if p.base == nil {
+			if debug {
+				panic("pointer with nil base type (possibly due to an invalid cyclic declaration)")
+			}
+			return Typ[Invalid], true
+		}
 		return p.base, true
 	}
 	return typ, false
diff --git a/src/cmd/compile/internal/types2/testdata/check/cycles.src b/src/cmd/compile/internal/types2/testdata/check/cycles.src
index b2ee8ecd5f..998f9f7da9 100644
--- a/src/cmd/compile/internal/types2/testdata/check/cycles.src
+++ b/src/cmd/compile/internal/types2/testdata/check/cycles.src
@@ -45,6 +45,7 @@ type (
 
 	// pointers
 	P0 *P0
+	PP *struct{ PP.f /* ERROR no field or method f */ }
 
 	// functions
 	F0 func(F0)
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 7fcb196c5a..af195c08a4 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -21,13 +21,10 @@ type Type interface {
 // under must only be called when a type is known
 // to be fully set up.
 func under(t Type) Type {
-	switch t := t.(type) {
-	case *Named:
+	if t, _ := t.(*Named); t != nil {
 		return t.under()
-	case *TypeParam:
-		return t.iface()
 	}
-	return t
+	return t.Underlying()
 }
 
 // If x and y are identical, match returns x.
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index e22b1ff0a0..e077879b9d 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -315,6 +315,7 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
 	case *syntax.Operation:
 		if e.Op == syntax.Mul && e.Y == nil {
 			typ := new(Pointer)
+			typ.base = Typ[Invalid] // avoid nil base in invalid recursive type declaration
 			def.setUnderlying(typ)
 			typ.base = check.varType(e.X)
 			// If typ.base is invalid, it's unlikely that *base is particularly

From dfa62c79de4f6f6ee2eb8cde340c21afc739c38d Mon Sep 17 00:00:00 2001
From: Keith Randall 
Date: Fri, 12 Nov 2021 15:48:01 -0800
Subject: [PATCH 154/752] doc: document GOAMD64 environment variable

Update #47694

Change-Id: I9c90bd251616cd4d10434bd3b6e6c30c5c819e24
Reviewed-on: https://go-review.googlesource.com/c/go/+/363661
Trust: Keith Randall 
Reviewed-by: Ian Lance Taylor 
---
 doc/go1.18.html | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 45f89b7be5..e796215c78 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -40,6 +40,19 @@ Do not send CLs removing the interior tags from such phrases.
   FreeBSD 13.0+ will require a kernel with the COMPAT_FREEBSD12 option set (this is the default).
 

 
+
AMD64

+
+

+  Go 1.18 introduces the new GOAMD64 environment variable which selects
+  a version of the AMD64 architecture. Allowed values are v1,
+  v2, v3, or v4. Each higher level requires,
+  and takes advantage of, additional processor features.  A detailed description of the
+  versions is here.
+

+

+  The GOAMD64 environment variable defaults to v1.
+

+
 
PPC64

 
 

@@ -123,10 +136,6 @@ Do not send CLs removing the interior tags from such phrases.
   third-party tools that need to collect package source code.)
 

 
-

-  TODO: https://golang.org/cl/349595: cmd/go: add GOAMD64 environment variable
-

-
 
gofmt

 
 


From 5337e53dfa3f5fde73b8f505ec3a91c628e8f648 Mon Sep 17 00:00:00 2001
From: Keith Randall 
Date: Fri, 12 Nov 2021 12:38:29 -0800
Subject: [PATCH 155/752] cmd/compile: ensure we replace package placeholder in
 type names

We want package names exposed by reflect to be things like
main.F[main.foo], not main.F["".foo].

Fixes #49547

Change-Id: I182411a75d56ce1f64fde847e5b9ee74ce44e00b
Reviewed-on: https://go-review.googlesource.com/c/go/+/363656
Trust: Keith Randall 
Trust: Dan Scales 
Run-TryBot: Keith Randall 
TryBot-Result: Go Bot 
Reviewed-by: Dan Scales 
---
 src/cmd/compile/internal/types/fmt.go |  8 +++++++-
 test/typeparam/issue49547.go          | 22 ++++++++++++++++++++++
 test/typeparam/nested.out             |  6 +++---
 3 files changed, 32 insertions(+), 4 deletions(-)
 create mode 100644 test/typeparam/issue49547.go

diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index 23fc4221e1..b20d2e2908 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -140,11 +140,17 @@ func sconv2(b *bytes.Buffer, s *Sym, verb rune, mode fmtMode) {
 }
 
 func symfmt(b *bytes.Buffer, s *Sym, verb rune, mode fmtMode) {
+	name := s.Name
 	if q := pkgqual(s.Pkg, verb, mode); q != "" {
 		b.WriteString(q)
 		b.WriteByte('.')
+		if mode == fmtTypeIDName {
+			// If name is a generic instantiation, it might have local package placeholders
+			// in it. Replace those placeholders with the package name. See issue 49547.
+			name = strings.Replace(name, LocalPkg.Prefix, q, -1)
+		}
 	}
-	b.WriteString(s.Name)
+	b.WriteString(name)
 }
 
 // pkgqual returns the qualifier that should be used for printing
diff --git a/test/typeparam/issue49547.go b/test/typeparam/issue49547.go
new file mode 100644
index 0000000000..99c124d7ab
--- /dev/null
+++ b/test/typeparam/issue49547.go
@@ -0,0 +1,22 @@
+// run -gcflags=-G=3
+
+// 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 foo int
+
+func main() {
+	want := "main.F[main.foo]"
+	got := fmt.Sprintf("%T", F[foo]{})
+	if got != want {
+		fmt.Printf("want: %s, got: %s\n", want, got)
+	}
+}
+
+type F[T any] struct {
+}
diff --git a/test/typeparam/nested.out b/test/typeparam/nested.out
index 9110518248..37cb762e32 100644
--- a/test/typeparam/nested.out
+++ b/test/typeparam/nested.out
@@ -1,4 +1,4 @@
 0,3: main.T·2[int;int]
-4,7: main.T·2[int;"".U·3[int;int]]
-22,23: main.T·2["".Int;"".Int]
-26,27: main.T·2["".Int;"".U·3["".Int;"".Int]]
+4,7: main.T·2[int;main.U·3[int;int]]
+22,23: main.T·2[main.Int;main.Int]
+26,27: main.T·2[main.Int;main.U·3[main.Int;main.Int]]

From ce4a2755956a42aa3211c121139a52c9a97a9aa0 Mon Sep 17 00:00:00 2001
From: Cherry Mui 
Date: Fri, 12 Nov 2021 19:53:28 -0500
Subject: [PATCH 156/752] cmd/compile, runtime: mark R1 as clobbered for write
 barrier call

If the call to gcWriteBarrier is via PLT, the PLT stub will
clobber R1. Mark R1 clobbered.

For #49386.

Change-Id: I72df5bb3b8d10381fec5c567b15749aaf7d2ad70
Reviewed-on: https://go-review.googlesource.com/c/go/+/363698
Trust: Cherry Mui 
Run-TryBot: Cherry Mui 
TryBot-Result: Go Bot 
Reviewed-by: Michael Knyszek 
---
 src/cmd/compile/internal/ssa/gen/S390XOps.go |  5 +++--
 src/cmd/compile/internal/ssa/opGen.go        |  2 +-
 src/runtime/asm_s390x.s                      | 10 ++++------
 3 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/ssa/gen/S390XOps.go b/src/cmd/compile/internal/ssa/gen/S390XOps.go
index cd7bad7acb..eef8a2557c 100644
--- a/src/cmd/compile/internal/ssa/gen/S390XOps.go
+++ b/src/cmd/compile/internal/ssa/gen/S390XOps.go
@@ -509,8 +509,9 @@ func init() {
 
 		// LoweredWB invokes runtime.gcWriteBarrier. arg0=destptr, arg1=srcptr, arg2=mem, aux=runtime.gcWriteBarrier
 		// It saves all GP registers if necessary,
-		// but clobbers R14 (LR) because it's a call.
-		{name: "LoweredWB", argLength: 3, reg: regInfo{inputs: []regMask{buildReg("R2"), buildReg("R3")}, clobbers: (callerSave &^ gpg) | buildReg("R14")}, clobberFlags: true, aux: "Sym", symEffect: "None"},
+		// but clobbers R14 (LR) because it's a call,
+		// and also clobbers R1 as the PLT stub does.
+		{name: "LoweredWB", argLength: 3, reg: regInfo{inputs: []regMask{buildReg("R2"), buildReg("R3")}, clobbers: (callerSave &^ gpg) | buildReg("R14") | r1}, clobberFlags: true, aux: "Sym", symEffect: "None"},
 
 		// There are three of these functions so that they can have three different register inputs.
 		// When we check 0 <= c <= cap (A), then 0 <= b <= c (B), then 0 <= a <= b (C), we want the
diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 2038575b0c..81fe5d4c23 100644
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -32779,7 +32779,7 @@ var opcodeTable = [...]opInfo{
 				{0, 4}, // R2
 				{1, 8}, // R3
 			},
-			clobbers: 4294918144, // R14 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
+			clobbers: 4294918146, // R1 R14 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15
 		},
 	},
 	{
diff --git a/src/runtime/asm_s390x.s b/src/runtime/asm_s390x.s
index 5894fe5783..9159a67372 100644
--- a/src/runtime/asm_s390x.s
+++ b/src/runtime/asm_s390x.s
@@ -777,13 +777,12 @@ TEXT ·checkASM(SB),NOSPLIT,$0-1
 // gcWriteBarrier does NOT follow the Go ABI. It takes two arguments:
 // - R2 is the destination of the write
 // - R3 is the value being written at R2.
-// It clobbers R10 (the temp register).
+// It clobbers R10 (the temp register) and R1 (used by PLT stub).
 // It does not clobber any other general-purpose registers,
 // but may clobber others (e.g., floating point registers).
-TEXT runtime·gcWriteBarrier(SB),NOSPLIT,$104
+TEXT runtime·gcWriteBarrier(SB),NOSPLIT,$96
 	// Save the registers clobbered by the fast path.
-	MOVD	R1, 96(R15)
-	MOVD	R4, 104(R15)
+	MOVD	R4, 96(R15)
 	MOVD	g_m(g), R1
 	MOVD	m_p(R1), R1
 	// Increment wbBuf.next position.
@@ -798,8 +797,7 @@ TEXT runtime·gcWriteBarrier(SB),NOSPLIT,$104
 	// Is the buffer full?
 	CMPBEQ	R4, R1, flush
 ret:
-	MOVD	96(R15), R1
-	MOVD	104(R15), R4
+	MOVD	96(R15), R4
 	// Do the write.
 	MOVD	R3, (R2)
 	RET

From f986191325e9c8be606b5f4db69a33692728274b Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek 
Date: Thu, 11 Nov 2021 18:12:20 +0000
Subject: [PATCH 157/752] runtime: fix released bytes accumulation in bg
 scavenger

Currently "released" is not accumulated bytes released. If the last
attempt to scavenge ends up as 0, then the scavenger will go to sleep
too soon. This is an artifact from the old code where scavenge would
only be called into once.

Change-Id: I85aa2261f1504a6fb5bf086daa029eecb0e09cf4
Reviewed-on: https://go-review.googlesource.com/c/go/+/363416
Trust: Michael Knyszek 
Reviewed-by: Michael Pratt 
Run-TryBot: Michael Knyszek 
TryBot-Result: Go Bot 
---
 src/runtime/mgcscavenge.go | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/runtime/mgcscavenge.go b/src/runtime/mgcscavenge.go
index 4a7f2465fd..286aa1bbae 100644
--- a/src/runtime/mgcscavenge.go
+++ b/src/runtime/mgcscavenge.go
@@ -326,8 +326,8 @@ func bgscavenge(c chan int) {
 
 			// Accumulate the amount of time spent scavenging.
 			start := nanotime()
-			released = mheap_.pages.scavenge(scavengeQuantum)
-			atomic.Xadduintptr(&mheap_.pages.scav.released, released)
+			r := mheap_.pages.scavenge(scavengeQuantum)
+			atomic.Xadduintptr(&mheap_.pages.scav.released, r)
 			end := nanotime()
 
 			// On some platforms we may see end >= start if the time it takes to scavenge
@@ -339,10 +339,11 @@ func bgscavenge(c chan int) {
 			// on timing.
 			const approxCritNSPerPhysicalPage = 10e3
 			if end <= start {
-				crit += approxCritNSPerPhysicalPage * float64(released/physPageSize)
+				crit += approxCritNSPerPhysicalPage * float64(r/physPageSize)
 			} else {
 				crit += float64(end - start)
 			}
+			released += r
 		}
 
 		if released == 0 {

From 1dc9af5cdc6dabe4841afb4edf9dbf5124946ea0 Mon Sep 17 00:00:00 2001
From: Dan Scales 
Date: Sat, 13 Nov 2021 16:17:52 -0800
Subject: [PATCH 158/752] cmd/compile: fix position info for implicit nodes due
 to generics

The main fix is that we should call ir.SetPos() at the beginning of
(*subster).node.edit function, since that is analogous to the
ir.SetPos() at the beginning of typecheck.typecheck(). It ensures that
transform functions can use base.Pos() with appropriate results, just
like their corresponding tc*() functions do.

A small fix is to make sure that the new nodes creates for dictionary
references have the correct position based on the location of the
function call.

Another small fix is to the use of base.Pos when creating a new selector
expression (including implicit XDOTs) for a method expression in
buildClosure().

Also, I converted the final use of base.Pos in stencil.go to src.NoXPos,
since the nodes created by AddImplicitDots will be checked for their
type, but won't actually be used.

I also needed to add an ir.SetPos() at the beginning of transformCall(),
since transformCall() is called in the modify and dict passes, when we
base.Pos is not being set for each node.

This change fixes all the line numbering problems printed out from
Alessandro's program, except for auto-generated functions (which I think
are fine).

Fixes #49523

Change-Id: I9836a497b7beba25ecafdde653a6c2036a3020d3
Reviewed-on: https://go-review.googlesource.com/c/go/+/363835
Trust: Dan Scales 
Run-TryBot: Dan Scales 
TryBot-Result: Go Bot 
Reviewed-by: Keith Randall 
---
 src/cmd/compile/internal/noder/stencil.go   | 25 +++++++++++++--------
 src/cmd/compile/internal/noder/transform.go |  3 +++
 2 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 4f9f8107bc..174006ab5e 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -500,7 +500,7 @@ func (g *genInst) buildClosure(outer *ir.Func, x ir.Node) ir.Node {
 			// explicitly traverse any embedded fields in the receiver
 			// argument in order to call the method instantiation.
 			arg0 := formalParams[0].Nname.(ir.Node)
-			arg0 = typecheck.AddImplicitDots(ir.NewSelectorExpr(base.Pos, ir.OXDOT, arg0, x.(*ir.SelectorExpr).Sel)).X
+			arg0 = typecheck.AddImplicitDots(ir.NewSelectorExpr(x.Pos(), ir.OXDOT, arg0, x.(*ir.SelectorExpr).Sel)).X
 			if valueMethod && arg0.Type().IsPtr() {
 				// For handling the (*T).M case: if we have a pointer
 				// receiver after following all the embedded fields,
@@ -616,7 +616,7 @@ func (g *genInst) getDictOrSubdict(declInfo *instInfo, n ir.Node, nameNode *ir.N
 		}
 	}
 	if !usingSubdict {
-		dict = g.getDictionaryValue(nameNode, targs, isMeth)
+		dict = g.getDictionaryValue(n.Pos(), nameNode, targs, isMeth)
 	}
 	return dict, usingSubdict
 }
@@ -905,6 +905,10 @@ func (subst *subster) node(n ir.Node) ir.Node {
 	// Use closure to capture all state needed by the ir.EditChildren argument.
 	var edit func(ir.Node) ir.Node
 	edit = func(x ir.Node) ir.Node {
+		// Analogous to ir.SetPos() at beginning of typecheck.typecheck() -
+		// allows using base.Pos during the transform functions, just like
+		// the tc*() functions.
+		ir.SetPos(x)
 		switch x.Op() {
 		case ir.OTYPE:
 			return ir.TypeNode(subst.ts.Typ(x.Type()))
@@ -1555,9 +1559,9 @@ func (g *genInst) getDictionarySym(gf *ir.Name, targs []*types.Type, isMeth bool
 				if se.X.Type().IsShape() {
 					// This is a method call enabled by a type bound.
 
-					// We need this extra check for type expressions, which
-					// don't add in the implicit XDOTs.
-					tmpse := ir.NewSelectorExpr(base.Pos, ir.OXDOT, se.X, se.Sel)
+					// We need this extra check for method expressions,
+					// which don't add in the implicit XDOTs.
+					tmpse := ir.NewSelectorExpr(src.NoXPos, ir.OXDOT, se.X, se.Sel)
 					tmpse = typecheck.AddImplicitDots(tmpse)
 					tparam := tmpse.X.Type()
 					if !tparam.IsShape() {
@@ -1725,7 +1729,7 @@ func (g *genInst) finalizeSyms() {
 	g.dictSymsToFinalize = nil
 }
 
-func (g *genInst) getDictionaryValue(gf *ir.Name, targs []*types.Type, isMeth bool) ir.Node {
+func (g *genInst) getDictionaryValue(pos src.XPos, gf *ir.Name, targs []*types.Type, isMeth bool) ir.Node {
 	sym := g.getDictionarySym(gf, targs, isMeth)
 
 	// Make (or reuse) a node referencing the dictionary symbol.
@@ -1733,15 +1737,18 @@ func (g *genInst) getDictionaryValue(gf *ir.Name, targs []*types.Type, isMeth bo
 	if sym.Def != nil {
 		n = sym.Def.(*ir.Name)
 	} else {
-		n = typecheck.NewName(sym)
+		// We set the position of a static dictionary to be the position of
+		// one of its uses.
+		n = ir.NewNameAt(pos, sym)
+		n.Curfn = ir.CurFunc
 		n.SetType(types.Types[types.TUINTPTR]) // should probably be [...]uintptr, but doesn't really matter
 		n.SetTypecheck(1)
 		n.Class = ir.PEXTERN
 		sym.Def = n
 	}
 
-	// Return the address of the dictionary.
-	np := typecheck.NodAddr(n)
+	// Return the address of the dictionary.  Addr node gets position that was passed in.
+	np := typecheck.NodAddrAt(pos, n)
 	// Note: treat dictionary pointers as uintptrs, so they aren't pointers
 	// with respect to GC. That saves on stack scanning work, write barriers, etc.
 	// We can get away with it because dictionaries are global variables.
diff --git a/src/cmd/compile/internal/noder/transform.go b/src/cmd/compile/internal/noder/transform.go
index 47e6397206..a673484821 100644
--- a/src/cmd/compile/internal/noder/transform.go
+++ b/src/cmd/compile/internal/noder/transform.go
@@ -133,6 +133,9 @@ func transformConvCall(n *ir.CallExpr) ir.Node {
 // (non-conversion, non-builtin part) of typecheck.tcCall. This code should work even
 // in the case of OCALL/OFUNCINST.
 func transformCall(n *ir.CallExpr) {
+	// Set base.Pos, since transformArgs below may need it, but transformCall
+	// is called in some passes that don't set base.Pos.
+	ir.SetPos(n)
 	// n.Type() can be nil for calls with no return value
 	assert(n.Typecheck() == 1)
 	transformArgs(n)

From 0e654100382f345ea555cfc1e1dd50853316b368 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Sun, 14 Nov 2021 20:34:58 -0500
Subject: [PATCH 159/752] go/types: assign error codes to new errors for Go
 1.18

During development, we used placeholder _Todo error codes for new
errors related to generics. Add real error codes in these places.

As a result, 9 new error codes are added for ~50 call sites.

Change-Id: Ib57b4cd9f0a2e160971a3aeea18f9fe26fc0f835
Reviewed-on: https://go-review.googlesource.com/c/go/+/363874
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/assignments.go     |  2 +-
 src/go/types/builtins.go        |  2 +-
 src/go/types/call.go            | 14 +++---
 src/go/types/decl.go            | 10 ++--
 src/go/types/errorcodes.go      | 84 +++++++++++++++++++++++++++++++++
 src/go/types/errorcodes_test.go |  6 ++-
 src/go/types/expr.go            |  8 ++--
 src/go/types/infer.go           | 14 ++++--
 src/go/types/instantiate.go     |  2 +-
 src/go/types/interface.go       |  2 +-
 src/go/types/resolver.go        |  6 +--
 src/go/types/signature.go       |  4 +-
 src/go/types/stmt.go            |  2 +-
 src/go/types/struct.go          |  9 ++--
 src/go/types/typeset.go         |  6 +--
 src/go/types/typexpr.go         | 10 ++--
 src/go/types/union.go           | 12 ++---
 17 files changed, 142 insertions(+), 51 deletions(-)

diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index 923bd43b49..d77cf8f7fa 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -72,7 +72,7 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 
 	// A generic (non-instantiated) function value cannot be assigned to a variable.
 	if sig, _ := under(x.typ).(*Signature); sig != nil && sig.TypeParams().Len() > 0 {
-		check.errorf(x, _Todo, "cannot use generic function %s without instantiation in %s", x, context)
+		check.errorf(x, _WrongTypeArgCount, "cannot use generic function %s without instantiation in %s", x, context)
 	}
 
 	// spec: "If a left-hand side is the blank identifier, any typed or
diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index 4d3ff26b14..c2d36e9711 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -370,7 +370,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 				return false
 			}
 			if key != nil && !Identical(map_.key, key) {
-				check.invalidArg(x, _Todo, "maps of %s must have identical key types", x)
+				check.invalidArg(x, _InvalidDelete, "maps of %s must have identical key types", x)
 				return false
 			}
 			key = map_.key
diff --git a/src/go/types/call.go b/src/go/types/call.go
index da4b72a0c7..927c9f2a44 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -18,7 +18,7 @@ import (
 // The operand x must be the evaluation of inst.X and its type must be a signature.
 func (check *Checker) funcInst(x *operand, ix *typeparams.IndexExpr) {
 	if !check.allowVersion(check.pkg, 1, 18) {
-		check.softErrorf(inNode(ix.Orig, ix.Lbrack), _Todo, "function instantiation requires go1.18 or later")
+		check.softErrorf(inNode(ix.Orig, ix.Lbrack), _UnsupportedFeature, "function instantiation requires go1.18 or later")
 	}
 
 	targs := check.typeList(ix.Indices)
@@ -33,7 +33,7 @@ func (check *Checker) funcInst(x *operand, ix *typeparams.IndexExpr) {
 	sig := x.typ.(*Signature)
 	got, want := len(targs), sig.TypeParams().Len()
 	if got > want {
-		check.errorf(ix.Indices[got-1], _Todo, "got %d type arguments but want %d", got, want)
+		check.errorf(ix.Indices[got-1], _WrongTypeArgCount, "got %d type arguments but want %d", got, want)
 		x.mode = invalid
 		x.expr = ix.Orig
 		return
@@ -90,7 +90,7 @@ func (check *Checker) instantiateSignature(pos token.Pos, typ *Signature, targs
 		if i < len(posList) {
 			pos = posList[i]
 		}
-		check.softErrorf(atPos(pos), _Todo, err.Error())
+		check.softErrorf(atPos(pos), _InvalidTypeArg, err.Error())
 	} else {
 		check.mono.recordInstance(check.pkg, pos, tparams, targs, posList)
 	}
@@ -143,7 +143,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 				}
 				if t, _ := under(T).(*Interface); t != nil {
 					if !t.IsMethodSet() {
-						check.errorf(call, _Todo, "cannot use interface %s in conversion (contains specific type constraints or is comparable)", T)
+						check.errorf(call, _MisplacedConstraintIface, "cannot use interface %s in conversion (contains specific type constraints or is comparable)", T)
 						break
 					}
 				}
@@ -198,7 +198,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 		// check number of type arguments (got) vs number of type parameters (want)
 		got, want := len(targs), sig.TypeParams().Len()
 		if got > want {
-			check.errorf(ix.Indices[want], _Todo, "got %d type arguments but want %d", got, want)
+			check.errorf(ix.Indices[want], _WrongTypeArgCount, "got %d type arguments but want %d", got, want)
 			check.use(call.Args...)
 			x.mode = invalid
 			x.expr = call
@@ -370,9 +370,9 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, targs []Type
 			switch call.Fun.(type) {
 			case *ast.IndexExpr, *ast.IndexListExpr:
 				ix := typeparams.UnpackIndexExpr(call.Fun)
-				check.softErrorf(inNode(call.Fun, ix.Lbrack), _Todo, "function instantiation requires go1.18 or later")
+				check.softErrorf(inNode(call.Fun, ix.Lbrack), _UnsupportedFeature, "function instantiation requires go1.18 or later")
 			default:
-				check.softErrorf(inNode(call, call.Lparen), _Todo, "implicit function instantiation requires go1.18 or later")
+				check.softErrorf(inNode(call, call.Lparen), _UnsupportedFeature, "implicit function instantiation requires go1.18 or later")
 			}
 		}
 		// TODO(gri) provide position information for targs so we can feed
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 7e89e7be3a..e12961416e 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -623,7 +623,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
 		check.validType(obj.typ, nil)
 		// If typ is local, an error was already reported where typ is specified/defined.
 		if check.isImportedConstraint(rhs) && !check.allowVersion(check.pkg, 1, 18) {
-			check.errorf(tdecl.Type, _Todo, "using type constraint %s requires go1.18 or later", rhs)
+			check.errorf(tdecl.Type, _UnsupportedFeature, "using type constraint %s requires go1.18 or later", rhs)
 		}
 	}).describef(obj, "validType(%s)", obj.Name())
 
@@ -631,7 +631,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
 	if alias && tdecl.TypeParams.NumFields() != 0 {
 		// The parser will ensure this but we may still get an invalid AST.
 		// Complain and continue as regular type definition.
-		check.error(atPos(tdecl.Assign), _Todo, "generic type cannot be alias")
+		check.error(atPos(tdecl.Assign), _BadDecl, "generic type cannot be alias")
 		alias = false
 	}
 
@@ -673,7 +673,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
 	// type (underlying not fully resolved yet) it cannot become a type parameter due
 	// to this very restriction.
 	if tpar, _ := named.underlying.(*TypeParam); tpar != nil {
-		check.error(tdecl.Type, _Todo, "cannot use a type parameter as RHS in type declaration")
+		check.error(tdecl.Type, _MisplacedTypeParam, "cannot use a type parameter as RHS in type declaration")
 		named.underlying = Typ[Invalid]
 	}
 }
@@ -724,7 +724,7 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list *ast.FieldList
 	check.later(func() {
 		for i, bound := range bounds {
 			if _, ok := under(bound).(*TypeParam); ok {
-				check.error(posns[i], _Todo, "cannot use a type parameter as constraint")
+				check.error(posns[i], _MisplacedTypeParam, "cannot use a type parameter as constraint")
 			}
 		}
 		for _, tpar := range tparams {
@@ -861,7 +861,7 @@ func (check *Checker) funcDecl(obj *Func, decl *declInfo) {
 	obj.color_ = saved
 
 	if fdecl.Type.TypeParams.NumFields() > 0 && fdecl.Body == nil {
-		check.softErrorf(fdecl.Name, _Todo, "parameterized function is missing function body")
+		check.softErrorf(fdecl.Name, _BadDecl, "parameterized function is missing function body")
 	}
 
 	// function body must be type-checked after global declarations
diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index 88dd0fda2f..cbf00ba0b4 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -1301,6 +1301,54 @@ const (
 	//  var _ = unsafe.Slice(&x, uint64(1) << 63)
 	_InvalidUnsafeSlice
 
+	// All codes below were added in Go 1.18.
+
+	// _UnsupportedFeature occurs when a language feature is used that is not
+	// supported at this Go version.
+	_UnsupportedFeature
+
+	// _WrongTypeArgCount occurs when a type or function is instantiated with an
+	// incorrent number of type arguments, including when a generic type or
+	// function is used without instantiation.
+	//
+	// Errors inolving failed type inference are assigned other error codes.
+	//
+	// Example:
+	//  type T[p any] int
+	//
+	//  var _ T[int, string]
+	//
+	// Example:
+	//  func f[T any]() {}
+	//
+	//  var x = f
+	_WrongTypeArgCount
+
+	// _CannotInferTypeArgs occurs when type or function type argument inference
+	// fails to infer all type arguments.
+	//
+	// Example:
+	//  func f[T any]() {}
+	//
+	//  func _() {
+	//  	f()
+	//  }
+	//
+	// Example:
+	//   type N[P, Q any] struct{}
+	//
+	//   var _ N[int]
+	_CannotInferTypeArgs
+
+	// _InvalidTypeArg occurs when a type argument does not satisfy its
+	// corresponding type parameter constraints.
+	//
+	// Example:
+	//  type T[P ~int] struct{}
+	//
+	//  var _ T[string]
+	_InvalidTypeArg // arguments? InferenceFailed
+
 	// _InvalidInstanceCycle occurs when an invalid cycle is detected
 	// within the instantiation graph.
 	//
@@ -1308,6 +1356,42 @@ const (
 	//  func f[T any]() { f[*T]() }
 	_InvalidInstanceCycle
 
+	// _InvalidUnion occurs when an embedded union or approximation element is
+	// not valid.
+	//
+	// Example:
+	//  type _ interface {
+	//   	~int | interface{ m() }
+	//  }
+	_InvalidUnion
+
+	// _MisplacedConstraintIface occurs when a constraint-type interface is used
+	// outside of constraint position.
+	//
+	// Example:
+	//   type I interface { ~int }
+	//
+	//   var _ I
+	_MisplacedConstraintIface
+
+	// _InvalidMethodTypeParams occurs when methods have type parameters.
+	//
+	// Example:
+	//  type T int
+	//
+	//  func (T) m[P any]() {}
+	_InvalidMethodTypeParams
+
+	// _MisplacedTypeParam occurs when a type parameter is used in a place where
+	// it is not permitted.
+	//
+	// Example:
+	//  type T[P any] P
+	//
+	// Example:
+	//  type T[P any] struct{ *P }
+	_MisplacedTypeParam
+
 	// _Todo is a placeholder for error codes that have not been decided.
 	// TODO(rFindley) remove this error code after deciding on errors for generics code.
 	_Todo
diff --git a/src/go/types/errorcodes_test.go b/src/go/types/errorcodes_test.go
index 5da1cdadfc..629eac4912 100644
--- a/src/go/types/errorcodes_test.go
+++ b/src/go/types/errorcodes_test.go
@@ -171,8 +171,10 @@ func TestErrorCodeStyle(t *testing.T) {
 			}
 		}
 		doc := spec.Doc.Text()
-		if !strings.HasPrefix(doc, name) {
-			t.Errorf("doc for %q does not start with identifier", name)
+		if doc == "" {
+			t.Errorf("%q is undocumented", name)
+		} else if !strings.HasPrefix(doc, name) {
+			t.Errorf("doc for %q does not start with the error code name", name)
 		}
 		lowerComment := strings.ToLower(strings.TrimPrefix(doc, name))
 		for _, bad := range forbiddenInComment {
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 138eb2f521..9d9eddfb95 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -186,7 +186,7 @@ func (check *Checker) unary(x *operand, e *ast.UnaryExpr) {
 				return false
 			}
 			if elem != nil && !Identical(ch.elem, elem) {
-				check.invalidOp(x, _Todo, "channels of %s must have the same element type", x)
+				check.invalidOp(x, _InvalidReceive, "channels of %s must have the same element type", x)
 				return false
 			}
 			elem = ch.elem
@@ -1116,7 +1116,7 @@ func (check *Checker) nonGeneric(x *operand) {
 		}
 	}
 	if what != "" {
-		check.errorf(x.expr, _Todo, "cannot use generic %s %s without instantiation", what, x.expr)
+		check.errorf(x.expr, _WrongTypeArgCount, "cannot use generic %s %s without instantiation", what, x.expr)
 		x.mode = invalid
 		x.typ = Typ[Invalid]
 	}
@@ -1233,7 +1233,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 			// Prevent crash if the struct referred to is not yet set up.
 			// See analogous comment for *Array.
 			if utyp.fields == nil {
-				check.error(e, _Todo, "illegal cycle in type declaration")
+				check.error(e, _InvalidDeclCycle, "illegal cycle in type declaration")
 				goto Error
 			}
 			if len(e.Elts) == 0 {
@@ -1472,7 +1472,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 					return false
 				}
 				if base != nil && !Identical(p.base, base) {
-					check.invalidOp(x, _Todo, "pointers of %s must have identical base types", x)
+					check.invalidOp(x, _InvalidIndirection, "pointers of %s must have identical base types", x)
 					return false
 				}
 				base = p.base
diff --git a/src/go/types/infer.go b/src/go/types/infer.go
index 41326a1be8..f4f9bfac8f 100644
--- a/src/go/types/infer.go
+++ b/src/go/types/infer.go
@@ -118,17 +118,21 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type,
 				}
 			}
 			if allFailed {
-				check.errorf(arg, _Todo, "%s %s of %s does not match %s (cannot infer %s)", kind, targ, arg.expr, tpar, typeParamsString(tparams))
+				check.errorf(arg, _CannotInferTypeArgs, "%s %s of %s does not match %s (cannot infer %s)", kind, targ, arg.expr, tpar, typeParamsString(tparams))
 				return
 			}
 		}
 		smap := makeSubstMap(tparams, targs)
 		// TODO(rFindley): pass a positioner here, rather than arg.Pos().
 		inferred := check.subst(arg.Pos(), tpar, smap, nil)
+		// _CannotInferTypeArgs indicates a failure of inference, though the actual
+		// error may be better attributed to a user-provided type argument (hence
+		// _InvalidTypeArg). We can't differentiate these cases, so fall back on
+		// the more general _CannotInferTypeArgs.
 		if inferred != tpar {
-			check.errorf(arg, _Todo, "%s %s of %s does not match inferred type %s for %s", kind, targ, arg.expr, inferred, tpar)
+			check.errorf(arg, _CannotInferTypeArgs, "%s %s of %s does not match inferred type %s for %s", kind, targ, arg.expr, inferred, tpar)
 		} else {
-			check.errorf(arg, _Todo, "%s %s of %s does not match %s", kind, targ, arg.expr, tpar)
+			check.errorf(arg, _CannotInferTypeArgs, "%s %s of %s does not match %s", kind, targ, arg.expr, tpar)
 		}
 	}
 
@@ -214,7 +218,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type,
 	// At least one type argument couldn't be inferred.
 	assert(index >= 0 && targs[index] == nil)
 	tpar := tparams[index]
-	check.errorf(posn, _Todo, "cannot infer %s (%v)", tpar.obj.name, tpar.obj.pos)
+	check.errorf(posn, _CannotInferTypeArgs, "cannot infer %s (%v)", tpar.obj.name, tpar.obj.pos)
 	return nil
 }
 
@@ -383,7 +387,7 @@ func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type,
 			if !u.unify(tpar, sbound) {
 				// TODO(gri) improve error message by providing the type arguments
 				//           which we know already
-				check.errorf(tpar.obj, _Todo, "%s does not match %s", tpar, sbound)
+				check.errorf(tpar.obj, _InvalidTypeArg, "%s does not match %s", tpar, sbound)
 				return nil, 0
 			}
 		}
diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index 2d2d1718f4..13d6e3114d 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -124,7 +124,7 @@ func (check *Checker) validateTArgLen(pos token.Pos, ntparams, ntargs int) bool
 	if ntargs != ntparams {
 		// TODO(gri) provide better error message
 		if check != nil {
-			check.errorf(atPos(pos), _Todo, "got %d arguments but %d type parameters", ntargs, ntparams)
+			check.errorf(atPos(pos), _WrongTypeArgCount, "got %d arguments but %d type parameters", ntargs, ntparams)
 			return false
 		}
 		panic(fmt.Sprintf("%v: got %d arguments but %d type parameters", pos, ntargs, ntparams))
diff --git a/src/go/types/interface.go b/src/go/types/interface.go
index 78813e665b..ef65bc6b2b 100644
--- a/src/go/types/interface.go
+++ b/src/go/types/interface.go
@@ -181,7 +181,7 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d
 			if ftyp, _ := f.Type.(*ast.FuncType); ftyp != nil && ftyp.TypeParams != nil {
 				at = ftyp.TypeParams
 			}
-			check.errorf(at, _Todo, "methods cannot have type parameters")
+			check.errorf(at, _InvalidMethodTypeParams, "methods cannot have type parameters")
 		}
 
 		// use named receiver type if available (for better error messages)
diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go
index 5a82b4fd9c..7a2dcbffbb 100644
--- a/src/go/types/resolver.go
+++ b/src/go/types/resolver.go
@@ -382,7 +382,7 @@ func (check *Checker) collectObjects() {
 				}
 			case typeDecl:
 				if d.spec.TypeParams.NumFields() != 0 && !check.allowVersion(pkg, 1, 18) {
-					check.softErrorf(d.spec.TypeParams.List[0], _Todo, "type parameters require go1.18 or later")
+					check.softErrorf(d.spec.TypeParams.List[0], _UnsupportedFeature, "type parameters require go1.18 or later")
 				}
 				obj := NewTypeName(d.spec.Name.Pos(), pkg, d.spec.Name.Name, nil)
 				check.declarePkgObj(d.spec.Name, obj, &declInfo{file: fileScope, tdecl: d.spec})
@@ -440,7 +440,7 @@ func (check *Checker) collectObjects() {
 					check.recordDef(d.decl.Name, obj)
 				}
 				if d.decl.Type.TypeParams.NumFields() != 0 && !check.allowVersion(pkg, 1, 18) && !hasTParamError {
-					check.softErrorf(d.decl.Type.TypeParams.List[0], _Todo, "type parameters require go1.18 or later")
+					check.softErrorf(d.decl.Type.TypeParams.List[0], _UnsupportedFeature, "type parameters require go1.18 or later")
 				}
 				info := &declInfo{file: fileScope, fdecl: d.decl}
 				// Methods are not package-level objects but we still track them in the
@@ -527,7 +527,7 @@ L: // unpack receiver type
 				case nil:
 					check.invalidAST(ix.Orig, "parameterized receiver contains nil parameters")
 				default:
-					check.errorf(arg, _Todo, "receiver type parameter %s must be an identifier", arg)
+					check.errorf(arg, _BadDecl, "receiver type parameter %s must be an identifier", arg)
 				}
 				if par == nil {
 					par = &ast.Ident{NamePos: arg.Pos(), Name: "_"}
diff --git a/src/go/types/signature.go b/src/go/types/signature.go
index 698b89c462..306d86c0b7 100644
--- a/src/go/types/signature.go
+++ b/src/go/types/signature.go
@@ -168,7 +168,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 		// (A separate check is needed when type-checking interface method signatures because
 		// they don't have a receiver specification.)
 		if recvPar != nil {
-			check.errorf(ftyp.TypeParams, _Todo, "methods cannot have type parameters")
+			check.errorf(ftyp.TypeParams, _InvalidMethodTypeParams, "methods cannot have type parameters")
 		}
 	}
 
@@ -215,7 +215,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 				// The receiver type may be an instantiated type referred to
 				// by an alias (which cannot have receiver parameters for now).
 				if T.TypeArgs() != nil && sig.RecvTypeParams() == nil {
-					check.errorf(atPos(recv.pos), _Todo, "cannot define methods on instantiated type %s", recv.typ)
+					check.errorf(atPos(recv.pos), _InvalidRecv, "cannot define methods on instantiated type %s", recv.typ)
 					break
 				}
 				// spec: "The type denoted by T is called the receiver base type; it must not
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index c000d935d6..2a3fb5f6f5 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -429,7 +429,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 				return false
 			}
 			if elem != nil && !Identical(uch.elem, elem) {
-				check.invalidOp(inNode(s, s.Arrow), _Todo, "channels of %s must have the same element type", &ch)
+				check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "channels of %s must have the same element type", &ch)
 				return false
 			}
 			elem = uch.elem
diff --git a/src/go/types/struct.go b/src/go/types/struct.go
index 60640ac578..84af8a3f48 100644
--- a/src/go/types/struct.go
+++ b/src/go/types/struct.go
@@ -124,9 +124,7 @@ func (check *Checker) structType(styp *Struct, e *ast.StructType) {
 			pos := f.Type.Pos()
 			name := embeddedFieldIdent(f.Type)
 			if name == nil {
-				// TODO(rFindley): using invalidAST here causes test failures (all
-				//                 errors should have codes). Clean this up.
-				check.errorf(f.Type, _Todo, "invalid AST: embedded field type %s has no name", f.Type)
+				check.invalidAST(f.Type, "embedded field type %s has no name", f.Type)
 				name = ast.NewIdent("_")
 				name.NamePos = pos
 				addInvalid(name, pos)
@@ -158,7 +156,10 @@ func (check *Checker) structType(styp *Struct, e *ast.StructType) {
 				case *Pointer:
 					check.error(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer")
 				case *TypeParam:
-					check.error(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a (pointer to a) type parameter")
+					// This error code here is inconsistent with other error codes for
+					// invalid embedding, because this restriction may be relaxed in the
+					// future, and so it did not warrant a new error code.
+					check.error(embeddedPos, _MisplacedTypeParam, "embedded field type cannot be a (pointer to a) type parameter")
 				case *Interface:
 					if isPtr {
 						check.error(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer to an interface")
diff --git a/src/go/types/typeset.go b/src/go/types/typeset.go
index f8e76ed400..1e6b9dd390 100644
--- a/src/go/types/typeset.go
+++ b/src/go/types/typeset.go
@@ -269,7 +269,7 @@ func computeInterfaceTypeSet(check *Checker, pos token.Pos, ityp *Interface) *_T
 			tset := computeInterfaceTypeSet(check, pos, u)
 			// If typ is local, an error was already reported where typ is specified/defined.
 			if check != nil && check.isImportedConstraint(typ) && !check.allowVersion(check.pkg, 1, 18) {
-				check.errorf(atPos(pos), _Todo, "embedding constraint interface %s requires go1.18 or later", typ)
+				check.errorf(atPos(pos), _UnsupportedFeature, "embedding constraint interface %s requires go1.18 or later", typ)
 				continue
 			}
 			if tset.comparable {
@@ -281,7 +281,7 @@ func computeInterfaceTypeSet(check *Checker, pos token.Pos, ityp *Interface) *_T
 			terms = tset.terms
 		case *Union:
 			if check != nil && !check.allowVersion(check.pkg, 1, 18) {
-				check.errorf(atPos(pos), _Todo, "embedding interface element %s requires go1.18 or later", u)
+				check.errorf(atPos(pos), _InvalidIfaceEmbed, "embedding interface element %s requires go1.18 or later", u)
 				continue
 			}
 			tset := computeUnionTypeSet(check, pos, u)
@@ -385,7 +385,7 @@ func computeUnionTypeSet(check *Checker, pos token.Pos, utyp *Union) *_TypeSet {
 		allTerms = allTerms.union(terms)
 		if len(allTerms) > maxTermCount {
 			if check != nil {
-				check.errorf(atPos(pos), _Todo, "cannot handle more than %d union terms (implementation limitation)", maxTermCount)
+				check.errorf(atPos(pos), _InvalidUnion, "cannot handle more than %d union terms (implementation limitation)", maxTermCount)
 			}
 			utyp.tset = &invalidTypeSet
 			return utyp.tset
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index cff9917185..c89e69db7b 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -149,9 +149,9 @@ func (check *Checker) varType(e ast.Expr) Type {
 			tset := computeInterfaceTypeSet(check, e.Pos(), t) // TODO(gri) is this the correct position?
 			if !tset.IsMethodSet() {
 				if tset.comparable {
-					check.softErrorf(e, _Todo, "interface is (or embeds) comparable")
+					check.softErrorf(e, _MisplacedConstraintIface, "interface is (or embeds) comparable")
 				} else {
-					check.softErrorf(e, _Todo, "interface contains type constraints")
+					check.softErrorf(e, _MisplacedConstraintIface, "interface contains type constraints")
 				}
 			}
 		}
@@ -169,7 +169,7 @@ func (check *Checker) definedType(e ast.Expr, def *Named) Type {
 	typ := check.typInternal(e, def)
 	assert(isTyped(typ))
 	if isGeneric(typ) {
-		check.errorf(e, _Todo, "cannot use generic type %s without instantiation", typ)
+		check.errorf(e, _WrongTypeArgCount, "cannot use generic type %s without instantiation", typ)
 		typ = Typ[Invalid]
 	}
 	check.recordTypeAndValue(e, typexpr, typ, nil)
@@ -261,7 +261,7 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 	case *ast.IndexExpr, *ast.IndexListExpr:
 		ix := typeparams.UnpackIndexExpr(e)
 		if !check.allowVersion(check.pkg, 1, 18) {
-			check.softErrorf(inNode(e, ix.Lbrack), _Todo, "type instantiation requires go1.18 or later")
+			check.softErrorf(inNode(e, ix.Lbrack), _UnsupportedFeature, "type instantiation requires go1.18 or later")
 		}
 		return check.instantiatedType(ix.X, ix.Indices, def)
 
@@ -459,7 +459,7 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 				if i < len(posList) {
 					pos = posList[i]
 				}
-				check.softErrorf(atPos(pos), _Todo, err.Error())
+				check.softErrorf(atPos(pos), _InvalidTypeArg, err.Error())
 			} else {
 				check.mono.recordInstance(check.pkg, x.Pos(), inst.tparams.list(), inst.targs.list(), posList)
 			}
diff --git a/src/go/types/union.go b/src/go/types/union.go
index c715839315..bb08174728 100644
--- a/src/go/types/union.go
+++ b/src/go/types/union.go
@@ -63,7 +63,7 @@ func parseUnion(check *Checker, tlist []ast.Expr) Type {
 			return typ
 		}
 		if len(terms) >= maxTermCount {
-			check.errorf(x, _Todo, "cannot handle more than %d union terms (implementation limitation)", maxTermCount)
+			check.errorf(x, _InvalidUnion, "cannot handle more than %d union terms (implementation limitation)", maxTermCount)
 			return Typ[Invalid]
 		}
 		terms = append(terms, NewTerm(tilde, typ))
@@ -82,12 +82,12 @@ func parseUnion(check *Checker, tlist []ast.Expr) Type {
 			f, _ := u.(*Interface)
 			if t.tilde {
 				if f != nil {
-					check.errorf(tlist[i], _Todo, "invalid use of ~ (%s is an interface)", t.typ)
+					check.errorf(tlist[i], _InvalidUnion, "invalid use of ~ (%s is an interface)", t.typ)
 					continue // don't report another error for t
 				}
 
 				if !Identical(u, t.typ) {
-					check.errorf(tlist[i], _Todo, "invalid use of ~ (underlying type of %s is %s)", t.typ, u)
+					check.errorf(tlist[i], _InvalidUnion, "invalid use of ~ (underlying type of %s is %s)", t.typ, u)
 					continue // don't report another error for t
 				}
 			}
@@ -96,14 +96,14 @@ func parseUnion(check *Checker, tlist []ast.Expr) Type {
 			// in the beginning. Embedded interfaces with tilde are excluded above. If we reach
 			// here, we must have at least two terms in the union.
 			if f != nil && !f.typeSet().IsTypeSet() {
-				check.errorf(tlist[i], _Todo, "cannot use %s in union (interface contains methods)", t)
+				check.errorf(tlist[i], _InvalidUnion, "cannot use %s in union (interface contains methods)", t)
 				continue // don't report another error for t
 			}
 
 			// Report overlapping (non-disjoint) terms such as
 			// a|a, a|~a, ~a|~a, and ~a|A (where under(A) == a).
 			if j := overlappingTerm(terms[:i], t); j >= 0 {
-				check.softErrorf(tlist[i], _Todo, "overlapping terms %s and %s", t, terms[j])
+				check.softErrorf(tlist[i], _InvalidUnion, "overlapping terms %s and %s", t, terms[j])
 			}
 		}
 	})
@@ -124,7 +124,7 @@ func parseTilde(check *Checker, x ast.Expr) (tilde bool, typ Type) {
 	//       check to later and could return Typ[Invalid] instead.
 	check.later(func() {
 		if _, ok := under(typ).(*TypeParam); ok {
-			check.error(x, _Todo, "cannot embed a type parameter")
+			check.error(x, _MisplacedTypeParam, "cannot embed a type parameter")
 		}
 	})
 	return

From b6342a02ad901e015e1c4eb9f862824029efb7b7 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 15 Nov 2021 10:49:54 -0500
Subject: [PATCH 160/752] go/types: return an error message from
 Checker.genericType

The bare error message "%s is not a generic type" is probably never
sufficient, so change the signature of genericType to instead return an
message that may be formatted as additional context in errors.

Along the way, refactor instantiatedType to have access to the entire
index expression.

Fixes #48827

Change-Id: I0c455c1ce46ac3f1ef2990c997da19e5fc6c4eae
Reviewed-on: https://go-review.googlesource.com/c/go/+/363994
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/errorcodes.go                    | 13 +++--
 src/go/types/signature.go                     |  2 +-
 .../types/testdata/fixedbugs/issue48827.go2   | 19 ++++++++
 src/go/types/typexpr.go                       | 47 +++++++++++--------
 4 files changed, 56 insertions(+), 25 deletions(-)
 create mode 100644 src/go/types/testdata/fixedbugs/issue48827.go2

diff --git a/src/go/types/errorcodes.go b/src/go/types/errorcodes.go
index cbf00ba0b4..b3796e8919 100644
--- a/src/go/types/errorcodes.go
+++ b/src/go/types/errorcodes.go
@@ -1307,6 +1307,15 @@ const (
 	// supported at this Go version.
 	_UnsupportedFeature
 
+	// _NotAGenericType occurs when a non-generic type is used where a generic
+	// type is expected: in type or function instantiation.
+	//
+	// Example:
+	//  type T int
+	//
+	//  var _ T[int]
+	_NotAGenericType
+
 	// _WrongTypeArgCount occurs when a type or function is instantiated with an
 	// incorrent number of type arguments, including when a generic type or
 	// function is used without instantiation.
@@ -1391,8 +1400,4 @@ const (
 	// Example:
 	//  type T[P any] struct{ *P }
 	_MisplacedTypeParam
-
-	// _Todo is a placeholder for error codes that have not been decided.
-	// TODO(rFindley) remove this error code after deciding on errors for generics code.
-	_Todo
 )
diff --git a/src/go/types/signature.go b/src/go/types/signature.go
index 306d86c0b7..8f89e931fb 100644
--- a/src/go/types/signature.go
+++ b/src/go/types/signature.go
@@ -137,7 +137,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast
 				// Also: Don't report an error via genericType since it will be reported
 				//       again when we type-check the signature.
 				// TODO(gri) maybe the receiver should be marked as invalid instead?
-				if recv, _ := check.genericType(rname, false).(*Named); recv != nil {
+				if recv, _ := check.genericType(rname, nil).(*Named); recv != nil {
 					recvTParams = recv.TypeParams().list()
 				}
 			}
diff --git a/src/go/types/testdata/fixedbugs/issue48827.go2 b/src/go/types/testdata/fixedbugs/issue48827.go2
new file mode 100644
index 0000000000..aa1d12aaf5
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue48827.go2
@@ -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 p
+
+type G[P any] int
+
+type (
+	_ G[int]
+	_ G[G /* ERROR "cannot use.*without instantiation" */]
+	_ bool /* ERROR "invalid operation: bool\[int\] \(bool is not a generic type\)" */ [int]
+	_ bool /* ERROR "invalid operation: bool\[G\] \(bool is not a generic type\)" */[G]
+)
+
+// The example from the issue.
+func _() {
+	_ = &([10]bool /* ERROR "invalid operation.*bool is not a generic type" */ [1 /* ERROR "expected type" */ ]{})
+}
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index c89e69db7b..d80acbe7d6 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -176,13 +176,15 @@ func (check *Checker) definedType(e ast.Expr, def *Named) Type {
 	return typ
 }
 
-// genericType is like typ but the type must be an (uninstantiated) generic type.
-func (check *Checker) genericType(e ast.Expr, reportErr bool) Type {
+// genericType is like typ but the type must be an (uninstantiated) generic
+// type. If reason is non-nil and the type expression was a valid type but not
+// generic, reason will be populated with a message describing the error.
+func (check *Checker) genericType(e ast.Expr, reason *string) Type {
 	typ := check.typInternal(e, nil)
 	assert(isTyped(typ))
 	if typ != Typ[Invalid] && !isGeneric(typ) {
-		if reportErr {
-			check.errorf(e, _Todo, "%s is not a generic type", typ)
+		if reason != nil {
+			*reason = check.sprintf("%s is not a generic type", typ)
 		}
 		typ = Typ[Invalid]
 	}
@@ -263,7 +265,7 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 		if !check.allowVersion(check.pkg, 1, 18) {
 			check.softErrorf(inNode(e, ix.Lbrack), _UnsupportedFeature, "type instantiation requires go1.18 or later")
 		}
-		return check.instantiatedType(ix.X, ix.Indices, def)
+		return check.instantiatedType(ix, def)
 
 	case *ast.ParenExpr:
 		// Generic types must be instantiated before they can be used in any form.
@@ -374,29 +376,34 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 	return typ
 }
 
-func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named) (res Type) {
+func (check *Checker) instantiatedType(ix *typeparams.IndexExpr, def *Named) (res Type) {
+	pos := ix.X.Pos()
 	if trace {
-		check.trace(x.Pos(), "-- instantiating %s with %s", x, targsx)
+		check.trace(pos, "-- instantiating %s with %s", ix.X, ix.Indices)
 		check.indent++
 		defer func() {
 			check.indent--
 			// Don't format the underlying here. It will always be nil.
-			check.trace(x.Pos(), "=> %s", res)
+			check.trace(pos, "=> %s", res)
 		}()
 	}
 
-	gtyp := check.genericType(x, true)
+	var reason string
+	gtyp := check.genericType(ix.X, &reason)
+	if reason != "" {
+		check.invalidOp(ix.Orig, _NotAGenericType, "%s (%s)", ix.Orig, reason)
+	}
 	if gtyp == Typ[Invalid] {
 		return gtyp // error already reported
 	}
 
 	orig, _ := gtyp.(*Named)
 	if orig == nil {
-		panic(fmt.Sprintf("%v: cannot instantiate %v", x.Pos(), gtyp))
+		panic(fmt.Sprintf("%v: cannot instantiate %v", ix.Pos(), gtyp))
 	}
 
 	// evaluate arguments
-	targs := check.typeList(targsx)
+	targs := check.typeList(ix.Indices)
 	if targs == nil {
 		def.setUnderlying(Typ[Invalid]) // avoid later errors due to lazy instantiation
 		return Typ[Invalid]
@@ -404,7 +411,7 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 
 	// determine argument positions
 	posList := make([]token.Pos, len(targs))
-	for i, arg := range targsx {
+	for i, arg := range ix.Indices {
 		posList[i] = arg.Pos()
 	}
 
@@ -418,7 +425,7 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 	// validation below. Ensure that the validation (and resulting errors) runs
 	// for each instantiated type in the source.
 	if inst == nil {
-		tname := NewTypeName(x.Pos(), orig.obj.pkg, orig.obj.name, nil)
+		tname := NewTypeName(ix.X.Pos(), orig.obj.pkg, orig.obj.name, nil)
 		inst = check.newNamed(tname, orig, nil, nil, nil) // underlying, methods and tparams are set when named is resolved
 		inst.targs = NewTypeList(targs)
 		inst = ctxt.update(h, orig, targs, inst).(*Named)
@@ -432,14 +439,14 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 		if len(targs) < len(tparams) {
 			// If inference fails, len(inferred) will be 0, and inst.underlying will
 			// be set to Typ[Invalid] in expandNamed.
-			inferred = check.infer(x, tparams, targs, nil, nil)
+			inferred = check.infer(ix.Orig, tparams, targs, nil, nil)
 			if len(inferred) > len(targs) {
 				inst.targs = NewTypeList(inferred)
 			}
 		}
 
-		check.recordInstance(x, inferred, inst)
-		return expandNamed(ctxt, n, x.Pos())
+		check.recordInstance(ix.Orig, inferred, inst)
+		return expandNamed(ctxt, n, pos)
 	}
 
 	// origin.tparams may not be set up, so we need to do expansion later.
@@ -452,16 +459,16 @@ func (check *Checker) instantiatedType(x ast.Expr, targsx []ast.Expr, def *Named
 		// frees some memory.
 		inst.resolver = nil
 
-		if check.validateTArgLen(x.Pos(), inst.tparams.Len(), inst.targs.Len()) {
-			if i, err := check.verify(x.Pos(), inst.tparams.list(), inst.targs.list()); err != nil {
+		if check.validateTArgLen(pos, inst.tparams.Len(), inst.targs.Len()) {
+			if i, err := check.verify(pos, inst.tparams.list(), inst.targs.list()); err != nil {
 				// best position for error reporting
-				pos := x.Pos()
+				pos := ix.Pos()
 				if i < len(posList) {
 					pos = posList[i]
 				}
 				check.softErrorf(atPos(pos), _InvalidTypeArg, err.Error())
 			} else {
-				check.mono.recordInstance(check.pkg, x.Pos(), inst.tparams.list(), inst.targs.list(), posList)
+				check.mono.recordInstance(check.pkg, pos, inst.tparams.list(), inst.targs.list(), posList)
 			}
 		}
 

From 92655582d0d3b739a1fc88c73cc49a24eb57f845 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 15 Nov 2021 11:47:55 -0500
Subject: [PATCH 161/752] cmd/compile/internal/types2: add a check for nil
 reason in assignableTo
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A recent change to error message formatting was missing a nil check.

Fixes #49592

Change-Id: Ic1843e0277ba75eec0e8e41fe34b59c323d7ea31
Reviewed-on: https://go-review.googlesource.com/c/go/+/364034
Trust: Robert Findley 
Trust: Dan Scales 
Trust: Daniel Martí 
Run-TryBot: Robert Findley 
Reviewed-by: Dan Scales 
TryBot-Result: Go Bot 
---
 src/cmd/compile/internal/types2/operand.go          |  4 +++-
 .../types2/testdata/fixedbugs/issue49592.go2        | 11 +++++++++++
 src/go/types/testdata/fixedbugs/issue49592.go2      | 11 +++++++++++
 test/fixedbugs/issue49592.go                        | 13 +++++++++++++
 4 files changed, 38 insertions(+), 1 deletion(-)
 create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue49592.go2
 create mode 100644 src/go/types/testdata/fixedbugs/issue49592.go2
 create mode 100644 test/fixedbugs/issue49592.go

diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index 8a905f3fd0..6581d80323 100644
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -316,7 +316,9 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 	// not an interface.
 	if check != nil && check.conf.CompilerErrorMessages {
 		if isInterfacePtr(Tu) {
-			*reason = check.sprintf("%s does not implement %s (%s is pointer to interface, not interface)", x.typ, T, T)
+			if reason != nil {
+				*reason = check.sprintf("%s does not implement %s (%s is pointer to interface, not interface)", x.typ, T, T)
+			}
 			return false, _InvalidIfaceAssign
 		}
 		if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil {
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49592.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49592.go2
new file mode 100644
index 0000000000..846deaa89a
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49592.go2
@@ -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.
+
+package p
+
+func _() {
+	var x *interface{}
+	var y interface{}
+	_ = x == y
+}
diff --git a/src/go/types/testdata/fixedbugs/issue49592.go2 b/src/go/types/testdata/fixedbugs/issue49592.go2
new file mode 100644
index 0000000000..846deaa89a
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue49592.go2
@@ -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.
+
+package p
+
+func _() {
+	var x *interface{}
+	var y interface{}
+	_ = x == y
+}
diff --git a/test/fixedbugs/issue49592.go b/test/fixedbugs/issue49592.go
new file mode 100644
index 0000000000..8b5612943a
--- /dev/null
+++ b/test/fixedbugs/issue49592.go
@@ -0,0 +1,13 @@
+// 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 _() {
+	var x *interface{}
+	var y interface{}
+	_ = x == y
+}

From 560dc9712d4bc900b5ab32b518ba4de2a9bc588c Mon Sep 17 00:00:00 2001
From: Keith Randall 
Date: Mon, 15 Nov 2021 10:01:43 -0800
Subject: [PATCH 162/752] cmd/compile: error when using internal type
 declarations in generic functions

We hope to support this feature one day, but it doesn't work currently.
Issue a nice error message instead of having the compiler crash.

Update #47631

Change-Id: I0359411410acbaf9a5b9dbb988cd933de1bb8438
Reviewed-on: https://go-review.googlesource.com/c/go/+/364054
Trust: Keith Randall 
Trust: Dan Scales 
Run-TryBot: Keith Randall 
TryBot-Result: Go Bot 
Reviewed-by: Dan Scales 
---
 src/cmd/compile/internal/noder/stmt.go |  4 +++
 test/run.go                            |  1 +
 test/typeparam/builtins.go             | 13 +++++-----
 test/typeparam/issue47631.go           | 34 ++++++++++++++++++++++++++
 test/typeparam/typelist.go             |  3 ++-
 5 files changed, 48 insertions(+), 7 deletions(-)
 create mode 100644 test/typeparam/issue47631.go

diff --git a/src/cmd/compile/internal/noder/stmt.go b/src/cmd/compile/internal/noder/stmt.go
index aedb09e21e..e329a59156 100644
--- a/src/cmd/compile/internal/noder/stmt.go
+++ b/src/cmd/compile/internal/noder/stmt.go
@@ -46,6 +46,10 @@ func (g *irgen) stmt(stmt syntax.Stmt) ir.Node {
 		n.SetTypecheck(1)
 		return n
 	case *syntax.DeclStmt:
+		if _, ok := stmt.DeclList[0].(*syntax.TypeDecl); ok && g.topFuncIsGeneric {
+			// TODO: remove this restriction. See issue 47631.
+			base.ErrorfAt(g.pos(stmt), "type declarations inside generic functions are not currently supported")
+		}
 		n := ir.NewBlockStmt(g.pos(stmt), nil)
 		g.decls(&n.List, stmt.DeclList)
 		return n
diff --git a/test/run.go b/test/run.go
index ad64304ec8..bdc2f0a277 100644
--- a/test/run.go
+++ b/test/run.go
@@ -2186,6 +2186,7 @@ var unifiedFailures = setOf(
 	"fixedbugs/issue42284.go", // prints "T(0) does not escape", but test expects "a.I(a.T(0)) does not escape"
 	"fixedbugs/issue7921.go",  // prints "… escapes to heap", but test expects "string(…) escapes to heap"
 	"typeparam/issue48538.go", // assertion failure, interprets struct key as closure variable
+	"typeparam/issue47631.go", // unified IR can handle local type declarations
 )
 
 func setOf(keys ...string) map[string]bool {
diff --git a/test/typeparam/builtins.go b/test/typeparam/builtins.go
index 844cdae8ab..73dda77e0e 100644
--- a/test/typeparam/builtins.go
+++ b/test/typeparam/builtins.go
@@ -69,24 +69,25 @@ func m1[
 	C1 interface{ chan int },
 	C2 interface{ chan int | chan string },
 ]() {
-	type S0 []int
 	_ = make([]int, 10)
-	_ = make(S0, 10)
+	_ = make(m1S0, 10)
 	_ = make(S1, 10)
 	_ = make(S1, 10, 20)
 
-	type M0 map[string]int
 	_ = make(map[string]int)
-	_ = make(M0)
+	_ = make(m1M0)
 	_ = make(M1)
 	_ = make(M1, 10)
 
-	type C0 chan int
 	_ = make(chan int)
-	_ = make(C0)
+	_ = make(m1C0)
 	_ = make(C1)
 	_ = make(C1, 10)
 }
+// TODO: put these type declarations back inside m1 when issue 47631 is fixed.
+type m1S0 []int
+type m1M0 map[string]int
+type m1C0 chan int
 
 // len/cap
 
diff --git a/test/typeparam/issue47631.go b/test/typeparam/issue47631.go
new file mode 100644
index 0000000000..7f7cfa6abb
--- /dev/null
+++ b/test/typeparam/issue47631.go
@@ -0,0 +1,34 @@
+// errorcheck -G=3
+
+// 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: one day we will support internal type declarations, at which time this test will be removed.
+
+package p
+
+func g[T any]() {
+	type U []T // ERROR "type declarations inside generic functions are not currently supported"
+	type V []int // ERROR "type declarations inside generic functions are not currently supported"
+}
+
+type S[T any] struct {
+}
+
+func (s S[T]) m() {
+	type U []T // ERROR "type declarations inside generic functions are not currently supported"
+	type V []int // ERROR "type declarations inside generic functions are not currently supported"
+}
+
+
+func f() {
+	type U []int // ok
+}
+
+type X struct {
+}
+
+func (x X) m() {
+	type U []int // ok
+}
diff --git a/test/typeparam/typelist.go b/test/typeparam/typelist.go
index 8d6a228de5..34ea4b8aa9 100644
--- a/test/typeparam/typelist.go
+++ b/test/typeparam/typelist.go
@@ -26,11 +26,12 @@ func at[T interface{ ~[]E }, E any](x T, i int) E {
 // type is itself, its "operational type" is defined by the type list in
 // the tybe bound, if any.
 func _[T interface{ ~int }](x T) {
-	type myint int
 	var _ int = int(x)
 	var _ T = 42
 	var _ T = T(myint(42))
 }
+// TODO: put this type declaration back inside the above function when issue 47631 is fixed.
+type myint int
 
 // Indexing a generic type which has a structural contraints to be an array.
 func _[T interface{ ~[10]int }](x T) {

From 184ca3cf99864b4112997891b079d106751be25c Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sun, 14 Nov 2021 11:31:47 -0800
Subject: [PATCH 163/752] go/types, types2: copy implicit bit in interface
 substitution

Change-Id: Idb02449ef1b06d5f47eeb4a4413e56e2cd5d0d96
Reviewed-on: https://go-review.googlesource.com/c/go/+/363836
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/subst.go | 2 +-
 src/go/types/subst.go                    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
index 5deb868a79..ed1fbbf941 100644
--- a/src/cmd/compile/internal/types2/subst.go
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -137,7 +137,7 @@ func (subst *subster) typ(typ Type) Type {
 		methods, mcopied := subst.funcList(t.methods)
 		embeddeds, ecopied := subst.typeList(t.embeddeds)
 		if mcopied || ecopied {
-			iface := &Interface{methods: methods, embeddeds: embeddeds, complete: t.complete}
+			iface := &Interface{methods: methods, embeddeds: embeddeds, implicit: t.implicit, complete: t.complete}
 			return iface
 		}
 
diff --git a/src/go/types/subst.go b/src/go/types/subst.go
index 3ff81a06b6..04eb3a6215 100644
--- a/src/go/types/subst.go
+++ b/src/go/types/subst.go
@@ -137,7 +137,7 @@ func (subst *subster) typ(typ Type) Type {
 		methods, mcopied := subst.funcList(t.methods)
 		embeddeds, ecopied := subst.typeList(t.embeddeds)
 		if mcopied || ecopied {
-			iface := &Interface{methods: methods, embeddeds: embeddeds, complete: t.complete}
+			iface := &Interface{methods: methods, embeddeds: embeddeds, implicit: t.implicit, complete: t.complete}
 			return iface
 		}
 

From 0a39e4a89d26d8375bb5877f736dcc0047894060 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sat, 13 Nov 2021 11:02:51 -0800
Subject: [PATCH 164/752] cmd/compile/internal/types2: optimize common case in
 structuralType

Most of the time we don't have a type parameter. Avoid using a
closure in that case.

While at it, rename argument from typ to t (to match style in
that file), and clarify the doc string.

Change-Id: Ie62821073f60f353526263f8b380bad9f72d842e
Reviewed-on: https://go-review.googlesource.com/c/go/+/363668
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/type.go | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index af195c08a4..39737d47a7 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -56,15 +56,20 @@ func match(x, y Type) Type {
 	return nil
 }
 
-// If typ is a type parameter, structuralType returns the single underlying
-// type of all types in the corresponding type constraint if it exists, or
-// nil otherwise. If the type set contains only unrestricted and restricted
-// channel types (with identical element types), the single underlying type
-// is the restricted channel type if the restrictions are always the same.
-// If typ is not a type parameter, structuralType returns the underlying type.
-func structuralType(typ Type) Type {
+// If t is not a type parameter, structuralType returns the underlying type.
+// If t is a type parameter, structuralType returns the single underlying
+// type of all types in its type set if it exists, or nil otherwise. If the
+// type set contains only unrestricted and restricted channel types (with
+// identical element types), the single underlying type is the restricted
+// channel type if the restrictions are always the same, or nil otherwise.
+func structuralType(t Type) Type {
+	tpar, _ := t.(*TypeParam)
+	if tpar == nil {
+		return under(t)
+	}
+
 	var su Type
-	if underIs(typ, func(u Type) bool {
+	if tpar.underIs(func(u Type) bool {
 		if u == nil {
 			return false
 		}

From cfcd71790f0ca8c2ec1ae5989cd60ad1e83ee40c Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Fri, 12 Nov 2021 15:08:00 -0800
Subject: [PATCH 165/752] cmd/compile/internal/types2: allow slicing for
 operands with []byte|string type sets

Fixes #49566.

Change-Id: I80ff4ca661f82b0981d51e0997d5988a9b82f508
Reviewed-on: https://go-review.googlesource.com/c/go/+/363662
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/builtins.go   | 23 ++----------
 src/cmd/compile/internal/types2/index.go      |  4 +-
 .../types2/testdata/check/typeparams.go2      |  4 ++
 src/cmd/compile/internal/types2/type.go       | 37 +++++++++++++++++++
 4 files changed, 47 insertions(+), 21 deletions(-)

diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index 5b4ffd0dad..53d834507a 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -337,26 +337,11 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 		if y.mode == invalid {
 			return
 		}
-		// src, _ := structuralType(y.typ).(*Slice); but also accepts strings
-		var src *Slice
-		var elem Type // == src.elem if valid
-		if underIs(y.typ, func(u Type) bool {
-			switch u := u.(type) {
-			case *Basic:
-				if isString(u) && (elem == nil || Identical(elem, universeByte)) {
-					elem = universeByte
-					return true
-				}
-			case *Slice:
-				if elem == nil || Identical(elem, u.elem) {
-					elem = u.elem
-					return true
-				}
-			}
-			return false
-		}) {
-			src = NewSlice(elem)
+		src0 := structuralString(y.typ)
+		if src0 != nil && isString(src0) {
+			src0 = NewSlice(universeByte)
 		}
+		src, _ := src0.(*Slice)
 
 		if dst == nil || src == nil {
 			check.errorf(x, invalidArg+"copy expects slice arguments; found %s and %s", x, &y)
diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index 648c7abe6f..524d1957b5 100644
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -213,7 +213,7 @@ func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) {
 
 	valid := false
 	length := int64(-1) // valid if >= 0
-	switch u := structuralType(x.typ).(type) {
+	switch u := structuralString(x.typ).(type) {
 	case nil:
 		check.errorf(x, invalidOp+"cannot slice %s: %s has no structural type", x, x.typ)
 		x.mode = invalid
@@ -232,7 +232,7 @@ func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) {
 			}
 			// spec: "For untyped string operands the result
 			// is a non-constant value of type string."
-			if u.kind == UntypedString {
+			if isUntyped(x.typ) {
 				x.typ = Typ[String]
 			}
 		}
diff --git a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
index 03c3f9a0b5..f77d09391b 100644
--- a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
+++ b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
@@ -136,6 +136,10 @@ type myByte2 []byte
 func _[T interface{ []byte | myByte1 | myByte2 }] (x T, i, j, k int) { var _ T = x[i:j:k] }
 func _[T interface{ []byte | myByte1 | []int }] (x T, i, j, k int) { var _ T = x[ /* ERROR no structural type */ i:j:k] }
 
+func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x[i:j] }
+func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x /* ERROR 3-index slice of string */ [i:j:k] }
+func _[T interface{ []byte | myByte1 | []int | string }] (x T, i, j, k int) { var _ T = x[ /* ERROR no structural type */ i:j] }
+
 // len/cap built-ins
 
 func _[T any](x T) { _ = len(x /* ERROR invalid argument */ ) }
diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 39737d47a7..3ab738eb19 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -87,3 +87,40 @@ func structuralType(t Type) Type {
 	}
 	return nil
 }
+
+// structuralString is like structuralType but also considers []byte
+// and strings as identical. In this case, if successful and we saw
+// a string, the result is of type (possibly untyped) string.
+func structuralString(t Type) Type {
+	tpar, _ := t.(*TypeParam)
+	if tpar == nil {
+		return under(t) // string or untyped string
+	}
+
+	var su Type
+	hasString := false
+	if tpar.underIs(func(u Type) bool {
+		if u == nil {
+			return false
+		}
+		if isString(u) {
+			u = NewSlice(universeByte)
+			hasString = true
+		}
+		if su != nil {
+			u = match(su, u)
+			if u == nil {
+				return false
+			}
+		}
+		// su == nil || match(su, u) != nil
+		su = u
+		return true
+	}) {
+		if hasString {
+			return Typ[String]
+		}
+		return su
+	}
+	return nil
+}

From 0a54a6826ebd19e5947af57993399652c62801de Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sat, 13 Nov 2021 12:04:01 -0800
Subject: [PATCH 166/752] cmd/compile/internal/types2: move match function to
 end of file (cleanup)

Change-Id: Ia09f7b1af0e84858fb73ab7e2592c5c3e983dc0e
Reviewed-on: https://go-review.googlesource.com/c/go/+/363669
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/type.go | 58 ++++++++++++-------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 3ab738eb19..9487ac5a84 100644
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -27,35 +27,6 @@ func under(t Type) Type {
 	return t.Underlying()
 }
 
-// If x and y are identical, match returns x.
-// If x and y are identical channels but for their direction
-// and one of them is unrestricted, match returns the channel
-// with the restricted direction.
-// In all other cases, match returns nil.
-func match(x, y Type) Type {
-	// Common case: we don't have channels.
-	if Identical(x, y) {
-		return x
-	}
-
-	// We may have channels that differ in direction only.
-	if x, _ := x.(*Chan); x != nil {
-		if y, _ := y.(*Chan); y != nil && Identical(x.elem, y.elem) {
-			// We have channels that differ in direction only.
-			// If there's an unrestricted channel, select the restricted one.
-			switch {
-			case x.dir == SendRecv:
-				return y
-			case y.dir == SendRecv:
-				return x
-			}
-		}
-	}
-
-	// types are different
-	return nil
-}
-
 // If t is not a type parameter, structuralType returns the underlying type.
 // If t is a type parameter, structuralType returns the single underlying
 // type of all types in its type set if it exists, or nil otherwise. If the
@@ -124,3 +95,32 @@ func structuralString(t Type) Type {
 	}
 	return nil
 }
+
+// If x and y are identical, match returns x.
+// If x and y are identical channels but for their direction
+// and one of them is unrestricted, match returns the channel
+// with the restricted direction.
+// In all other cases, match returns nil.
+func match(x, y Type) Type {
+	// Common case: we don't have channels.
+	if Identical(x, y) {
+		return x
+	}
+
+	// We may have channels that differ in direction only.
+	if x, _ := x.(*Chan); x != nil {
+		if y, _ := y.(*Chan); y != nil && Identical(x.elem, y.elem) {
+			// We have channels that differ in direction only.
+			// If there's an unrestricted channel, select the restricted one.
+			switch {
+			case x.dir == SendRecv:
+				return y
+			case y.dir == SendRecv:
+				return x
+			}
+		}
+	}
+
+	// types are different
+	return nil
+}

From 42fa03a88ca7767c1869e55b3144a9828d29b7b5 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sat, 13 Nov 2021 13:37:15 -0800
Subject: [PATCH 167/752] cmd/compile/internal/types2: better position for
 "3-index slice of string" error

As a result, slightly narrow position tolerance for tests.

Change-Id: I543dc2b7b9a7940b0684067d1961165b2b4812bb
Reviewed-on: https://go-review.googlesource.com/c/go/+/363670
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/check_test.go               | 2 +-
 src/cmd/compile/internal/types2/index.go                    | 6 +++++-
 src/cmd/compile/internal/types2/testdata/check/expr3.src    | 4 ++--
 .../compile/internal/types2/testdata/check/typeparams.go2   | 4 ++--
 4 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index d4c7b7b39b..ddaacd2443 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -277,7 +277,7 @@ func TestManual(t *testing.T) {
 
 // TODO(gri) go/types has extra TestLongConstants and TestIndexRepresentability tests
 
-func TestCheck(t *testing.T)     { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/check", 75, false) } // TODO(gri) narrow column tolerance
+func TestCheck(t *testing.T)     { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/check", 55, false) } // TODO(gri) narrow column tolerance
 func TestSpec(t *testing.T)      { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/spec", 0, false) }
 func TestExamples(t *testing.T)  { testDirFiles(t, "testdata/examples", 0, false) }
 func TestFixedbugs(t *testing.T) { testDirFiles(t, "testdata/fixedbugs", 0, false) }
diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index 524d1957b5..c773ae8ad3 100644
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -222,7 +222,11 @@ func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) {
 	case *Basic:
 		if isString(u) {
 			if e.Full {
-				check.error(x, invalidOp+"3-index slice of string")
+				at := e.Index[2]
+				if at == nil {
+					at = e // e.Index[2] should be present but be careful
+				}
+				check.error(at, invalidOp+"3-index slice of string")
 				x.mode = invalid
 				return
 			}
diff --git a/src/cmd/compile/internal/types2/testdata/check/expr3.src b/src/cmd/compile/internal/types2/testdata/check/expr3.src
index d1e1dba9f4..523214461f 100644
--- a/src/cmd/compile/internal/types2/testdata/check/expr3.src
+++ b/src/cmd/compile/internal/types2/testdata/check/expr3.src
@@ -110,8 +110,8 @@ func indexes() {
 	_ = t[- /* ERROR "negative" */ 1]
 	_ = t[- /* ERROR "negative" */ 1 :]
 	_ = t[: - /* ERROR "negative" */ 1]
-	_ = t /* ERROR "3-index slice of string" */ [1:2:3]
-	_ = "foo" /* ERROR "3-index slice of string" */ [1:2:3]
+	_ = t[1:2:3 /* ERROR "3-index slice of string" */ ]
+	_ = "foo"[1:2:3 /* ERROR "3-index slice of string" */ ]
 	var t0 byte
 	t0 = t[0]
 	_ = t0
diff --git a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
index f77d09391b..d72cf078a7 100644
--- a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
+++ b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
@@ -129,7 +129,7 @@ func _[T interface{ ~[10]E }, E any] (x T, i, j, k int) { var _ []E = x[i:j:k] }
 func _[T interface{ ~[]byte }] (x T, i, j, k int) { var _ T = x[i:j] }
 func _[T interface{ ~[]byte }] (x T, i, j, k int) { var _ T = x[i:j:k] }
 func _[T interface{ ~string }] (x T, i, j, k int) { var _ T = x[i:j] }
-func _[T interface{ ~string }] (x T, i, j, k int) { var _ T = x /* ERROR 3-index slice of string */ [i:j:k] }
+func _[T interface{ ~string }] (x T, i, j, k int) { var _ T = x[i:j:k /* ERROR 3-index slice of string */ ] }
 
 type myByte1 []byte
 type myByte2 []byte
@@ -137,7 +137,7 @@ func _[T interface{ []byte | myByte1 | myByte2 }] (x T, i, j, k int) { var _ T =
 func _[T interface{ []byte | myByte1 | []int }] (x T, i, j, k int) { var _ T = x[ /* ERROR no structural type */ i:j:k] }
 
 func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x[i:j] }
-func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x /* ERROR 3-index slice of string */ [i:j:k] }
+func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x[i:j:k /* ERROR 3-index slice of string */ ] }
 func _[T interface{ []byte | myByte1 | []int | string }] (x T, i, j, k int) { var _ T = x[ /* ERROR no structural type */ i:j] }
 
 // len/cap built-ins

From fda92615040c831bdcd812fd20ddb0da9dcef70b Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sat, 13 Nov 2021 13:57:48 -0800
Subject: [PATCH 168/752] cmd/compile/internal/types2: better position for
 invalid slice indices error

Report the error at the first place (which is to say, latest index)
causing the error.

Change-Id: I31cf0a4d243fc66cfab84b7fec98055f4eb60ddf
Reviewed-on: https://go-review.googlesource.com/c/go/+/363671
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/index.go       |  9 ++++++---
 .../internal/types2/testdata/check/expr3.src   | 18 +++++++++---------
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index c773ae8ad3..4995d2d730 100644
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -309,9 +309,12 @@ func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) {
 L:
 	for i, x := range ind[:len(ind)-1] {
 		if x > 0 {
-			for _, y := range ind[i+1:] {
-				if y >= 0 && x > y {
-					check.errorf(e, "invalid slice indices: %d > %d", x, y)
+			for j, y := range ind[i+1:] {
+				if y >= 0 && y < x {
+					// The value y corresponds to the expression e.Index[i+1+j].
+					// Because y >= 0, it must have been set from the expression
+					// when checking indices and thus e.Index[i+1+j] is not nil.
+					check.errorf(e.Index[i+1+j], "invalid slice indices: %d < %d", y, x)
 					break L // only report one error, ok to continue
 				}
 			}
diff --git a/src/cmd/compile/internal/types2/testdata/check/expr3.src b/src/cmd/compile/internal/types2/testdata/check/expr3.src
index 523214461f..0d7bbae9f9 100644
--- a/src/cmd/compile/internal/types2/testdata/check/expr3.src
+++ b/src/cmd/compile/internal/types2/testdata/check/expr3.src
@@ -45,9 +45,9 @@ func indexes() {
 	_ = a[:10:10]
 	_ = a[:11 /* ERROR "index .* out of bounds" */ :10]
 	_ = a[:10:11 /* ERROR "index .* out of bounds" */ ]
-	_ = a[10:0:10] /* ERROR "invalid slice indices" */
-	_ = a[0:10:0] /* ERROR "invalid slice indices" */
-	_ = a[10:0:0] /* ERROR "invalid slice indices" */
+	_ = a[10:0 /* ERROR "invalid slice indices" */ :10]
+	_ = a[0:10:0 /* ERROR "invalid slice indices" */ ]
+	_ = a[10:0 /* ERROR "invalid slice indices" */:0]
 	_ = &a /* ERROR "cannot take address" */ [:10]
 
 	pa := &a
@@ -63,9 +63,9 @@ func indexes() {
 	_ = pa[:10:10]
 	_ = pa[:11 /* ERROR "index .* out of bounds" */ :10]
 	_ = pa[:10:11 /* ERROR "index .* out of bounds" */ ]
-	_ = pa[10:0:10] /* ERROR "invalid slice indices" */
-	_ = pa[0:10:0] /* ERROR "invalid slice indices" */
-	_ = pa[10:0:0] /* ERROR "invalid slice indices" */
+	_ = pa[10:0 /* ERROR "invalid slice indices" */ :10]
+	_ = pa[0:10:0 /* ERROR "invalid slice indices" */ ]
+	_ = pa[10:0 /* ERROR "invalid slice indices" */ :0]
 	_ = &pa /* ERROR "cannot take address" */ [:10]
 
 	var b [0]int
@@ -90,9 +90,9 @@ func indexes() {
 	_ = s[1 /* ERROR "overflows" */ <<100 : 1 /* ERROR "overflows" */ <<100]
 	_ = s[: /* ERROR "middle index required" */ :  /* ERROR "final index required" */ ]
 	_ = s[:10:10]
-	_ = s[10:0:10] /* ERROR "invalid slice indices" */
-	_ = s[0:10:0] /* ERROR "invalid slice indices" */
-	_ = s[10:0:0] /* ERROR "invalid slice indices" */
+	_ = s[10:0 /* ERROR "invalid slice indices" */ :10]
+	_ = s[0:10:0 /* ERROR "invalid slice indices" */ ]
+	_ = s[10:0 /* ERROR "invalid slice indices" */ :0]
 	_ = &s /* ERROR "cannot take address" */ [:10]
 
 	var m map[string]int

From e08aae2ee443ba8bb16b8ce9c5d3d8d4d3cfa82b Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sun, 14 Nov 2021 11:29:45 -0800
Subject: [PATCH 169/752] cmd/compile/internal/types2: implement
 Checker.implements

Checker.implements implements the complete interface
"implements" predicate. Use it instead of Checker.satisfies.
This is mostly a refactoring of the code but the constraint
types have already been instatiated with the respective type
arguments as needed before calling "implements".
Future CLs will address the various TODOs.

Change-Id: If530cca36643a561282361348f1526157a7182de
Reviewed-on: https://go-review.googlesource.com/c/go/+/363837
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 .../compile/internal/types2/instantiate.go    | 131 ++++++++++--------
 .../types2/testdata/fixedbugs/issue45920.go2  |   4 +-
 2 files changed, 72 insertions(+), 63 deletions(-)

diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index 582d1e4763..a0f6885c51 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -119,34 +119,6 @@ func (check *Checker) validateTArgLen(pos syntax.Pos, ntparams, ntargs int) bool
 }
 
 func (check *Checker) verify(pos syntax.Pos, tparams []*TypeParam, targs []Type) (int, error) {
-	smap := makeSubstMap(tparams, targs)
-	for i, tpar := range tparams {
-		// stop checking bounds after the first failure
-		if err := check.satisfies(pos, targs[i], tpar, smap); err != nil {
-			return i, err
-		}
-	}
-	return -1, nil
-}
-
-// satisfies reports whether the type argument targ satisfies the constraint of type parameter
-// parameter tpar (after any of its type parameters have been substituted through smap).
-// A suitable error is reported if the result is false.
-// TODO(gri) This should be a method of interfaces or type sets.
-func (check *Checker) satisfies(pos syntax.Pos, targ Type, tpar *TypeParam, smap substMap) error {
-	iface := tpar.iface()
-
-	// Every type argument satisfies interface{}.
-	if iface.Empty() {
-		return nil
-	}
-
-	// A type argument that is a type parameter with an empty type set satisfies any constraint.
-	// (The empty set is a subset of any set.)
-	if targ, _ := targ.(*TypeParam); targ != nil && targ.iface().typeSet().IsEmpty() {
-		return nil
-	}
-
 	// TODO(rfindley): it would be great if users could pass in a qualifier here,
 	// rather than falling back to verbose qualification. Maybe this can be part
 	// of the shared context.
@@ -154,77 +126,114 @@ func (check *Checker) satisfies(pos syntax.Pos, targ Type, tpar *TypeParam, smap
 	if check != nil {
 		qf = check.qualifier
 	}
+
+	smap := makeSubstMap(tparams, targs)
+	for i, tpar := range tparams {
+		// The type parameter bound is parameterized with the same type parameters
+		// as the instantiated type; before we can use it for bounds checking we
+		// need to instantiate it with the type arguments with which we instantiated
+		// the parameterized type.
+		bound := check.subst(pos, tpar.bound, smap, nil)
+		if err := check.implements(targs[i], bound, qf); err != nil {
+			return i, err
+		}
+	}
+	return -1, nil
+}
+
+// implements checks if V implements T and reports an error if it doesn't.
+// If a qualifier is provided, it is used in error formatting.
+func (check *Checker) implements(V, T Type, qf Qualifier) error {
+	Vu := under(V)
+	Tu := under(T)
+	if Vu == Typ[Invalid] || Tu == Typ[Invalid] {
+		return nil
+	}
+
 	errorf := func(format string, args ...interface{}) error {
 		return errors.New(sprintf(qf, false, format, args...))
 	}
 
-	// No type argument with non-empty type set satisfies the empty type set.
-	if iface.typeSet().IsEmpty() {
-		return errorf("%s does not satisfy %s (constraint type set is empty)", targ, tpar.bound)
+	Ti, _ := Tu.(*Interface)
+	if Ti == nil {
+		return errorf("%s is not an interface", T)
 	}
 
-	// The type parameter bound is parameterized with the same type parameters
-	// as the instantiated type; before we can use it for bounds checking we
-	// need to instantiate it with the type arguments with which we instantiate
-	// the parameterized type.
-	iface = check.subst(pos, iface, smap, nil).(*Interface)
+	// Every type satisfies the empty interface.
+	if Ti.Empty() {
+		return nil
+	}
+	// T is not the empty interface (i.e., the type set of T is restricted)
 
-	// if iface is comparable, targ must be comparable
+	// An interface V with an empty type set satisfies any interface.
+	// (The empty set is a subset of any set.)
+	Vi, _ := Vu.(*Interface)
+	if Vi != nil && Vi.typeSet().IsEmpty() {
+		return nil
+	}
+	// type set of V is not empty
+
+	// No type with non-empty type set satisfies the empty type set.
+	// TODO(gri) should use "implements" rather than "satisfies" throughout
+	if Ti.typeSet().IsEmpty() {
+		return errorf("%s does not satisfy %s (constraint type set is empty)", V, T)
+	}
+
+	// If T is comparable, V must be comparable.
 	// TODO(gri) the error messages needs to be better, here
-	if iface.IsComparable() && !Comparable(targ) {
-		if tpar, _ := targ.(*TypeParam); tpar != nil && tpar.iface().typeSet().IsAll() {
-			return errorf("%s has no constraints", targ)
+	if Ti.IsComparable() && !Comparable(V) {
+		if Vi != nil && Vi.typeSet().IsAll() {
+			return errorf("%s has no constraints", V)
 		}
-		return errorf("%s does not satisfy comparable", targ)
+		return errorf("%s does not satisfy comparable", V)
 	}
 
-	// targ must implement iface (methods)
+	// V must implement T (methods)
 	// - check only if we have methods
-	if iface.NumMethods() > 0 {
+	if Ti.NumMethods() > 0 {
 		// If the type argument is a pointer to a type parameter, the type argument's
 		// method set is empty.
 		// TODO(gri) is this what we want? (spec question)
-		if base, isPtr := deref(targ); isPtr && isTypeParam(base) {
-			return errorf("%s has no methods", targ)
+		if base, isPtr := deref(V); isPtr && isTypeParam(base) {
+			return errorf("%s has no methods", V)
 		}
-		if m, wrong := check.missingMethod(targ, iface, true); m != nil {
+		if m, wrong := check.missingMethod(V, Ti, true); m != nil {
 			// TODO(gri) needs to print updated name to avoid major confusion in error message!
 			//           (print warning for now)
 			// Old warning:
-			// check.softErrorf(pos, "%s does not satisfy %s (warning: name not updated) = %s (missing method %s)", targ, tpar.bound, iface, m)
+			// check.softErrorf(pos, "%s does not satisfy %s (warning: name not updated) = %s (missing method %s)", V, T, Ti, m)
 			if wrong != nil {
 				// TODO(gri) This can still report uninstantiated types which makes the error message
 				//           more difficult to read then necessary.
 				return errorf("%s does not satisfy %s: wrong method signature\n\tgot  %s\n\twant %s",
-					targ, tpar.bound, wrong, m,
+					V, T, wrong, m,
 				)
 			}
-			return errorf("%s does not satisfy %s (missing method %s)", targ, tpar.bound, m.name)
+			return errorf("%s does not satisfy %s (missing method %s)", V, T, m.name)
 		}
 	}
 
-	// targ must also be in the set of types of iface, if any.
+	// V must also be in the set of types of T, if any.
 	// Constraints with empty type sets were already excluded above.
-	if !iface.typeSet().hasTerms() {
+	if !Ti.typeSet().hasTerms() {
 		return nil // nothing to do
 	}
 
-	// If targ is itself a type parameter, each of its possible types must be in the set
-	// of iface types (i.e., the targ type set must be a subset of the iface type set).
-	// Type arguments with empty type sets were already excluded above.
-	if targ, _ := targ.(*TypeParam); targ != nil {
-		targBound := targ.iface()
-		if !targBound.typeSet().subsetOf(iface.typeSet()) {
+	// If V is itself an interface, each of its possible types must be in the set
+	// of T types (i.e., the V type set must be a subset of the T type set).
+	// Interfaces V with empty type sets were already excluded above.
+	if Vi != nil {
+		if !Vi.typeSet().subsetOf(Ti.typeSet()) {
 			// TODO(gri) report which type is missing
-			return errorf("%s does not satisfy %s", targ, tpar.bound)
+			return errorf("%s does not satisfy %s", V, T)
 		}
 		return nil
 	}
 
-	// Otherwise, targ's type must be included in the iface type set.
-	if !iface.typeSet().includes(targ) {
+	// Otherwise, V's type must be included in the iface type set.
+	if !Ti.typeSet().includes(V) {
 		// TODO(gri) report which type is missing
-		return errorf("%s does not satisfy %s", targ, tpar.bound)
+		return errorf("%s does not satisfy %s", V, T)
 	}
 
 	return nil
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2
index ef9ca9fede..620bdb2e4e 100644
--- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2
@@ -8,10 +8,10 @@ func f1[T any, C chan T | <-chan T](ch C) {}
 
 func _(ch chan int)   { f1(ch) }
 func _(ch <-chan int) { f1(ch) }
-func _(ch chan<- int) { f1( /* ERROR chan<- int does not satisfy chan T\|<-chan T */ ch) }
+func _(ch chan<- int) { f1( /* ERROR chan<- int does not satisfy chan int\|<-chan int */ ch) }
 
 func f2[T any, C chan T | chan<- T](ch C) {}
 
 func _(ch chan int)   { f2(ch) }
-func _(ch <-chan int) { f2( /* ERROR <-chan int does not satisfy chan T\|chan<- T */ ch) }
+func _(ch <-chan int) { f2( /* ERROR <-chan int does not satisfy chan int\|chan<- int */ ch) }
 func _(ch chan<- int) { f2(ch) }

From c8d7c5fe0511569f19d4ebed29f11d96f50b3e07 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sun, 14 Nov 2021 20:45:40 -0800
Subject: [PATCH 170/752] cmd/compile/internal/types2: remove unneccesary tests
 in implements and lookup

Because the underlying type of a type parameter is an interface,
the questions whether *P for a type parameter P has methods or
not is settled: P is also an interface pointers to interfaces
don't have methods.

This allows us to eliminate the now unneccesary test in "implements"
and also allows us to remove a special case for type parameters in
"lookupFieldOrMethod".

Change-Id: I8b218f81584a8e42e75884089a44293365b700df
Reviewed-on: https://go-review.googlesource.com/c/go/+/363838
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/instantiate.go | 6 ------
 src/cmd/compile/internal/types2/lookup.go      | 6 +-----
 2 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index a0f6885c51..13f0661611 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -191,12 +191,6 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 	// V must implement T (methods)
 	// - check only if we have methods
 	if Ti.NumMethods() > 0 {
-		// If the type argument is a pointer to a type parameter, the type argument's
-		// method set is empty.
-		// TODO(gri) is this what we want? (spec question)
-		if base, isPtr := deref(V); isPtr && isTypeParam(base) {
-			return errorf("%s has no methods", V)
-		}
 		if m, wrong := check.missingMethod(V, Ti, true); m != nil {
 			// TODO(gri) needs to print updated name to avoid major confusion in error message!
 			//           (print warning for now)
diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index b4035e16b3..4f50ea54b1 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -80,12 +80,8 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name
 
 	typ, isPtr := deref(T)
 
-	// *typ where typ is an interface or type parameter has no methods.
+	// *typ where typ is an interface has no methods.
 	if isPtr {
-		// don't look at under(typ) here - was bug (issue #47747)
-		if _, ok := typ.(*TypeParam); ok {
-			return
-		}
 		if _, ok := under(typ).(*Interface); ok {
 			return
 		}

From 95e85e31089523447aadb7670715c4d3383cc4ee Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sun, 14 Nov 2021 21:13:27 -0800
Subject: [PATCH 171/752] cmd/compile/internal/types2: use "implements" rather
 than "satisfies" in error messages

Type constraint satisfaction is interface implementation.

Adjusted a few error messages.

Change-Id: I4266af78e83131a76b1e3e44c847a21de760ac6e
Reviewed-on: https://go-review.googlesource.com/c/go/+/363839
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 .../compile/internal/types2/instantiate.go    | 21 +++++++-------
 .../internal/types2/testdata/check/issues.go2 |  6 ++--
 .../types2/testdata/check/typeinst2.go2       | 28 +++++++++----------
 .../types2/testdata/examples/inference.go2    |  2 +-
 .../types2/testdata/fixedbugs/issue39754.go2  |  4 +--
 .../types2/testdata/fixedbugs/issue45920.go2  |  4 +--
 .../types2/testdata/fixedbugs/issue47411.go2  | 10 +++----
 src/constraints/constraints_test.go           |  2 +-
 test/typeparam/mdempsky/8.dir/b.go            |  2 +-
 test/typeparam/mincheck.dir/main.go           |  4 +--
 10 files changed, 41 insertions(+), 42 deletions(-)

diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index 13f0661611..3834c6ba87 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -174,18 +174,17 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 	// type set of V is not empty
 
 	// No type with non-empty type set satisfies the empty type set.
-	// TODO(gri) should use "implements" rather than "satisfies" throughout
 	if Ti.typeSet().IsEmpty() {
-		return errorf("%s does not satisfy %s (constraint type set is empty)", V, T)
+		return errorf("cannot implement %s (empty type set)", T)
 	}
 
 	// If T is comparable, V must be comparable.
-	// TODO(gri) the error messages needs to be better, here
+	// TODO(gri) the error messages could be better, here
 	if Ti.IsComparable() && !Comparable(V) {
-		if Vi != nil && Vi.typeSet().IsAll() {
-			return errorf("%s has no constraints", V)
+		if Vi != nil && Vi.Empty() {
+			return errorf("empty interface %s does not implement %s", V, T)
 		}
-		return errorf("%s does not satisfy comparable", V)
+		return errorf("%s does not implement comparable", V)
 	}
 
 	// V must implement T (methods)
@@ -195,15 +194,15 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 			// TODO(gri) needs to print updated name to avoid major confusion in error message!
 			//           (print warning for now)
 			// Old warning:
-			// check.softErrorf(pos, "%s does not satisfy %s (warning: name not updated) = %s (missing method %s)", V, T, Ti, m)
+			// check.softErrorf(pos, "%s does not implement %s (warning: name not updated) = %s (missing method %s)", V, T, Ti, m)
 			if wrong != nil {
 				// TODO(gri) This can still report uninstantiated types which makes the error message
 				//           more difficult to read then necessary.
-				return errorf("%s does not satisfy %s: wrong method signature\n\tgot  %s\n\twant %s",
+				return errorf("%s does not implement %s: wrong method signature\n\tgot  %s\n\twant %s",
 					V, T, wrong, m,
 				)
 			}
-			return errorf("%s does not satisfy %s (missing method %s)", V, T, m.name)
+			return errorf("%s does not implement %s (missing method %s)", V, T, m.name)
 		}
 	}
 
@@ -219,7 +218,7 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 	if Vi != nil {
 		if !Vi.typeSet().subsetOf(Ti.typeSet()) {
 			// TODO(gri) report which type is missing
-			return errorf("%s does not satisfy %s", V, T)
+			return errorf("%s does not implement %s", V, T)
 		}
 		return nil
 	}
@@ -227,7 +226,7 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 	// Otherwise, V's type must be included in the iface type set.
 	if !Ti.typeSet().includes(V) {
 		// TODO(gri) report which type is missing
-		return errorf("%s does not satisfy %s", V, T)
+		return errorf("%s does not implement %s", V, T)
 	}
 
 	return nil
diff --git a/src/cmd/compile/internal/types2/testdata/check/issues.go2 b/src/cmd/compile/internal/types2/testdata/check/issues.go2
index 8608473135..76f9cc5010 100644
--- a/src/cmd/compile/internal/types2/testdata/check/issues.go2
+++ b/src/cmd/compile/internal/types2/testdata/check/issues.go2
@@ -58,7 +58,7 @@ func _() {
 type T1[P interface{~uint}] struct{}
 
 func _[P any]() {
-    _ = T1[P /* ERROR P has no constraints */ ]{}
+    _ = T1[P /* ERROR empty interface P does not implement interface{~uint} */ ]{}
 }
 
 // This is the original (simplified) program causing the same issue.
@@ -74,8 +74,8 @@ func (u T2[U]) Add1() U {
     return u.s + 1
 }
 
-func NewT2[U any]() T2[U /* ERROR U has no constraints */ ] {
-    return T2[U /* ERROR U has no constraints */ ]{}
+func NewT2[U any]() T2[U /* ERROR empty interface U does not implement Unsigned */ ] {
+    return T2[U /* ERROR empty interface U does not implement Unsigned */ ]{}
 }
 
 func _() {
diff --git a/src/cmd/compile/internal/types2/testdata/check/typeinst2.go2 b/src/cmd/compile/internal/types2/testdata/check/typeinst2.go2
index cd56c81bb9..4aaefb3424 100644
--- a/src/cmd/compile/internal/types2/testdata/check/typeinst2.go2
+++ b/src/cmd/compile/internal/types2/testdata/check/typeinst2.go2
@@ -208,7 +208,7 @@ func f0[T I0]() {}
 var _ = f0[int]
 var _ = f0[bool]
 var _ = f0[string]
-var _ = f0[float64 /* ERROR does not satisfy I0 */ ]
+var _ = f0[float64 /* ERROR does not implement I0 */ ]
 
 type I01 interface {
 	E0
@@ -217,9 +217,9 @@ type I01 interface {
 
 func f01[T I01]() {}
 var _ = f01[int]
-var _ = f01[bool /* ERROR does not satisfy I0 */ ]
+var _ = f01[bool /* ERROR does not implement I0 */ ]
 var _ = f01[string]
-var _ = f01[float64 /* ERROR does not satisfy I0 */ ]
+var _ = f01[float64 /* ERROR does not implement I0 */ ]
 
 type I012 interface {
 	E0
@@ -228,10 +228,10 @@ type I012 interface {
 }
 
 func f012[T I012]() {}
-var _ = f012[int /* ERROR does not satisfy I012.*type set is empty */ ]
-var _ = f012[bool /* ERROR does not satisfy I012.*type set is empty */ ]
-var _ = f012[string /* ERROR does not satisfy I012.*type set is empty */ ]
-var _ = f012[float64 /* ERROR does not satisfy I012.*type set is empty */ ]
+var _ = f012[int /* ERROR cannot implement I012.*empty type set */ ]
+var _ = f012[bool /* ERROR cannot implement I012.*empty type set */ ]
+var _ = f012[string /* ERROR cannot implement I012.*empty type set */ ]
+var _ = f012[float64 /* ERROR cannot implement I012.*empty type set */ ]
 
 type I12 interface {
 	E1
@@ -239,9 +239,9 @@ type I12 interface {
 }
 
 func f12[T I12]() {}
-var _ = f12[int /* ERROR does not satisfy I12 */ ]
-var _ = f12[bool /* ERROR does not satisfy I12 */ ]
-var _ = f12[string /* ERROR does not satisfy I12 */ ]
+var _ = f12[int /* ERROR does not implement I12 */ ]
+var _ = f12[bool /* ERROR does not implement I12 */ ]
+var _ = f12[string /* ERROR does not implement I12 */ ]
 var _ = f12[float64]
 
 type I0_ interface {
@@ -251,9 +251,9 @@ type I0_ interface {
 
 func f0_[T I0_]() {}
 var _ = f0_[int]
-var _ = f0_[bool /* ERROR does not satisfy I0_ */ ]
-var _ = f0_[string /* ERROR does not satisfy I0_ */ ]
-var _ = f0_[float64 /* ERROR does not satisfy I0_ */ ]
+var _ = f0_[bool /* ERROR does not implement I0_ */ ]
+var _ = f0_[string /* ERROR does not implement I0_ */ ]
+var _ = f0_[float64 /* ERROR does not implement I0_ */ ]
 
 // Using a function instance as a type is an error.
 var _ f0 // ERROR not a type
@@ -271,7 +271,7 @@ func gg[T any]() {}
 func hh[T ~int]() {}
 
 func _[T none]() {
-        _ = ff[int /* ERROR int does not satisfy none \(constraint type set is empty\) */ ]
+        _ = ff[int /* ERROR cannot implement none \(empty type set\) */ ]
         _ = ff[T]  // pathological but ok because T's type set is empty, too
         _ = gg[int]
         _ = gg[T]
diff --git a/src/cmd/compile/internal/types2/testdata/examples/inference.go2 b/src/cmd/compile/internal/types2/testdata/examples/inference.go2
index 4eb18eb239..0732f06a39 100644
--- a/src/cmd/compile/internal/types2/testdata/examples/inference.go2
+++ b/src/cmd/compile/internal/types2/testdata/examples/inference.go2
@@ -97,7 +97,7 @@ func _() {
 	// last.
 	related2(1.2, []float64{})
 	related2(1.0, []int{})
-	related2( /* ERROR does not satisfy */ float64(1.0), []int{}) // TODO(gri) fix error position
+	related2( /* ERROR does not implement */ float64(1.0), []int{}) // TODO(gri) fix error position
 }
 
 type List[P any] []P
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39754.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39754.go2
index f70b8d0ce0..a88f4cf2f1 100644
--- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39754.go2
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39754.go2
@@ -16,8 +16,8 @@ func f[V interface{}, A, B Box[V]]() {}
 
 func _() {
 	f[int, Optional[int], Optional[int]]()
-	_ = f[int, Optional[int], Optional /* ERROR does not satisfy Box */ [string]]
+	_ = f[int, Optional[int], Optional /* ERROR does not implement Box */ [string]]
 	// TODO(gri) Provide better position information here.
 	//           See TODO in call.go, Checker.arguments.
-	f[int, Optional[int], Optional[string]]( /* ERROR does not satisfy Box */ )
+	f[int, Optional[int], Optional[string]]( /* ERROR does not implement Box */ )
 }
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2
index 620bdb2e4e..b113e104bc 100644
--- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45920.go2
@@ -8,10 +8,10 @@ func f1[T any, C chan T | <-chan T](ch C) {}
 
 func _(ch chan int)   { f1(ch) }
 func _(ch <-chan int) { f1(ch) }
-func _(ch chan<- int) { f1( /* ERROR chan<- int does not satisfy chan int\|<-chan int */ ch) }
+func _(ch chan<- int) { f1( /* ERROR chan<- int does not implement chan int\|<-chan int */ ch) }
 
 func f2[T any, C chan T | chan<- T](ch C) {}
 
 func _(ch chan int)   { f2(ch) }
-func _(ch <-chan int) { f2( /* ERROR <-chan int does not satisfy chan int\|chan<- int */ ch) }
+func _(ch <-chan int) { f2( /* ERROR <-chan int does not implement chan int\|chan<- int */ ch) }
 func _(ch chan<- int) { f2(ch) }
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47411.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47411.go2
index ccf4bcf782..ce5db0a615 100644
--- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47411.go2
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47411.go2
@@ -15,12 +15,12 @@ func _[P comparable,
         _ = f[int]
         _ = f[P]
         _ = f[Q]
-        _ = f[func( /* ERROR does not satisfy comparable */ )]
-        _ = f[R /* ERROR R has no constraints */ ]
+        _ = f[func( /* ERROR does not implement comparable */ )]
+        _ = f[R /* ERROR empty interface R does not implement comparable */ ]
 
         _ = g[int]
-        _ = g[P /* ERROR P does not satisfy interface{interface{comparable; ~int\|~string} */ ]
+        _ = g[P /* ERROR P does not implement interface{interface{comparable; ~int\|~string} */ ]
         _ = g[Q]
-        _ = g[func( /* ERROR does not satisfy comparable */ )]
-        _ = g[R /* ERROR R has no constraints */ ]
+        _ = g[func( /* ERROR does not implement comparable */ )]
+        _ = g[R /* ERROR empty interface R does not implement interface{interface{comparable; ~int\|~string} */ ]
 }
diff --git a/src/constraints/constraints_test.go b/src/constraints/constraints_test.go
index 538dc843cc..47d4cba52a 100644
--- a/src/constraints/constraints_test.go
+++ b/src/constraints/constraints_test.go
@@ -105,7 +105,7 @@ func TestFailure(t *testing.T) {
 				t.Error("build succeeded, but expected to fail")
 			} else if len(out) > 0 {
 				t.Logf("%s", out)
-				const want = "does not satisfy"
+				const want = "does not implement"
 				if !bytes.Contains(out, []byte(want)) {
 					t.Errorf("output does not include %q", want)
 				}
diff --git a/test/typeparam/mdempsky/8.dir/b.go b/test/typeparam/mdempsky/8.dir/b.go
index ef2637b894..84037bf763 100644
--- a/test/typeparam/mdempsky/8.dir/b.go
+++ b/test/typeparam/mdempsky/8.dir/b.go
@@ -7,5 +7,5 @@ package b
 import "./a"
 
 func init() {
-	a.F[func()]() // ERROR "does not satisfy comparable"
+	a.F[func()]() // ERROR "does not implement comparable"
 }
diff --git a/test/typeparam/mincheck.dir/main.go b/test/typeparam/mincheck.dir/main.go
index 9cf2c6bafd..63786de5e6 100644
--- a/test/typeparam/mincheck.dir/main.go
+++ b/test/typeparam/mincheck.dir/main.go
@@ -28,11 +28,11 @@ func main() {
 	}
 
 	const want2 = "ay"
-	if got := a.Min[string]("bb", "ay"); got != want2 { // ERROR "string does not satisfy"
+	if got := a.Min[string]("bb", "ay"); got != want2 { // ERROR "string does not implement"
 		panic(fmt.Sprintf("got %d, want %d", got, want2))
 	}
 
-	if got := a.Min("bb", "ay"); got != want2 { // ERROR "string does not satisfy"
+	if got := a.Min("bb", "ay"); got != want2 { // ERROR "string does not implement"
 		panic(fmt.Sprintf("got %d, want %d", got, want2))
 	}
 }

From d15610128e63e299e39af02ea0e6be1afd38b1ff Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sat, 13 Nov 2021 16:16:53 -0800
Subject: [PATCH 172/752] cmd/compile/internal/types2: add test for imported
 constraints pre-1.18

But exclude the test when running unified build for now
(the unified builder's importers are not yet updated to
handle extended interfaces).
Also, fix respective error position.

Fixes #47967.

Change-Id: I4e3d829b5c12001c024b9eefcc27f97b10c1d1e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/363834
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
Reviewed-by: Robert Findley 
TryBot-Result: Go Bot 
---
 src/cmd/compile/internal/types2/check_test.go   | 17 +++++++++++++++++
 src/cmd/compile/internal/types2/decl.go         |  2 +-
 .../types2/testdata/fixedbugs/issue47818.go2    |  4 +++-
 3 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go
index ddaacd2443..a5ecdf8b81 100644
--- a/src/cmd/compile/internal/types2/check_test.go
+++ b/src/cmd/compile/internal/types2/check_test.go
@@ -25,6 +25,7 @@ package types2_test
 import (
 	"cmd/compile/internal/syntax"
 	"flag"
+	"internal/buildcfg"
 	"internal/testenv"
 	"os"
 	"path/filepath"
@@ -93,11 +94,27 @@ func asGoVersion(s string) string {
 	return ""
 }
 
+// excludedForUnifiedBuild lists files that cannot be tested
+// when using the unified build's export data.
+// TODO(gri) enable as soon as the unified build supports this.
+var excludedForUnifiedBuild = map[string]bool{
+	"issue47818.go2": true,
+}
+
 func testFiles(t *testing.T, filenames []string, colDelta uint, manual bool) {
 	if len(filenames) == 0 {
 		t.Fatal("no source files")
 	}
 
+	if buildcfg.Experiment.Unified {
+		for _, f := range filenames {
+			if excludedForUnifiedBuild[filepath.Base(f)] {
+				t.Logf("%s cannot be tested with unified build - skipped", f)
+				return
+			}
+		}
+	}
+
 	var mode syntax.Mode
 	if strings.HasSuffix(filenames[0], ".go2") || manual {
 		mode |= syntax.AllowGenerics
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 739fc163de..91503f1fcd 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -570,7 +570,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named
 		check.validType(obj.typ, nil)
 		// If typ is local, an error was already reported where typ is specified/defined.
 		if check.isImportedConstraint(rhs) && !check.allowVersion(check.pkg, 1, 18) {
-			check.versionErrorf(tdecl.Type.Pos(), "go1.18", "using type constraint %s", rhs)
+			check.versionErrorf(tdecl.Type, "go1.18", "using type constraint %s", rhs)
 		}
 	}).describef(obj, "validType(%s)", obj.Name())
 
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47818.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47818.go2
index 166cc680db..2631118bae 100644
--- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47818.go2
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47818.go2
@@ -8,6 +8,8 @@
 
 package go1_17
 
+import "constraints"
+
 type T[P /* ERROR type parameters require go1\.18 or later */ any /* ERROR undeclared name: any \(requires version go1\.18 or later\) */ ] struct{}
 
 // for init (and main, but we're not in package main) we should only get one error
@@ -56,4 +58,4 @@ type (
 	_ = C2
 )
 
-// TODO(gri) need test cases for imported constraint types (see also issue #47967)
\ No newline at end of file
+type Ordered constraints /* ERROR using type constraint constraints\.Ordered requires go1\.18 or later */ .Ordered

From 9e13a8876fb531861cbb8e865e57431de9818c16 Mon Sep 17 00:00:00 2001
From: Alessandro Arzilli 
Date: Mon, 15 Nov 2021 09:42:28 +0100
Subject: [PATCH 173/752] debug/dwarf: better error message when reading absent
 debug_line_str

When a DW_FORM_line_strp is used without a debug_line_str section a
good error message (about the missing section) is generated but
immediately overwritten by the underflow error generated by trying to
read the non-existent section.

Updates #49590

Change-Id: I1c431392123a86c78c95ef1f185ebd6f17f2476a
Reviewed-on: https://go-review.googlesource.com/c/go/+/363894
Run-TryBot: Alessandro Arzilli 
Trust: David Chase 
Reviewed-by: Than McIntosh 
---
 src/debug/dwarf/entry.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/debug/dwarf/entry.go b/src/debug/dwarf/entry.go
index 9f5ac57080..25a3b5beec 100644
--- a/src/debug/dwarf/entry.go
+++ b/src/debug/dwarf/entry.go
@@ -641,6 +641,7 @@ func (b *buf) entry(cu *Entry, atab abbrevTable, ubase Offset, vers int) *Entry
 			} else {
 				if len(b.dwarf.lineStr) == 0 {
 					b.error("DW_FORM_line_strp with no .debug_line_str section")
+					return nil
 				}
 				b1 = makeBuf(b.dwarf, b.format, "line_str", 0, b.dwarf.lineStr)
 			}

From 865689571d52fee0b4c910d54bd4ba1484ff2344 Mon Sep 17 00:00:00 2001
From: jiahua wang 
Date: Fri, 12 Nov 2021 10:15:21 +0800
Subject: [PATCH 174/752] doc/go1.18: add AppendRune doc

For #47694

Change-Id: I39594c273aeb038702457587ee1c46e4b3920bb6
Reviewed-on: https://go-review.googlesource.com/c/go/+/363359
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Dmitri Shuralyov 
Reviewed-by: Jeremy Faller 
Trust: Jeremy Faller 
---
 doc/go1.18.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index e796215c78..e266889cad 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -441,7 +441,8 @@ Do not send CLs removing the interior tags from such phrases.
 
unicode/utf8

   

     

-      TODO: https://golang.org/cl/345571: add AppendRune
+      The AppendRune function appends the UTF-8 new
+      encoding of a rune to a []byte.
     

   

 


From fdd67930a0f2fec891e4be9c2b62996eb8b06ce5 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor 
Date: Sat, 13 Nov 2021 14:36:35 -0800
Subject: [PATCH 175/752] sync: in TryLock try to acquire mutex even if state
 is not 0

For #45435

Change-Id: I728accd9a53c1826243f52aa04dc2a0a1dfdaadf
Reviewed-on: https://go-review.googlesource.com/c/go/+/363672
Trust: Ian Lance Taylor 
Run-TryBot: Ian Lance Taylor 
Reviewed-by: Dmitry Vyukov 
---
 src/sync/mutex.go | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/sync/mutex.go b/src/sync/mutex.go
index 9dd04d9470..18b2cedba7 100644
--- a/src/sync/mutex.go
+++ b/src/sync/mutex.go
@@ -87,13 +87,22 @@ func (m *Mutex) Lock() {
 // and use of TryLock is often a sign of a deeper problem
 // in a particular use of mutexes.
 func (m *Mutex) TryLock() bool {
-	if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
-		if race.Enabled {
-			race.Acquire(unsafe.Pointer(m))
-		}
-		return true
+	old := m.state
+	if old&(mutexLocked|mutexStarving) != 0 {
+		return false
 	}
-	return false
+
+	// There may be a goroutine waiting for the mutex, but we are
+	// running now and can try to grab the mutex before that
+	// goroutine wakes up.
+	if !atomic.CompareAndSwapInt32(&m.state, old, old|mutexLocked) {
+		return false
+	}
+
+	if race.Enabled {
+		race.Acquire(unsafe.Pointer(m))
+	}
+	return true
 }
 
 func (m *Mutex) lockSlow() {

From febbef593e8d77500d0e330db91a7be1a71d05e9 Mon Sep 17 00:00:00 2001
From: Keith Randall 
Date: Mon, 15 Nov 2021 14:42:42 -0800
Subject: [PATCH 176/752] doc: mention generics in release notes

Also mention local types restriction.

We probably want to say more at some point, this is just a
placeholder to start.

Update #47631

Change-Id: I828e451e1e8504d21cb55c7132e9cb330b160a54
Reviewed-on: https://go-review.googlesource.com/c/go/+/364134
Trust: Keith Randall 
Reviewed-by: Robert Griesemer 
---
 doc/go1.18.html | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index e266889cad..1ad651ffe8 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -29,6 +29,24 @@ Do not send CLs removing the interior tags from such phrases.
   TODO: complete this section
 

 
+
Generics

+
+

+Go 1.18 includes an implementation of generics as described
+by the
+proposal.
+

+
+

+  The current generics implementation has the following limitations:
+  
    
+    
  • 
+      The Go compiler cannot currently handle type declarations inside generic functions
+      or methods. We hope to provide support for this feature in Go 1.19.
+    
    • 
+  

+

+
 
Ports

 
 
FreeBSD


From a52e4b9c7e8f5aae678596e0c198e67b3b2b1087 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Mon, 15 Nov 2021 14:56:33 -0800
Subject: [PATCH 177/752] cmd/compile/internal/types2: use Identical to verify
 type identity in the Context map

This is a clean port of CL 362798 from go/types to types2,
with an additional comment adjustment in types2 and go/types.

Change-Id: Ifa3d11f512f794f8ae2b6aca50b625a4a44672de
Reviewed-on: https://go-review.googlesource.com/c/go/+/364135
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/context.go    | 52 +++++++++++++++----
 .../compile/internal/types2/instantiate.go    |  4 +-
 src/cmd/compile/internal/types2/named.go      |  2 +-
 src/cmd/compile/internal/types2/predicates.go | 17 ++++++
 src/cmd/compile/internal/types2/subst.go      |  2 +-
 src/cmd/compile/internal/types2/typexpr.go    | 18 +++----
 src/go/types/typexpr.go                       |  2 +-
 7 files changed, 72 insertions(+), 25 deletions(-)

diff --git a/src/cmd/compile/internal/types2/context.go b/src/cmd/compile/internal/types2/context.go
index 9e9eb5bdf6..8833b8097e 100644
--- a/src/cmd/compile/internal/types2/context.go
+++ b/src/cmd/compile/internal/types2/context.go
@@ -5,6 +5,7 @@ package types2
 
 import (
 	"bytes"
+	"fmt"
 	"strings"
 	"sync"
 )
@@ -16,15 +17,15 @@ import (
 // It is safe for concurrent use.
 type Context struct {
 	mu      sync.Mutex
-	typeMap map[string]*Named // type hash -> instance
-	nextID  int               // next unique ID
-	seen    map[*Named]int    // assigned unique IDs
+	typeMap map[string][]*Named // type hash -> instances
+	nextID  int                 // next unique ID
+	seen    map[*Named]int      // assigned unique IDs
 }
 
 // NewContext creates a new Context.
 func NewContext() *Context {
 	return &Context{
-		typeMap: make(map[string]*Named),
+		typeMap: make(map[string][]*Named),
 		seen:    make(map[*Named]int),
 	}
 }
@@ -56,17 +57,46 @@ func (ctxt *Context) typeHash(typ Type, targs []Type) string {
 	return strings.Replace(buf.String(), " ", "#", -1) // ReplaceAll is not available in Go1.4
 }
 
-// typeForHash returns the recorded type for the type hash h, if it exists.
-// If no type exists for h and n is non-nil, n is recorded for h.
-func (ctxt *Context) typeForHash(h string, n *Named) *Named {
+// lookup returns an existing instantiation of orig with targs, if it exists.
+// Otherwise, it returns nil.
+func (ctxt *Context) lookup(h string, orig *Named, targs []Type) *Named {
 	ctxt.mu.Lock()
 	defer ctxt.mu.Unlock()
-	if existing := ctxt.typeMap[h]; existing != nil {
-		return existing
+
+	for _, e := range ctxt.typeMap[h] {
+		if identicalInstance(orig, targs, e.orig, e.TypeArgs().list()) {
+			return e
+		}
+		if debug {
+			// Panic during development to surface any imperfections in our hash.
+			panic(fmt.Sprintf("non-identical instances: (orig: %s, targs: %v) and %s", orig, targs, e))
+		}
 	}
-	if n != nil {
-		ctxt.typeMap[h] = n
+
+	return nil
+}
+
+// update de-duplicates n against previously seen types with the hash h.  If an
+// identical type is found with the type hash h, the previously seen type is
+// returned. Otherwise, n is returned, and recorded in the Context for the hash
+// h.
+func (ctxt *Context) update(h string, n *Named) *Named {
+	assert(n != nil)
+
+	ctxt.mu.Lock()
+	defer ctxt.mu.Unlock()
+
+	for _, e := range ctxt.typeMap[h] {
+		if n == nil || Identical(n, e) {
+			return e
+		}
+		if debug {
+			// Panic during development to surface any imperfections in our hash.
+			panic(fmt.Sprintf("%s and %s are not identical", n, e))
+		}
 	}
+
+	ctxt.typeMap[h] = append(ctxt.typeMap[h], n)
 	return n
 }
 
diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index 3834c6ba87..65ed25ddff 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -60,7 +60,7 @@ func (check *Checker) instance(pos syntax.Pos, typ Type, targs []Type, ctxt *Con
 			h = ctxt.typeHash(t, targs)
 			// typ may already have been instantiated with identical type arguments. In
 			// that case, re-use the existing instance.
-			if named := ctxt.typeForHash(h, nil); named != nil {
+			if named := ctxt.lookup(h, t, targs); named != nil {
 				return named
 			}
 		}
@@ -73,7 +73,7 @@ func (check *Checker) instance(pos syntax.Pos, typ Type, targs []Type, ctxt *Con
 		if ctxt != nil {
 			// It's possible that we've lost a race to add named to the context.
 			// In this case, use whichever instance is recorded in the context.
-			named = ctxt.typeForHash(h, named)
+			named = ctxt.update(h, named)
 		}
 		return named
 
diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go
index e73a31d42e..78c6803d99 100644
--- a/src/cmd/compile/internal/types2/named.go
+++ b/src/cmd/compile/internal/types2/named.go
@@ -253,7 +253,7 @@ func expandNamed(ctxt *Context, n *Named, instPos syntax.Pos) (tparams *TypePara
 		ctxt = check.bestContext(ctxt)
 		h := ctxt.typeHash(n.orig, n.targs.list())
 		// ensure that an instance is recorded for h to avoid infinite recursion.
-		ctxt.typeForHash(h, n)
+		ctxt.update(h, n)
 
 		smap := makeSubstMap(n.orig.tparams.list(), n.targs.list())
 		underlying = n.check.subst(instPos, n.orig.underlying, smap, ctxt)
diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index 8ba534ce77..e7834a0f9e 100644
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -372,6 +372,23 @@ func identical(x, y Type, cmpTags bool, p *ifacePair) bool {
 	return false
 }
 
+// identicalInstance reports if two type instantiations are identical.
+// Instantiations are identical if their origin and type arguments are
+// identical.
+func identicalInstance(xorig Type, xargs []Type, yorig Type, yargs []Type) bool {
+	if len(xargs) != len(yargs) {
+		return false
+	}
+
+	for i, xa := range xargs {
+		if !Identical(xa, yargs[i]) {
+			return false
+		}
+	}
+
+	return Identical(xorig, yorig)
+}
+
 func identicalTParams(x, y []*TypeParam, cmpTags bool, p *ifacePair) bool {
 	if len(x) != len(y) {
 		return false
diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
index ed1fbbf941..9b82f8889a 100644
--- a/src/cmd/compile/internal/types2/subst.go
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -209,7 +209,7 @@ func (subst *subster) typ(typ Type) Type {
 		// before creating a new named type, check if we have this one already
 		h := subst.ctxt.typeHash(t.orig, newTArgs)
 		dump(">>> new type hash: %s", h)
-		if named := subst.ctxt.typeForHash(h, nil); named != nil {
+		if named := subst.ctxt.lookup(h, t.orig, newTArgs); named != nil {
 			dump(">>> found %s", named)
 			return named
 		}
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index e077879b9d..05481a9a64 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -418,8 +418,8 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 		return gtyp // error already reported
 	}
 
-	origin, _ := gtyp.(*Named)
-	if origin == nil {
+	orig, _ := gtyp.(*Named)
+	if orig == nil {
 		panic(fmt.Sprintf("%v: cannot instantiate %v", x.Pos(), gtyp))
 	}
 
@@ -437,23 +437,23 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 	}
 
 	// create the instance
-	h := check.conf.Context.typeHash(origin, targs)
+	h := check.conf.Context.typeHash(orig, targs)
 	// targs may be incomplete, and require inference. In any case we should de-duplicate.
-	inst := check.conf.Context.typeForHash(h, nil)
+	inst := check.conf.Context.lookup(h, orig, targs)
 	// If inst is non-nil, we can't just return here. Inst may have been
 	// constructed via recursive substitution, in which case we wouldn't do the
 	// validation below. Ensure that the validation (and resulting errors) runs
 	// for each instantiated type in the source.
 	if inst == nil {
-		tname := NewTypeName(x.Pos(), origin.obj.pkg, origin.obj.name, nil)
-		inst = check.newNamed(tname, origin, nil, nil, nil) // underlying, methods and tparams are set when named is resolved
+		tname := NewTypeName(x.Pos(), orig.obj.pkg, orig.obj.name, nil)
+		inst = check.newNamed(tname, orig, nil, nil, nil) // underlying, methods and tparams are set when named is resolved
 		inst.targs = NewTypeList(targs)
-		inst = check.conf.Context.typeForHash(h, inst)
+		inst = check.conf.Context.update(h, inst)
 	}
 	def.setUnderlying(inst)
 
 	inst.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) {
-		tparams := origin.TypeParams().list()
+		tparams := orig.TypeParams().list()
 
 		inferred := targs
 		if len(targs) < len(tparams) {
@@ -469,7 +469,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 		return expandNamed(ctxt, n, x.Pos())
 	}
 
-	// origin.tparams may not be set up, so we need to do expansion later.
+	// orig.tparams may not be set up, so we need to do expansion later.
 	check.later(func() {
 		// This is an instance from the source, not from recursive substitution,
 		// and so it must be resolved during type-checking so that we can report
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index d80acbe7d6..5828c2e7c3 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -449,7 +449,7 @@ func (check *Checker) instantiatedType(ix *typeparams.IndexExpr, def *Named) (re
 		return expandNamed(ctxt, n, pos)
 	}
 
-	// origin.tparams may not be set up, so we need to do expansion later.
+	// orig.tparams may not be set up, so we need to do expansion later.
 	check.later(func() {
 		// This is an instance from the source, not from recursive substitution,
 		// and so it must be resolved during type-checking so that we can report

From 313cae3861841e9c64bebe2c1aed8126cf6cc117 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Mon, 15 Nov 2021 15:21:42 -0800
Subject: [PATCH 178/752] cmd/compile/internal/types2: refactor the Context
 type map to accept arbitrary types

This CL is a clean port of CL 362799 from go/types to types2.

Change-Id: Id670aa4b1ca0b568a79bb6e4855747807dcf00f3
Reviewed-on: https://go-review.googlesource.com/c/go/+/364154
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/context.go    | 42 ++++++++++++-------
 .../compile/internal/types2/instantiate.go    | 25 ++++++-----
 src/cmd/compile/internal/types2/named.go      |  2 +-
 src/cmd/compile/internal/types2/typexpr.go    |  4 +-
 4 files changed, 41 insertions(+), 32 deletions(-)

diff --git a/src/cmd/compile/internal/types2/context.go b/src/cmd/compile/internal/types2/context.go
index 8833b8097e..b6fd9822b2 100644
--- a/src/cmd/compile/internal/types2/context.go
+++ b/src/cmd/compile/internal/types2/context.go
@@ -17,15 +17,21 @@ import (
 // It is safe for concurrent use.
 type Context struct {
 	mu      sync.Mutex
-	typeMap map[string][]*Named // type hash -> instances
-	nextID  int                 // next unique ID
-	seen    map[*Named]int      // assigned unique IDs
+	typeMap map[string][]ctxtEntry // type hash -> instances entries
+	nextID  int                    // next unique ID
+	seen    map[*Named]int         // assigned unique IDs
+}
+
+type ctxtEntry struct {
+	orig     Type
+	targs    []Type
+	instance Type // = orig[targs]
 }
 
 // NewContext creates a new Context.
 func NewContext() *Context {
 	return &Context{
-		typeMap: make(map[string][]*Named),
+		typeMap: make(map[string][]ctxtEntry),
 		seen:    make(map[*Named]int),
 	}
 }
@@ -59,17 +65,17 @@ func (ctxt *Context) typeHash(typ Type, targs []Type) string {
 
 // lookup returns an existing instantiation of orig with targs, if it exists.
 // Otherwise, it returns nil.
-func (ctxt *Context) lookup(h string, orig *Named, targs []Type) *Named {
+func (ctxt *Context) lookup(h string, orig *Named, targs []Type) Type {
 	ctxt.mu.Lock()
 	defer ctxt.mu.Unlock()
 
 	for _, e := range ctxt.typeMap[h] {
-		if identicalInstance(orig, targs, e.orig, e.TypeArgs().list()) {
-			return e
+		if identicalInstance(orig, targs, e.orig, e.targs) {
+			return e.instance
 		}
 		if debug {
 			// Panic during development to surface any imperfections in our hash.
-			panic(fmt.Sprintf("non-identical instances: (orig: %s, targs: %v) and %s", orig, targs, e))
+			panic(fmt.Sprintf("non-identical instances: (orig: %s, targs: %v) and %s", orig, targs, e.instance))
 		}
 	}
 
@@ -80,24 +86,28 @@ func (ctxt *Context) lookup(h string, orig *Named, targs []Type) *Named {
 // identical type is found with the type hash h, the previously seen type is
 // returned. Otherwise, n is returned, and recorded in the Context for the hash
 // h.
-func (ctxt *Context) update(h string, n *Named) *Named {
-	assert(n != nil)
-
+func (ctxt *Context) update(h string, orig Type, targs []Type, inst Type) Type {
+	assert(inst != nil)
 	ctxt.mu.Lock()
 	defer ctxt.mu.Unlock()
 
 	for _, e := range ctxt.typeMap[h] {
-		if n == nil || Identical(n, e) {
-			return e
+		if inst == nil || Identical(inst, e.instance) {
+			return e.instance
 		}
 		if debug {
 			// Panic during development to surface any imperfections in our hash.
-			panic(fmt.Sprintf("%s and %s are not identical", n, e))
+			panic(fmt.Sprintf("%s and %s are not identical", inst, e.instance))
 		}
 	}
 
-	ctxt.typeMap[h] = append(ctxt.typeMap[h], n)
-	return n
+	ctxt.typeMap[h] = append(ctxt.typeMap[h], ctxtEntry{
+		orig:     orig,
+		targs:    targs,
+		instance: inst,
+	})
+
+	return inst
 }
 
 // idForType returns a unique ID for the pointer n.
diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index 65ed25ddff..9408fa43d9 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -52,20 +52,20 @@ func Instantiate(ctxt *Context, typ Type, targs []Type, validate bool) (Type, er
 // instance creates a type or function instance using the given original type
 // typ and arguments targs. For Named types the resulting instance will be
 // unexpanded.
-func (check *Checker) instance(pos syntax.Pos, typ Type, targs []Type, ctxt *Context) Type {
-	switch t := typ.(type) {
+func (check *Checker) instance(pos syntax.Pos, orig Type, targs []Type, ctxt *Context) Type {
+	switch orig := orig.(type) {
 	case *Named:
 		var h string
 		if ctxt != nil {
-			h = ctxt.typeHash(t, targs)
+			h = ctxt.typeHash(orig, targs)
 			// typ may already have been instantiated with identical type arguments. In
 			// that case, re-use the existing instance.
-			if named := ctxt.lookup(h, t, targs); named != nil {
+			if named := ctxt.lookup(h, orig, targs); named != nil {
 				return named
 			}
 		}
-		tname := NewTypeName(pos, t.obj.pkg, t.obj.name, nil)
-		named := check.newNamed(tname, t, nil, nil, nil) // underlying, tparams, and methods are set when named is resolved
+		tname := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil)
+		named := check.newNamed(tname, orig, nil, nil, nil) // underlying, tparams, and methods are set when named is resolved
 		named.targs = NewTypeList(targs)
 		named.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) {
 			return expandNamed(ctxt, n, pos)
@@ -73,23 +73,23 @@ func (check *Checker) instance(pos syntax.Pos, typ Type, targs []Type, ctxt *Con
 		if ctxt != nil {
 			// It's possible that we've lost a race to add named to the context.
 			// In this case, use whichever instance is recorded in the context.
-			named = ctxt.update(h, named)
+			named = ctxt.update(h, orig, targs, named).(*Named)
 		}
 		return named
 
 	case *Signature:
-		tparams := t.TypeParams()
+		tparams := orig.TypeParams()
 		if !check.validateTArgLen(pos, tparams.Len(), len(targs)) {
 			return Typ[Invalid]
 		}
 		if tparams.Len() == 0 {
-			return typ // nothing to do (minor optimization)
+			return orig // nothing to do (minor optimization)
 		}
-		sig := check.subst(pos, typ, makeSubstMap(tparams.list(), targs), ctxt).(*Signature)
+		sig := check.subst(pos, orig, makeSubstMap(tparams.list(), targs), ctxt).(*Signature)
 		// If the signature doesn't use its type parameters, subst
 		// will not make a copy. In that case, make a copy now (so
 		// we can set tparams to nil w/o causing side-effects).
-		if sig == t {
+		if sig == orig {
 			copy := *sig
 			sig = ©
 		}
@@ -98,9 +98,8 @@ func (check *Checker) instance(pos syntax.Pos, typ Type, targs []Type, ctxt *Con
 		sig.tparams = nil
 		return sig
 	}
-
 	// only types and functions can be generic
-	panic(fmt.Sprintf("%v: cannot instantiate %v", pos, typ))
+	panic(fmt.Sprintf("%v: cannot instantiate %v", pos, orig))
 }
 
 // validateTArgLen verifies that the length of targs and tparams matches,
diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go
index 78c6803d99..e90c301a0d 100644
--- a/src/cmd/compile/internal/types2/named.go
+++ b/src/cmd/compile/internal/types2/named.go
@@ -253,7 +253,7 @@ func expandNamed(ctxt *Context, n *Named, instPos syntax.Pos) (tparams *TypePara
 		ctxt = check.bestContext(ctxt)
 		h := ctxt.typeHash(n.orig, n.targs.list())
 		// ensure that an instance is recorded for h to avoid infinite recursion.
-		ctxt.update(h, n)
+		ctxt.update(h, n.orig, n.TypeArgs().list(), n)
 
 		smap := makeSubstMap(n.orig.tparams.list(), n.targs.list())
 		underlying = n.check.subst(instPos, n.orig.underlying, smap, ctxt)
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 05481a9a64..4ba21fa9a0 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -439,7 +439,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 	// create the instance
 	h := check.conf.Context.typeHash(orig, targs)
 	// targs may be incomplete, and require inference. In any case we should de-duplicate.
-	inst := check.conf.Context.lookup(h, orig, targs)
+	inst, _ := check.conf.Context.lookup(h, orig, targs).(*Named)
 	// If inst is non-nil, we can't just return here. Inst may have been
 	// constructed via recursive substitution, in which case we wouldn't do the
 	// validation below. Ensure that the validation (and resulting errors) runs
@@ -448,7 +448,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 		tname := NewTypeName(x.Pos(), orig.obj.pkg, orig.obj.name, nil)
 		inst = check.newNamed(tname, orig, nil, nil, nil) // underlying, methods and tparams are set when named is resolved
 		inst.targs = NewTypeList(targs)
-		inst = check.conf.Context.update(h, inst)
+		inst = check.conf.Context.update(h, orig, targs, inst).(*Named)
 	}
 	def.setUnderlying(inst)
 

From 6b3f4d388fe5602172f45361f438edf54699b953 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Mon, 15 Nov 2021 15:28:12 -0800
Subject: [PATCH 179/752] cmd/compile/internal/types2: re-use type hashing
 logic in Context.typeHash

This CL is clean port of CL 362800 from go/types to types2.

Change-Id: I66443b5a82b3a9c2f608a0fe012fbb099db996f3
Reviewed-on: https://go-review.googlesource.com/c/go/+/364155
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/context.go    | 26 +++++++------------
 .../compile/internal/types2/instantiate.go    |  4 +--
 2 files changed, 12 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/types2/context.go b/src/cmd/compile/internal/types2/context.go
index b6fd9822b2..93a0cb8d40 100644
--- a/src/cmd/compile/internal/types2/context.go
+++ b/src/cmd/compile/internal/types2/context.go
@@ -36,28 +36,22 @@ func NewContext() *Context {
 	}
 }
 
-// typeHash returns a string representation of typ, which can be used as an exact
-// type hash: types that are identical produce identical string representations.
-// If typ is a *Named type and targs is not empty, typ is printed as if it were
-// instantiated with targs. The result is guaranteed to not contain blanks (" ").
+// typeHash returns a string representation of typ instantiated with targs,
+// which can be used as an exact type hash: types that are identical produce
+// identical string representations. If targs is not empty, typ is printed as
+// if it were instantiated with targs. The result is guaranteed to not contain
+// blanks (" ").
 func (ctxt *Context) typeHash(typ Type, targs []Type) string {
 	assert(ctxt != nil)
 	assert(typ != nil)
 	var buf bytes.Buffer
 
 	h := newTypeHasher(&buf, ctxt)
-	// Caution: don't use asNamed here. TypeHash may be called for unexpanded
-	// types. We don't need anything other than name and type arguments below,
-	// which do not require expansion.
-	if named, _ := typ.(*Named); named != nil && len(targs) > 0 {
-		// Don't use WriteType because we need to use the provided targs
-		// and not any targs that might already be with the *Named type.
-		h.typePrefix(named)
-		h.typeName(named.obj)
+	h.typ(typ)
+	if len(targs) > 0 {
+		// TODO(rfindley): consider asserting on isGeneric(typ) here, if and when
+		// isGeneric handles *Signature types.
 		h.typeList(targs)
-	} else {
-		assert(targs == nil)
-		h.typ(typ)
 	}
 
 	return strings.Replace(buf.String(), " ", "#", -1) // ReplaceAll is not available in Go1.4
@@ -65,7 +59,7 @@ func (ctxt *Context) typeHash(typ Type, targs []Type) string {
 
 // lookup returns an existing instantiation of orig with targs, if it exists.
 // Otherwise, it returns nil.
-func (ctxt *Context) lookup(h string, orig *Named, targs []Type) Type {
+func (ctxt *Context) lookup(h string, orig Type, targs []Type) Type {
 	ctxt.mu.Lock()
 	defer ctxt.mu.Unlock()
 
diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index 9408fa43d9..299d63dc60 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -60,8 +60,8 @@ func (check *Checker) instance(pos syntax.Pos, orig Type, targs []Type, ctxt *Co
 			h = ctxt.typeHash(orig, targs)
 			// typ may already have been instantiated with identical type arguments. In
 			// that case, re-use the existing instance.
-			if named := ctxt.lookup(h, orig, targs); named != nil {
-				return named
+			if inst := ctxt.lookup(h, orig, targs); inst != nil {
+				return inst
 			}
 		}
 		tname := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil)

From 6e481c0b36ca484a9fe4a1de25b6def06a26b988 Mon Sep 17 00:00:00 2001
From: Alberto Donizetti 
Date: Wed, 27 Oct 2021 17:37:09 +0200
Subject: [PATCH 180/752] cmd/go: don't try to print build info of non-Go
 binaries

On a non-nil err, buildinfo.ReadFile will always return a nil
*Buildinfo. In scanFile, we need to return early if that happens.

Fixes #49181

Change-Id: I354348d206ab084804937c6f922eadb61435e7b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/359154
Trust: Alberto Donizetti 
Run-TryBot: Alberto Donizetti 
Reviewed-by: Bryan C. Mills 
---
 src/cmd/go/internal/version/version.go    | 1 +
 src/cmd/go/testdata/script/go_version.txt | 9 +++++++++
 2 files changed, 10 insertions(+)
 create mode 100644 src/cmd/go/testdata/script/go_version.txt

diff --git a/src/cmd/go/internal/version/version.go b/src/cmd/go/internal/version/version.go
index febc7c638a..52502e95c6 100644
--- a/src/cmd/go/internal/version/version.go
+++ b/src/cmd/go/internal/version/version.go
@@ -151,6 +151,7 @@ func scanFile(file string, info fs.FileInfo, mustPrint bool) {
 				fmt.Fprintf(os.Stderr, "%s: %v\n", file, err)
 			}
 		}
+		return
 	}
 
 	fmt.Printf("%s: %s\n", file, bi.GoVersion)
diff --git a/src/cmd/go/testdata/script/go_version.txt b/src/cmd/go/testdata/script/go_version.txt
new file mode 100644
index 0000000000..1a787e1b18
--- /dev/null
+++ b/src/cmd/go/testdata/script/go_version.txt
@@ -0,0 +1,9 @@
+# test that go version doesn't panic on non-go binaries
+# See Issue #49181
+
+[exec:/bin/true] cp /bin/true true
+[exec:C:\windows\system32\help.exe] cp C:\windows\system32\help.exe help.exe
+
+go version -m .
+! stdout .
+! stderr .

From 9efb6493f498f8fdcc5d34d4df4d5e9c620f861b Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 15 Nov 2021 21:12:33 -0500
Subject: [PATCH 181/752] all: update vendored golang.org/x/tools

Update the vendored x/tools to pick up the fix for #49597, using the
following commands:

  go get -d golang.org/x/tools@4adea5033c5c6f39a900d4b963c4b496448b1655
  go mod tidy
  go mod vendor

Fixes #49597

Change-Id: Ib1bc43aacbdc707b605194012134f048a336e176
Reviewed-on: https://go-review.googlesource.com/c/go/+/363986
Trust: Robert Findley 
Run-TryBot: Dmitri Shuralyov 
Reviewed-by: Dmitri Shuralyov 
TryBot-Result: Go Bot 
---
 src/cmd/go.mod                                |   2 +-
 src/cmd/go.sum                                |   4 +-
 .../go/analysis/passes/composite/composite.go |  21 ++-
 .../x/tools/go/analysis/passes/shift/shift.go |  20 ++-
 .../analysis/passes/stringintconv/string.go   |  37 +++--
 .../x/tools/internal/typeparams/normalize.go  | 132 ++++++++----------
 src/cmd/vendor/modules.txt                    |   2 +-
 7 files changed, 117 insertions(+), 101 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index facc54cee1..014c854a73 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -8,7 +8,7 @@ require (
 	golang.org/x/mod v0.6.0-dev.0.20210913215816-37dd6891021a
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
 	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211
-	golang.org/x/tools v0.1.8-0.20211109164901-e9000123914f
+	golang.org/x/tools v0.1.8-0.20211116011028-4adea5033c5c
 )
 
 require (
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index f248d84e24..4f50e7c6c8 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -18,7 +18,7 @@ golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e h1:i6Vklmyu+fZMFYpum+sR4ZWAB
 golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/tools v0.1.8-0.20211109164901-e9000123914f h1:wwsTeyXackfHvwdCKtGcDlYwO78AwwW6OwUomSMB0aI=
-golang.org/x/tools v0.1.8-0.20211109164901-e9000123914f/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
+golang.org/x/tools v0.1.8-0.20211116011028-4adea5033c5c h1:EftGXIEk7/EwE5R+/azXJzSbzwNumuLeH9oupAN7YV0=
+golang.org/x/tools v0.1.8-0.20211116011028-4adea5033c5c/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/composite/composite.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/composite/composite.go
index 025952ed50..d3670aca97 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/composite/composite.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/composite/composite.go
@@ -68,17 +68,26 @@ func run(pass *analysis.Pass) (interface{}, error) {
 			// skip whitelisted types
 			return
 		}
-		terms, err := typeparams.StructuralTerms(typ)
-		if err != nil {
-			return // invalid type
+		var structuralTypes []types.Type
+		switch typ := typ.(type) {
+		case *typeparams.TypeParam:
+			terms, err := typeparams.StructuralTerms(typ)
+			if err != nil {
+				return // invalid type
+			}
+			for _, term := range terms {
+				structuralTypes = append(structuralTypes, term.Type())
+			}
+		default:
+			structuralTypes = append(structuralTypes, typ)
 		}
-		for _, term := range terms {
-			under := deref(term.Type().Underlying())
+		for _, typ := range structuralTypes {
+			under := deref(typ.Underlying())
 			if _, ok := under.(*types.Struct); !ok {
 				// skip non-struct composite literals
 				continue
 			}
-			if isLocalType(pass, term.Type()) {
+			if isLocalType(pass, typ) {
 				// allow unkeyed locally defined composite literal
 				continue
 			}
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go
index 640de28e05..e968f27b40 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/shift/shift.go
@@ -14,6 +14,7 @@ import (
 	"go/ast"
 	"go/constant"
 	"go/token"
+	"go/types"
 	"math"
 
 	"golang.org/x/tools/go/analysis"
@@ -95,13 +96,22 @@ func checkLongShift(pass *analysis.Pass, node ast.Node, x, y ast.Expr) {
 	if t == nil {
 		return
 	}
-	terms, err := typeparams.StructuralTerms(t)
-	if err != nil {
-		return // invalid type
+	var structuralTypes []types.Type
+	switch t := t.(type) {
+	case *typeparams.TypeParam:
+		terms, err := typeparams.StructuralTerms(t)
+		if err != nil {
+			return // invalid type
+		}
+		for _, term := range terms {
+			structuralTypes = append(structuralTypes, term.Type())
+		}
+	default:
+		structuralTypes = append(structuralTypes, t)
 	}
 	sizes := make(map[int64]struct{})
-	for _, term := range terms {
-		size := 8 * pass.TypesSizes.Sizeof(term.Type())
+	for _, t := range structuralTypes {
+		size := 8 * pass.TypesSizes.Sizeof(t)
 		sizes[size] = struct{}{}
 	}
 	minSize := int64(math.MaxInt64)
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go
index 92fd375f23..e41de809de 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stringintconv/string.go
@@ -110,17 +110,17 @@ func run(pass *analysis.Pass) (interface{}, error) {
 
 		// First, find a type T0 in T that has an underlying type of string.
 		T := tname.Type()
-		tterms, err := typeparams.StructuralTerms(T)
+		ttypes, err := structuralTypes(T)
 		if err != nil {
 			return // invalid type
 		}
 
 		var T0 types.Type // string type in the type set of T
 
-		for _, term := range tterms {
-			u, _ := term.Type().Underlying().(*types.Basic)
+		for _, tt := range ttypes {
+			u, _ := tt.Underlying().(*types.Basic)
 			if u != nil && u.Kind() == types.String {
-				T0 = term.Type()
+				T0 = tt
 				break
 			}
 		}
@@ -133,21 +133,21 @@ func run(pass *analysis.Pass) (interface{}, error) {
 		// Next, find a type V0 in V that has an underlying integral type that is
 		// not byte or rune.
 		V := pass.TypesInfo.TypeOf(arg)
-		vterms, err := typeparams.StructuralTerms(V)
+		vtypes, err := structuralTypes(V)
 		if err != nil {
 			return // invalid type
 		}
 
 		var V0 types.Type // integral type in the type set of V
 
-		for _, term := range vterms {
-			u, _ := term.Type().Underlying().(*types.Basic)
+		for _, vt := range vtypes {
+			u, _ := vt.Underlying().(*types.Basic)
 			if u != nil && u.Info()&types.IsInteger != 0 {
 				switch u.Kind() {
 				case types.Byte, types.Rune, types.UntypedRune:
 					continue
 				}
-				V0 = term.Type()
+				V0 = vt
 				break
 			}
 		}
@@ -158,8 +158,8 @@ func run(pass *analysis.Pass) (interface{}, error) {
 		}
 
 		convertibleToRune := true // if true, we can suggest a fix
-		for _, term := range vterms {
-			if !types.ConvertibleTo(term.Type(), types.Typ[types.Rune]) {
+		for _, t := range vtypes {
+			if !types.ConvertibleTo(t, types.Typ[types.Rune]) {
 				convertibleToRune = false
 				break
 			}
@@ -200,3 +200,20 @@ func run(pass *analysis.Pass) (interface{}, error) {
 	})
 	return nil, nil
 }
+
+func structuralTypes(t types.Type) ([]types.Type, error) {
+	var structuralTypes []types.Type
+	switch t := t.(type) {
+	case *typeparams.TypeParam:
+		terms, err := typeparams.StructuralTerms(t)
+		if err != nil {
+			return nil, err
+		}
+		for _, term := range terms {
+			structuralTypes = append(structuralTypes, term.Type())
+		}
+	default:
+		structuralTypes = append(structuralTypes, t)
+	}
+	return structuralTypes, nil
+}
diff --git a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/normalize.go b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/normalize.go
index 29373508e9..f41ec6ec0b 100644
--- a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/normalize.go
+++ b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/normalize.go
@@ -16,92 +16,72 @@ import (
 
 const debug = false
 
-// NormalizeInterface returns the normal form of the interface iface, or nil if iface
-// has an empty type set (i.e. there are no types that satisfy iface). If the
-// resulting interface is non-nil, it will be identical to iface.
+var ErrEmptyTypeSet = errors.New("empty type set")
+
+// StructuralTerms returns a slice of terms representing the normalized
+// structural type restrictions of a type parameter, if any.
 //
-// An error is returned if the interface type is invalid, or too complicated to
-// reasonably normalize (for example, contains unions with more than a hundred
-// terms).
+// Structural type restrictions of a type parameter are created via
+// non-interface types embedded in its constraint interface (directly, or via a
+// chain of interface embeddings). For example, in the declaration `type T[P
+// interface{~int; m()}] int`, the structural restriction of the type parameter
+// P is ~int.
 //
-// An interface is in normal form if and only if:
-//   - it has 0 or 1 embedded types.
-//   - its embedded type is either a types.Union or has a concrete
-//     (non-interface) underlying type
-//   - if the embedded type is a union, each term of the union has a concrete
-//     underlying type, and no terms may be removed without changing the type set
-//     of the interface
-func NormalizeInterface(iface *types.Interface) (*types.Interface, error) {
-	var methods []*types.Func
-	for i := 0; i < iface.NumMethods(); i++ {
-		methods = append(methods, iface.Method(i))
+// With interface embedding and unions, the specification of structural type
+// restrictions may be arbitrarily complex. For example, consider the
+// following:
+//
+//  type A interface{ ~string|~[]byte }
+//
+//  type B interface{ int|string }
+//
+//  type C interface { ~string|~int }
+//
+//  type T[P interface{ A|B; C }] int
+//
+// In this example, the structural type restriction of P is ~string|int: A|B
+// expands to ~string|~[]byte|int|string, which reduces to ~string|~[]byte|int,
+// which when intersected with C (~string|~int) yields ~string|int.
+//
+// StructuralTerms computes these expansions and reductions, producing a
+// "normalized" form of the embeddings. A structural restriction is normalized
+// if it is a single union containing no interface terms, and is minimal in the
+// sense that removing any term changes the set of types satisfying the
+// constraint. It is left as a proof for the reader that, modulo sorting, there
+// is exactly one such normalized form.
+//
+// Because the minimal representation always takes this form, StructuralTerms
+// returns a slice of tilde terms corresponding to the terms of the union in
+// the normalized structural restriction. An error is returned if the
+// constraint interface is invalid, exceeds complexity bounds, or has an empty
+// type set. In the latter case, StructuralTerms returns ErrEmptyTypeSet.
+//
+// StructuralTerms makes no guarantees about the order of terms, except that it
+// is deterministic.
+func StructuralTerms(tparam *TypeParam) ([]*Term, error) {
+	constraint := tparam.Constraint()
+	if constraint == nil {
+		return nil, fmt.Errorf("%s has nil constraint", tparam)
+	}
+	iface, _ := constraint.Underlying().(*types.Interface)
+	if iface == nil {
+		return nil, fmt.Errorf("constraint is %T, not *types.Interface", constraint.Underlying())
 	}
-	var embeddeds []types.Type
 	tset, err := computeTermSet(iface, make(map[types.Type]*termSet), 0)
 	if err != nil {
 		return nil, err
 	}
-	switch {
-	case tset.terms.isEmpty():
-		// Special case: as documented
+	if tset.terms.isEmpty() {
+		return nil, ErrEmptyTypeSet
+	}
+	if tset.terms.isAll() {
 		return nil, nil
-
-	case tset.terms.isAll():
-		// No embeddeds.
-
-	case len(tset.terms) == 1:
-		if !tset.terms[0].tilde {
-			embeddeds = append(embeddeds, tset.terms[0].typ)
-			break
-		}
-		fallthrough
-	default:
-		var terms []*Term
-		for _, term := range tset.terms {
-			terms = append(terms, NewTerm(term.tilde, term.typ))
-		}
-		embeddeds = append(embeddeds, NewUnion(terms))
 	}
-
-	return types.NewInterfaceType(methods, embeddeds), nil
-}
-
-var ErrEmptyTypeSet = errors.New("empty type set")
-
-// StructuralTerms returns the normalized structural type restrictions of a
-// type, if any. For types that are not type parameters, it returns term slice
-// containing a single non-tilde term holding the given type. For type
-// parameters, it returns the normalized term list of the type parameter's
-// constraint. See NormalizeInterface for more information on the normal form
-// of a constraint interface.
-//
-// StructuralTerms returns an error if the structural term list cannot be
-// computed. If the type set of typ is empty, it returns ErrEmptyTypeSet.
-func StructuralTerms(typ types.Type) ([]*Term, error) {
-	switch typ := typ.(type) {
-	case *TypeParam:
-		iface, _ := typ.Constraint().(*types.Interface)
-		if iface == nil {
-			return nil, fmt.Errorf("constraint is %T, not *types.Interface", typ)
-		}
-		tset, err := computeTermSet(iface, make(map[types.Type]*termSet), 0)
-		if err != nil {
-			return nil, err
-		}
-		if tset.terms.isEmpty() {
-			return nil, ErrEmptyTypeSet
-		}
-		if tset.terms.isAll() {
-			return nil, nil
-		}
-		var terms []*Term
-		for _, term := range tset.terms {
-			terms = append(terms, NewTerm(term.tilde, term.typ))
-		}
-		return terms, nil
-	default:
-		return []*Term{NewTerm(false, typ)}, nil
+	var terms []*Term
+	for _, term := range tset.terms {
+		terms = append(terms, NewTerm(term.tilde, term.typ))
 	}
+	return terms, nil
 }
 
 // A termSet holds the normalized set of terms for a given type.
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 3806f7171c..82e04c1d33 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -51,7 +51,7 @@ golang.org/x/sys/windows
 # golang.org/x/term v0.0.0-20210927222741-03fcf44c2211
 ## explicit; go 1.17
 golang.org/x/term
-# golang.org/x/tools v0.1.8-0.20211109164901-e9000123914f
+# golang.org/x/tools v0.1.8-0.20211116011028-4adea5033c5c
 ## explicit; go 1.17
 golang.org/x/tools/cover
 golang.org/x/tools/go/analysis

From bddb79f0faa11958ff473109398be684c088a6a9 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 15 Nov 2021 22:22:26 -0500
Subject: [PATCH 182/752] go/types: use type variables consistently in
 Checker.conversion

This is a clean port of CL 362895 from types2 to go/types.

Change-Id: Icd0631127c51aec80ce9450df2be71bf4b96b2df
Reviewed-on: https://go-review.googlesource.com/c/go/+/363987
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/conversions.go | 26 +++++++++-----------------
 1 file changed, 9 insertions(+), 17 deletions(-)

diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index 26bebd4ade..18d24e404c 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -139,39 +139,39 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 	}
 
 	// "V and T are both integer or floating point types"
-	if isIntegerOrFloat(V) && isIntegerOrFloat(T) {
+	if isIntegerOrFloat(Vu) && isIntegerOrFloat(Tu) {
 		return true
 	}
 
 	// "V and T are both complex types"
-	if isComplex(V) && isComplex(T) {
+	if isComplex(Vu) && isComplex(Tu) {
 		return true
 	}
 
 	// "V is an integer or a slice of bytes or runes and T is a string type"
-	if (isInteger(V) || isBytesOrRunes(Vu)) && isString(T) {
+	if (isInteger(Vu) || isBytesOrRunes(Vu)) && isString(Tu) {
 		return true
 	}
 
 	// "V is a string and T is a slice of bytes or runes"
-	if isString(V) && isBytesOrRunes(Tu) {
+	if isString(Vu) && isBytesOrRunes(Tu) {
 		return true
 	}
 
 	// package unsafe:
 	// "any pointer or value of underlying type uintptr can be converted into a unsafe.Pointer"
-	if (isPointer(Vu) || isUintptr(Vu)) && isUnsafePointer(T) {
+	if (isPointer(Vu) || isUintptr(Vu)) && isUnsafePointer(Tu) {
 		return true
 	}
 	// "and vice versa"
-	if isUnsafePointer(V) && (isPointer(Tu) || isUintptr(Tu)) {
+	if isUnsafePointer(Vu) && (isPointer(Tu) || isUintptr(Tu)) {
 		return true
 	}
 
-	// "V is a slice, T is a pointer-to-array type,
+	// "V a slice, T is a pointer-to-array type,
 	// and the slice and array types have identical element types."
-	if s, _ := under(V).(*Slice); s != nil {
-		if p, _ := under(T).(*Pointer); p != nil {
+	if s, _ := Vu.(*Slice); s != nil {
+		if p, _ := Tu.(*Pointer); p != nil {
 			if a, _ := under(p.Elem()).(*Array); a != nil {
 				if Identical(s.Elem(), a.Elem()) {
 					if check == nil || check.allowVersion(check.pkg, 1, 17) {
@@ -249,20 +249,12 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 	return false
 }
 
-// Helper predicates for convertibleToImpl. The types provided to convertibleToImpl
-// may be type parameters but they won't have specific type terms. Thus it is ok to
-// use the toT convenience converters in the predicates below.
-
 func isUintptr(typ Type) bool {
 	t, _ := under(typ).(*Basic)
 	return t != nil && t.kind == Uintptr
 }
 
 func isUnsafePointer(typ Type) bool {
-	// TODO(gri): Is this under(typ).(*Basic) instead of typ.(*Basic) correct?
-	//            (The former calls under(), while the latter doesn't.)
-	//            The spec does not say so, but gc claims it is. See also
-	//            issue 6326.
 	t, _ := under(typ).(*Basic)
 	return t != nil && t.kind == UnsafePointer
 }

From 67c15568156eb0c5607edc51a2b5d69876ba236d Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 15 Nov 2021 22:23:24 -0500
Subject: [PATCH 183/752] go/types: rename structure to structuralType

This is a clean port of CL 362994 from types2 to go/types.

Change-Id: I51b38c35ec3306274ef0355516e2d5557e7d8b46
Reviewed-on: https://go-review.googlesource.com/c/go/+/363988
Trust: Robert Findley 
Reviewed-by: Robert Griesemer 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
---
 src/go/types/builtins.go   | 22 +++++++++++-----------
 src/go/types/call.go       |  2 +-
 src/go/types/expr.go       |  2 +-
 src/go/types/index.go      |  2 +-
 src/go/types/infer.go      |  2 +-
 src/go/types/predicates.go |  4 ++--
 src/go/types/stmt.go       |  2 +-
 7 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index c2d36e9711..8d293a9af3 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -83,7 +83,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		// of S and the respective parameter passing rules apply."
 		S := x.typ
 		var T Type
-		if s, _ := structure(S).(*Slice); s != nil {
+		if s, _ := structuralType(S).(*Slice); s != nil {
 			T = s.elem
 		} else {
 			check.invalidArg(x, _InvalidAppend, "%s is not a slice", x)
@@ -332,14 +332,14 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 
 	case _Copy:
 		// copy(x, y []T) int
-		dst, _ := structure(x.typ).(*Slice)
+		dst, _ := structuralType(x.typ).(*Slice)
 
 		var y operand
 		arg(&y, 1)
 		if y.mode == invalid {
 			return
 		}
-		src, _ := structureString(y.typ).(*Slice)
+		src, _ := structuralString(y.typ).(*Slice)
 
 		if dst == nil || src == nil {
 			check.invalidArg(x, _InvalidCopy, "copy expects slice arguments; found %s and %s", x, &y)
@@ -473,7 +473,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		}
 
 		var min int // minimum number of arguments
-		switch structure(T).(type) {
+		switch structuralType(T).(type) {
 		case *Slice:
 			min = 2
 		case *Map, *Chan:
@@ -776,11 +776,11 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 	return true
 }
 
-// If typ is a type parameter, structure returns the single underlying
-// type of all types in the corresponding type constraint if it exists,
-// or nil otherwise. If typ is not a type parameter, structure returns
+// If typ is a type parameter, structuralType returns the single underlying
+// type of all types in the corresponding type constraint if it exists, or
+// nil otherwise. If typ is not a type parameter, structuralType returns
 // the underlying type.
-func structure(typ Type) Type {
+func structuralType(typ Type) Type {
 	var su Type
 	if underIs(typ, func(u Type) bool {
 		if su != nil && !Identical(su, u) {
@@ -795,10 +795,10 @@ func structure(typ Type) Type {
 	return nil
 }
 
-// structureString is like structure but also considers []byte and
-// string as "identical". In this case, if successful, the result
+// structuralString is like structuralType but also considers []byte
+// and string as "identical". In this case, if successful, the result
 // is always []byte.
-func structureString(typ Type) Type {
+func structuralString(typ Type) Type {
 	var su Type
 	if underIs(typ, func(u Type) bool {
 		if isString(u) {
diff --git a/src/go/types/call.go b/src/go/types/call.go
index 927c9f2a44..dfd7142094 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -175,7 +175,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 	cgocall := x.mode == cgofunc
 
 	// a type parameter may be "called" if all types have the same signature
-	sig, _ := structure(x.typ).(*Signature)
+	sig, _ := structuralType(x.typ).(*Signature)
 	if sig == nil {
 		check.invalidOp(x, _InvalidCall, "cannot call non-function %s", x)
 		x.mode = invalid
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 9d9eddfb95..0edaf63db0 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1228,7 +1228,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 			goto Error
 		}
 
-		switch utyp := structure(base).(type) {
+		switch utyp := structuralType(base).(type) {
 		case *Struct:
 			// Prevent crash if the struct referred to is not yet set up.
 			// See analogous comment for *Array.
diff --git a/src/go/types/index.go b/src/go/types/index.go
index cd19f50627..534b445e9e 100644
--- a/src/go/types/index.go
+++ b/src/go/types/index.go
@@ -211,7 +211,7 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
 
 	valid := false
 	length := int64(-1) // valid if >= 0
-	switch u := structure(x.typ).(type) {
+	switch u := structuralType(x.typ).(type) {
 	case nil:
 		check.errorf(x, _NonSliceableOperand, "cannot slice %s: type set has no single underlying type", x)
 		x.mode = invalid
diff --git a/src/go/types/infer.go b/src/go/types/infer.go
index f4f9bfac8f..909042219c 100644
--- a/src/go/types/infer.go
+++ b/src/go/types/infer.go
@@ -377,7 +377,7 @@ func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type,
 
 	// If a constraint has a structural type, unify the corresponding type parameter with it.
 	for _, tpar := range tparams {
-		sbound := structure(tpar)
+		sbound := structuralType(tpar)
 		if sbound != nil {
 			// If the structural type is the underlying type of a single
 			// defined type in the constraint, use that defined type instead.
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index e7f9d3b1db..2d9b9c4c07 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -33,7 +33,7 @@ func isBasic(t Type, info BasicInfo) bool {
 // The allX predicates below report whether t is an X.
 // If t is a type parameter the result is true if isX is true
 // for all specified types of the type parameter's type set.
-// allX is an optimized version of isX(structure(t)) (which
+// allX is an optimized version of isX(structuralType(t)) (which
 // is the same as underIs(t, isX)).
 
 func allBoolean(typ Type) bool         { return allBasic(typ, IsBoolean) }
@@ -47,7 +47,7 @@ func allNumericOrString(typ Type) bool { return allBasic(typ, IsNumeric|IsString
 // allBasic reports whether under(t) is a basic type with the specified info.
 // If t is a type parameter, the result is true if isBasic(t, info) is true
 // for all specific types of the type parameter's type set.
-// allBasic(t, info) is an optimized version of isBasic(structure(t), info).
+// allBasic(t, info) is an optimized version of isBasic(structuralType(t), info).
 func allBasic(t Type, info BasicInfo) bool {
 	switch u := under(t).(type) {
 	case *Basic:
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index 2a3fb5f6f5..3d4a20f808 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -834,7 +834,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 		if x.mode != invalid {
 			// Ranging over a type parameter is permitted if it has a single underlying type.
 			var cause string
-			u := structure(x.typ)
+			u := structuralType(x.typ)
 			switch t := u.(type) {
 			case nil:
 				cause = "type set has no single underlying type"

From 50dac3b410b9bc47dabc3f3c2afd21f7aecfb118 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 15 Nov 2021 22:27:19 -0500
Subject: [PATCH 184/752] go/types: move some functions into different files
 (cleanup)

This is a clean port of CL 362995 from types2 to go/types.

Change-Id: Iefc37b28178795ea944e0bc0ff91982251de2944
Reviewed-on: https://go-review.googlesource.com/c/go/+/363989
Trust: Robert Findley 
Reviewed-by: Robert Griesemer 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
---
 src/go/types/builtins.go | 40 ------------------------------------
 src/go/types/type.go     | 44 +++++++++++++++++++++++++++++++++++++---
 2 files changed, 41 insertions(+), 43 deletions(-)

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index 8d293a9af3..9b50403d7f 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -776,46 +776,6 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 	return true
 }
 
-// If typ is a type parameter, structuralType returns the single underlying
-// type of all types in the corresponding type constraint if it exists, or
-// nil otherwise. If typ is not a type parameter, structuralType returns
-// the underlying type.
-func structuralType(typ Type) Type {
-	var su Type
-	if underIs(typ, func(u Type) bool {
-		if su != nil && !Identical(su, u) {
-			return false
-		}
-		// su == nil || Identical(su, u)
-		su = u
-		return true
-	}) {
-		return su
-	}
-	return nil
-}
-
-// structuralString is like structuralType but also considers []byte
-// and string as "identical". In this case, if successful, the result
-// is always []byte.
-func structuralString(typ Type) Type {
-	var su Type
-	if underIs(typ, func(u Type) bool {
-		if isString(u) {
-			u = NewSlice(universeByte)
-		}
-		if su != nil && !Identical(su, u) {
-			return false
-		}
-		// su == nil || Identical(su, u)
-		su = u
-		return true
-	}) {
-		return su
-	}
-	return nil
-}
-
 // hasVarSize reports if the size of type t is variable due to type parameters.
 func hasVarSize(t Type) bool {
 	switch t := under(t).(type) {
diff --git a/src/go/types/type.go b/src/go/types/type.go
index b1e2bda4cd..26a605444d 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -27,10 +27,47 @@ func under(t Type) Type {
 	return t
 }
 
-// If the argument to asNamed, or asTypeParam is of the respective type
-// (possibly after resolving a *Named type), these methods return that type.
-// Otherwise the result is nil.
+// If typ is a type parameter, structuralType returns the single underlying
+// type of all types in the corresponding type constraint if it exists,
+// or nil otherwise. If typ is not a type parameter, structuralType returns
+// the underlying type.
+func structuralType(typ Type) Type {
+	var su Type
+	if underIs(typ, func(u Type) bool {
+		if su != nil && !Identical(su, u) {
+			return false
+		}
+		// su == nil || Identical(su, u)
+		su = u
+		return true
+	}) {
+		return su
+	}
+	return nil
+}
 
+// structuralString is like structuralType but also considers []byte
+// and string as "identical". In this case, if successful, the result
+// is always []byte.
+func structuralString(typ Type) Type {
+	var su Type
+	if underIs(typ, func(u Type) bool {
+		if isString(u) {
+			u = NewSlice(universeByte)
+		}
+		if su != nil && !Identical(su, u) {
+			return false
+		}
+		// su == nil || Identical(su, u)
+		su = u
+		return true
+	}) {
+		return su
+	}
+	return nil
+}
+
+// If t is a defined type, asNamed returns that type (possibly after resolving it), otherwise it returns nil.
 func asNamed(t Type) *Named {
 	e, _ := t.(*Named)
 	if e != nil {
@@ -39,6 +76,7 @@ func asNamed(t Type) *Named {
 	return e
 }
 
+// If t is a type parameter, asTypeParam returns that type, otherwise it returns nil.
 func asTypeParam(t Type) *TypeParam {
 	u, _ := under(t).(*TypeParam)
 	return u

From 46e98d489fda3bc1e36af92ee625b2fce3c1f88e Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 15 Nov 2021 22:33:22 -0500
Subject: [PATCH 185/752] go/types: refer to structural rather than single
 underlying type in errors

This is a port of CL 362997 from types2 to go/types. Some error
positions were adjusted in tests.

Change-Id: I6a932aee1a8d9bcbf4cd8c16a95bbb41b5c7e13f
Reviewed-on: https://go-review.googlesource.com/c/go/+/363990
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/builtins.go                   |  2 +-
 src/go/types/index.go                      |  2 +-
 src/go/types/stmt.go                       |  4 ++--
 src/go/types/testdata/check/builtins.go2   |  6 +++---
 src/go/types/testdata/check/typeparams.go2 | 12 ++++++------
 5 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index 9b50403d7f..b767128367 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -479,7 +479,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		case *Map, *Chan:
 			min = 1
 		case nil:
-			check.errorf(arg0, _InvalidMake, "cannot make %s; type set has no single underlying type", arg0)
+			check.errorf(arg0, _InvalidMake, "cannot make %s: no structural type", arg0)
 			return
 		default:
 			check.invalidArg(arg0, _InvalidMake, "cannot make %s; type must be slice, map, or channel", arg0)
diff --git a/src/go/types/index.go b/src/go/types/index.go
index 534b445e9e..0284716277 100644
--- a/src/go/types/index.go
+++ b/src/go/types/index.go
@@ -213,7 +213,7 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
 	length := int64(-1) // valid if >= 0
 	switch u := structuralType(x.typ).(type) {
 	case nil:
-		check.errorf(x, _NonSliceableOperand, "cannot slice %s: type set has no single underlying type", x)
+		check.invalidOp(x, _NonSliceableOperand, "cannot slice %s: %s has no structural type", x, x.typ)
 		x.mode = invalid
 		return
 
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index 3d4a20f808..e7514f19ae 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -832,12 +832,12 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 		// determine key/value types
 		var key, val Type
 		if x.mode != invalid {
-			// Ranging over a type parameter is permitted if it has a single underlying type.
+			// Ranging over a type parameter is permitted if it has a structural type.
 			var cause string
 			u := structuralType(x.typ)
 			switch t := u.(type) {
 			case nil:
-				cause = "type set has no single underlying type"
+				cause = check.sprintf("%s has no structural type", x.typ)
 			case *Chan:
 				if s.Value != nil {
 					check.softErrorf(s.Value, _InvalidIterVar, "range over %s permits only one iteration variable", &x)
diff --git a/src/go/types/testdata/check/builtins.go2 b/src/go/types/testdata/check/builtins.go2
index 7cca6fd714..c1accff016 100644
--- a/src/go/types/testdata/check/builtins.go2
+++ b/src/go/types/testdata/check/builtins.go2
@@ -148,7 +148,7 @@ func _[
 	_ = make /* ERROR expects 2 or 3 arguments */ (S1)
 	_ = make(S1, 10, 20)
 	_ = make /* ERROR expects 2 or 3 arguments */ (S1, 10, 20, 30)
-	_ = make(S2 /* ERROR cannot make .* no single underlying type */ , 10)
+	_ = make(S2 /* ERROR cannot make S2: no structural type */ , 10)
 
 	type M0 map[string]int
 	_ = make(map[string]int)
@@ -156,7 +156,7 @@ func _[
 	_ = make(M1)
 	_ = make(M1, 10)
 	_ = make/* ERROR expects 1 or 2 arguments */(M1, 10, 20)
-	_ = make(M2 /* ERROR cannot make .* no single underlying type */ )
+	_ = make(M2 /* ERROR cannot make M2: no structural type */ )
 
 	type C0 chan int
 	_ = make(chan int)
@@ -164,7 +164,7 @@ func _[
 	_ = make(C1)
 	_ = make(C1, 10)
 	_ = make/* ERROR expects 1 or 2 arguments */(C1, 10, 20)
-	_ = make(C2 /* ERROR cannot make .* no single underlying type */ )
+	_ = make(C2 /* ERROR cannot make C2: no structural type */ )
 	_ = make(C3)
 }
 
diff --git a/src/go/types/testdata/check/typeparams.go2 b/src/go/types/testdata/check/typeparams.go2
index 09d478c4d7..6bf303af90 100644
--- a/src/go/types/testdata/check/typeparams.go2
+++ b/src/go/types/testdata/check/typeparams.go2
@@ -134,7 +134,7 @@ func _[T interface{ ~string }] (x T, i, j, k int) { var _ T = x /* ERROR 3-index
 type myByte1 []byte
 type myByte2 []byte
 func _[T interface{ []byte | myByte1 | myByte2 }] (x T, i, j, k int) { var _ T = x[i:j:k] }
-func _[T interface{ []byte | myByte1 | []int }] (x T, i, j, k int) { var _ T = x /* ERROR no single underlying type */ [i:j:k] }
+func _[T interface{ []byte | myByte1 | []int }] (x T, i, j, k int) { var _ T = x /* ERROR no structural type */ [i:j:k] }
 
 // len/cap built-ins
 
@@ -210,7 +210,7 @@ func _[
         for _, _ /* ERROR permits only one iteration variable */ = range c1 {}
 
         var c2 C2
-        for range c2 /* ERROR cannot range over c2.*no single underlying type */ {}
+        for range c2 /* ERROR cannot range over c2.*no structural type */ {}
 
         var c3 C3
         for range c3 /* ERROR receive from send-only channel */ {}
@@ -226,7 +226,7 @@ func _[
         for _, _ = range s1 {}
 
         var s2 S2
-        for range s2 /* ERROR cannot range over s2.*no single underlying type */ {}
+        for range s2 /* ERROR cannot range over s2.*no structural type */ {}
 
         var a0 []int
         for range a0 {}
@@ -239,7 +239,7 @@ func _[
         for _, _ = range a1 {}
 
         var a2 A2
-        for range a2 /* ERROR cannot range over a2.*no single underlying type */ {}
+        for range a2 /* ERROR cannot range over a2.*no structural type */ {}
 
         var p0 *[10]int
         for range p0 {}
@@ -252,7 +252,7 @@ func _[
         for _, _ = range p1 {}
 
         var p2 P2
-        for range p2 /* ERROR cannot range over p2.*no single underlying type */ {}
+        for range p2 /* ERROR cannot range over p2.*no structural type */ {}
 
         var m0 map[string]int
         for range m0 {}
@@ -265,7 +265,7 @@ func _[
         for _, _ = range m1 {}
 
         var m2 M2
-        for range m2 /* ERROR cannot range over m2.*no single underlying type */ {}
+        for range m2 /* ERROR cannot range over m2.*no structural type */ {}
 }
 
 // type inference checks

From 289c930750fccac6aca578c675694b612532fd24 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 15 Nov 2021 22:42:41 -0500
Subject: [PATCH 186/752] go/types: slightly relax notion of structural type

This is a port of CL 363075 from types2 to go/types, adjusted for the
different error reporting API, and to adjust positions of error messages
in tests.

Change-Id: Ic6bfedf1152eff94bad20725b56e6ba804b2e3e8
Reviewed-on: https://go-review.googlesource.com/c/go/+/363991
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/expr.go                          | 35 ++++++------
 src/go/types/stmt.go                          | 32 +++++------
 src/go/types/testdata/check/typeparams.go2    |  2 +-
 .../types/testdata/fixedbugs/issue43671.go2   |  6 +-
 .../types/testdata/fixedbugs/issue45920.go2   | 17 ++++++
 .../types/testdata/fixedbugs/issue47115.go2   |  4 +-
 src/go/types/type.go                          | 55 ++++++++++++++++---
 7 files changed, 98 insertions(+), 53 deletions(-)
 create mode 100644 src/go/types/testdata/fixedbugs/issue45920.go2

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 0edaf63db0..6eeb431b73 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -174,29 +174,26 @@ func (check *Checker) unary(x *operand, e *ast.UnaryExpr) {
 		return
 
 	case token.ARROW:
-		var elem Type
-		if !underIs(x.typ, func(u Type) bool {
-			ch, _ := u.(*Chan)
-			if ch == nil {
-				check.invalidOp(x, _InvalidReceive, "cannot receive from non-channel %s", x)
-				return false
-			}
-			if ch.dir == SendOnly {
-				check.invalidOp(x, _InvalidReceive, "cannot receive from send-only channel %s", x)
-				return false
-			}
-			if elem != nil && !Identical(ch.elem, elem) {
-				check.invalidOp(x, _InvalidReceive, "channels of %s must have the same element type", x)
-				return false
-			}
-			elem = ch.elem
-			return true
-		}) {
+		u := structuralType(x.typ)
+		if u == nil {
+			check.invalidOp(x, _InvalidReceive, "cannot receive from %s: no structural type", x)
 			x.mode = invalid
 			return
 		}
+		ch, _ := u.(*Chan)
+		if ch == nil {
+			check.invalidOp(x, _InvalidReceive, "cannot receive from non-channel %s", x)
+			x.mode = invalid
+			return
+		}
+		if ch.dir == SendOnly {
+			check.invalidOp(x, _InvalidReceive, "cannot receive from send-only channel %s", x)
+			x.mode = invalid
+			return
+		}
+
 		x.mode = commaok
-		x.typ = elem
+		x.typ = ch.elem
 		check.hasCallOrRecv = true
 		return
 	}
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index e7514f19ae..363ea35acf 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -417,27 +417,21 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 		if ch.mode == invalid || val.mode == invalid {
 			return
 		}
-		var elem Type
-		if !underIs(ch.typ, func(u Type) bool {
-			uch, _ := u.(*Chan)
-			if uch == nil {
-				check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to non-channel %s", &ch)
-				return false
-			}
-			if uch.dir == RecvOnly {
-				check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to receive-only channel %s", &ch)
-				return false
-			}
-			if elem != nil && !Identical(uch.elem, elem) {
-				check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "channels of %s must have the same element type", &ch)
-				return false
-			}
-			elem = uch.elem
-			return true
-		}) {
+		u := structuralType(ch.typ)
+		if u == nil {
+			check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to %s: no structural type", &ch)
 			return
 		}
-		check.assignment(&val, elem, "send")
+		uch, _ := u.(*Chan)
+		if uch == nil {
+			check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to non-channel %s", &ch)
+			return
+		}
+		if uch.dir == RecvOnly {
+			check.invalidOp(inNode(s, s.Arrow), _InvalidSend, "cannot send to receive-only channel %s", &ch)
+			return
+		}
+		check.assignment(&val, uch.elem, "send")
 
 	case *ast.IncDecStmt:
 		var op token.Token
diff --git a/src/go/types/testdata/check/typeparams.go2 b/src/go/types/testdata/check/typeparams.go2
index 6bf303af90..9e2bffb539 100644
--- a/src/go/types/testdata/check/typeparams.go2
+++ b/src/go/types/testdata/check/typeparams.go2
@@ -210,7 +210,7 @@ func _[
         for _, _ /* ERROR permits only one iteration variable */ = range c1 {}
 
         var c2 C2
-        for range c2 /* ERROR cannot range over c2.*no structural type */ {}
+        for range c2 {}
 
         var c3 C3
         for range c3 /* ERROR receive from send-only channel */ {}
diff --git a/src/go/types/testdata/fixedbugs/issue43671.go2 b/src/go/types/testdata/fixedbugs/issue43671.go2
index 6cc3801cc9..46ac51ebdd 100644
--- a/src/go/types/testdata/fixedbugs/issue43671.go2
+++ b/src/go/types/testdata/fixedbugs/issue43671.go2
@@ -12,11 +12,11 @@ type C4 interface{ chan int | chan<- int }
 type C5[T any] interface{ ~chan T | <-chan T }
 
 func _[T any](ch T) {
-	<-ch // ERROR cannot receive from non-channel
+	<-ch // ERROR cannot receive from ch .* no structural type
 }
 
 func _[T C0](ch T) {
-	<-ch // ERROR cannot receive from non-channel
+	<-ch // ERROR cannot receive from non-channel ch
 }
 
 func _[T C1](ch T) {
@@ -28,7 +28,7 @@ func _[T C2](ch T) {
 }
 
 func _[T C3](ch T) {
-	<-ch // ERROR channels of ch .* must have the same element type
+	<-ch // ERROR cannot receive from ch .* no structural type
 }
 
 func _[T C4](ch T) {
diff --git a/src/go/types/testdata/fixedbugs/issue45920.go2 b/src/go/types/testdata/fixedbugs/issue45920.go2
new file mode 100644
index 0000000000..f659f3a0db
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue45920.go2
@@ -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 p
+
+func f1[T any, C chan T | <-chan T](ch C) {}
+
+func _(ch chan int)   { f1(ch) }
+func _(ch <-chan int) { f1(ch) }
+func _(ch chan<- int) { f1 /* ERROR chan<- int does not satisfy chan T\|<-chan T */ (ch) }
+
+func f2[T any, C chan T | chan<- T](ch C) {}
+
+func _(ch chan int)   { f2(ch) }
+func _(ch <-chan int) { f2 /* ERROR <-chan int does not satisfy chan T\|chan<- T */ (ch)}
+func _(ch chan<- int) { f2(ch) }
diff --git a/src/go/types/testdata/fixedbugs/issue47115.go2 b/src/go/types/testdata/fixedbugs/issue47115.go2
index 6694219b54..f71e06c9b2 100644
--- a/src/go/types/testdata/fixedbugs/issue47115.go2
+++ b/src/go/types/testdata/fixedbugs/issue47115.go2
@@ -12,7 +12,7 @@ type C4 interface{ chan int | chan<- int }
 type C5[T any] interface{ ~chan T | chan<- T }
 
 func _[T any](ch T) {
-	ch <- /* ERROR cannot send to non-channel */ 0
+	ch <- /* ERROR cannot send to ch .* no structural type */ 0
 }
 
 func _[T C0](ch T) {
@@ -28,7 +28,7 @@ func _[T C2](ch T) {
 }
 
 func _[T C3](ch T) {
-	ch <- /* ERROR channels of ch .* must have the same element type */ 0
+	ch <- /* ERROR cannot send to ch .* no structural type */ 0
 }
 
 func _[T C4](ch T) {
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 26a605444d..8f23fb530d 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -27,17 +27,51 @@ func under(t Type) Type {
 	return t
 }
 
+// If x and y are identical, match returns x.
+// If x and y are identical channels but for their direction
+// and one of them is unrestricted, match returns the channel
+// with the restricted direction.
+// In all other cases, match returns nil.
+func match(x, y Type) Type {
+	// Common case: we don't have channels.
+	if Identical(x, y) {
+		return x
+	}
+
+	// We may have channels that differ in direction only.
+	if x, _ := x.(*Chan); x != nil {
+		if y, _ := y.(*Chan); y != nil && Identical(x.elem, y.elem) {
+			// We have channels that differ in direction only.
+			// If there's an unrestricted channel, select the restricted one.
+			switch {
+			case x.dir == SendRecv:
+				return y
+			case y.dir == SendRecv:
+				return x
+			}
+		}
+	}
+
+	// types are different
+	return nil
+}
+
 // If typ is a type parameter, structuralType returns the single underlying
-// type of all types in the corresponding type constraint if it exists,
-// or nil otherwise. If typ is not a type parameter, structuralType returns
-// the underlying type.
+// type of all types in the corresponding type constraint if it exists, or
+// nil otherwise. If the type set contains only unrestricted and restricted
+// channel types (with identical element types), the single underlying type
+// is the restricted channel type if the restrictions are always the same.
+// If typ is not a type parameter, structuralType returns the underlying type.
 func structuralType(typ Type) Type {
 	var su Type
 	if underIs(typ, func(u Type) bool {
-		if su != nil && !Identical(su, u) {
-			return false
+		if su != nil {
+			u = match(su, u)
+			if u == nil {
+				return false
+			}
 		}
-		// su == nil || Identical(su, u)
+		// su == nil || match(su, u) != nil
 		su = u
 		return true
 	}) {
@@ -55,10 +89,13 @@ func structuralString(typ Type) Type {
 		if isString(u) {
 			u = NewSlice(universeByte)
 		}
-		if su != nil && !Identical(su, u) {
-			return false
+		if su != nil {
+			u = match(su, u)
+			if u == nil {
+				return false
+			}
 		}
-		// su == nil || Identical(su, u)
+		// su == nil || match(su, u) != nil
 		su = u
 		return true
 	}) {

From f041c7e3028545ba39c60d6e20ab9b74c01bbf33 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 15 Nov 2021 23:29:25 -0500
Subject: [PATCH 187/752] go/types: remove structuralString in favor of inlined
 code

This is a clean port of CL 363154 from types2 to go/types.

Change-Id: I26c18767041db096390e84ba9200ec69b66778d0
Reviewed-on: https://go-review.googlesource.com/c/go/+/364234
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/builtins.go | 21 ++++++++++++++++++++-
 src/go/types/type.go     | 24 ------------------------
 2 files changed, 20 insertions(+), 25 deletions(-)

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index b767128367..c1932232aa 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -339,7 +339,26 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		if y.mode == invalid {
 			return
 		}
-		src, _ := structuralString(y.typ).(*Slice)
+		// src, _ := structuralType(y.typ).(*Slice); but also accepts strings
+		var src *Slice
+		var elem Type // == src.elem if valid
+		if underIs(y.typ, func(u Type) bool {
+			switch u := u.(type) {
+			case *Basic:
+				if isString(u) && (elem == nil || Identical(elem, universeByte)) {
+					elem = universeByte
+					return true
+				}
+			case *Slice:
+				if elem == nil || Identical(elem, u.elem) {
+					elem = u.elem
+					return true
+				}
+			}
+			return false
+		}) {
+			src = NewSlice(elem)
+		}
 
 		if dst == nil || src == nil {
 			check.invalidArg(x, _InvalidCopy, "copy expects slice arguments; found %s and %s", x, &y)
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 8f23fb530d..e26d8189d1 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -80,30 +80,6 @@ func structuralType(typ Type) Type {
 	return nil
 }
 
-// structuralString is like structuralType but also considers []byte
-// and string as "identical". In this case, if successful, the result
-// is always []byte.
-func structuralString(typ Type) Type {
-	var su Type
-	if underIs(typ, func(u Type) bool {
-		if isString(u) {
-			u = NewSlice(universeByte)
-		}
-		if su != nil {
-			u = match(su, u)
-			if u == nil {
-				return false
-			}
-		}
-		// su == nil || match(su, u) != nil
-		su = u
-		return true
-	}) {
-		return su
-	}
-	return nil
-}
-
 // If t is a defined type, asNamed returns that type (possibly after resolving it), otherwise it returns nil.
 func asNamed(t Type) *Named {
 	e, _ := t.(*Named)

From 7c50ef6c8c4c827db45a3327cb950913cf9d489b Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 15 Nov 2021 23:39:22 -0500
Subject: [PATCH 188/752] go/types: remove asTypeParam and simplify some code

This is a port of CL 363438 from types2 to go/types.

Change-Id: I87c76d31b398b9ce406f96b0030ee458619b3dbe
Reviewed-on: https://go-review.googlesource.com/c/go/+/364235
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/builtins.go    |  6 +++---
 src/go/types/call.go        |  2 +-
 src/go/types/conversions.go |  6 +++---
 src/go/types/decl.go        | 11 ++++++-----
 src/go/types/expr.go        |  5 ++---
 src/go/types/instantiate.go |  8 ++++----
 src/go/types/lookup.go      |  8 +-------
 src/go/types/operand.go     |  6 +++---
 src/go/types/predicates.go  |  2 +-
 src/go/types/type.go        |  6 ------
 src/go/types/typeset.go     |  8 --------
 src/go/types/typexpr.go     |  2 +-
 src/go/types/union.go       | 17 ++++++++---------
 13 files changed, 33 insertions(+), 54 deletions(-)

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index c1932232aa..5418d66aeb 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -298,7 +298,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		// the argument types must be of floating-point type
 		// (applyTypeFunc never calls f with a type parameter)
 		f := func(typ Type) Type {
-			assert(asTypeParam(typ) == nil)
+			assert(!isTypeParam(typ))
 			if t, _ := under(typ).(*Basic); t != nil {
 				switch t.kind {
 				case Float32:
@@ -441,7 +441,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		// the argument must be of complex type
 		// (applyTypeFunc never calls f with a type parameter)
 		f := func(typ Type) Type {
-			assert(asTypeParam(typ) == nil)
+			assert(!isTypeParam(typ))
 			if t, _ := under(typ).(*Basic); t != nil {
 				switch t.kind {
 				case Complex64:
@@ -822,7 +822,7 @@ func hasVarSize(t Type) bool {
 // applyTypeFunc returns nil.
 // If x is not a type parameter, the result is f(x).
 func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type {
-	if tp := asTypeParam(x); tp != nil {
+	if tp, _ := x.(*TypeParam); tp != nil {
 		// Test if t satisfies the requirements for the argument
 		// type and collect possible result types at the same time.
 		var terms []*Term
diff --git a/src/go/types/call.go b/src/go/types/call.go
index dfd7142094..7cb6027f3b 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -531,7 +531,7 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
 			check.errorf(e.Sel, _InvalidMethodExpr, "cannot call pointer method %s on %s", sel, x.typ)
 		default:
 			var why string
-			if tpar := asTypeParam(x.typ); tpar != nil {
+			if tpar, _ := x.typ.(*TypeParam); tpar != nil {
 				// Type parameter bounds don't specify fields, so don't mention "field".
 				if tname := tpar.iface().obj; tname != nil {
 					why = check.sprintf("interface %s has no method %s", tname.name, sel)
diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index 18d24e404c..eadc923f5e 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -47,7 +47,7 @@ func (check *Checker) conversion(x *operand, T Type) {
 		// If T's type set is empty, or if it doesn't
 		// have specific types, constant x cannot be
 		// converted.
-		ok = under(T).(*TypeParam).underIs(func(u Type) bool {
+		ok = T.(*TypeParam).underIs(func(u Type) bool {
 			// t is nil if there are no specific type terms
 			if u == nil {
 				cause = check.sprintf("%s does not contain specific types", T)
@@ -186,8 +186,8 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 	}
 
 	// optimization: if we don't have type parameters, we're done
-	Vp, _ := Vu.(*TypeParam)
-	Tp, _ := Tu.(*TypeParam)
+	Vp, _ := V.(*TypeParam)
+	Tp, _ := T.(*TypeParam)
 	if Vp == nil && Tp == nil {
 		return false
 	}
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index e12961416e..2108cf6b05 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -669,10 +669,11 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) {
 	}
 
 	// Disallow a lone type parameter as the RHS of a type declaration (issue #45639).
-	// We can look directly at named.underlying because even if it is still a *Named
-	// type (underlying not fully resolved yet) it cannot become a type parameter due
-	// to this very restriction.
-	if tpar, _ := named.underlying.(*TypeParam); tpar != nil {
+	// We don't need this restriction anymore if we make the underlying type of a type
+	// parameter its constraint interface: if the RHS is a lone type parameter, we will
+	// use its underlying type (like we do for any RHS in a type declaration), and its
+	// underlying type is an interface and the type declaration is well defined.
+	if isTypeParam(rhs) {
 		check.error(tdecl.Type, _MisplacedTypeParam, "cannot use a type parameter as RHS in type declaration")
 		named.underlying = Typ[Invalid]
 	}
@@ -723,7 +724,7 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list *ast.FieldList
 
 	check.later(func() {
 		for i, bound := range bounds {
-			if _, ok := under(bound).(*TypeParam); ok {
+			if isTypeParam(bound) {
 				check.error(posns[i], _MisplacedTypeParam, "cannot use a type parameter as constraint")
 			}
 		}
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 6eeb431b73..660c92de3b 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -147,11 +147,10 @@ var op2str2 = [...]string{
 // If typ is a type parameter, underIs returns the result of typ.underIs(f).
 // Otherwise, underIs returns the result of f(under(typ)).
 func underIs(typ Type, f func(Type) bool) bool {
-	u := under(typ)
-	if tpar, _ := u.(*TypeParam); tpar != nil {
+	if tpar, _ := typ.(*TypeParam); tpar != nil {
 		return tpar.underIs(f)
 	}
-	return f(u)
+	return f(under(typ))
 }
 
 // The unary expression e may be nil. It's passed in for better error messages only.
diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index 13d6e3114d..c9ce6f6ae1 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -157,7 +157,7 @@ func (check *Checker) satisfies(pos token.Pos, targ Type, tpar *TypeParam, smap
 
 	// A type argument that is a type parameter with an empty type set satisfies any constraint.
 	// (The empty set is a subset of any set.)
-	if targ := asTypeParam(targ); targ != nil && targ.iface().typeSet().IsEmpty() {
+	if targ, _ := targ.(*TypeParam); targ != nil && targ.iface().typeSet().IsEmpty() {
 		return nil
 	}
 
@@ -186,7 +186,7 @@ func (check *Checker) satisfies(pos token.Pos, targ Type, tpar *TypeParam, smap
 	// if iface is comparable, targ must be comparable
 	// TODO(gri) the error messages needs to be better, here
 	if iface.IsComparable() && !Comparable(targ) {
-		if tpar := asTypeParam(targ); tpar != nil && tpar.iface().typeSet().IsAll() {
+		if tpar, _ := targ.(*TypeParam); tpar != nil && tpar.iface().typeSet().IsAll() {
 			return errorf("%s has no constraints", targ)
 		}
 		return errorf("%s does not satisfy comparable", targ)
@@ -198,7 +198,7 @@ func (check *Checker) satisfies(pos token.Pos, targ Type, tpar *TypeParam, smap
 		// If the type argument is a pointer to a type parameter, the type argument's
 		// method set is empty.
 		// TODO(gri) is this what we want? (spec question)
-		if base, isPtr := deref(targ); isPtr && asTypeParam(base) != nil {
+		if base, isPtr := deref(targ); isPtr && isTypeParam(base) {
 			return errorf("%s has no methods", targ)
 		}
 		if m, wrong := check.missingMethod(targ, iface, true); m != nil {
@@ -227,7 +227,7 @@ func (check *Checker) satisfies(pos token.Pos, targ Type, tpar *TypeParam, smap
 	// If targ is itself a type parameter, each of its possible types must be in the set
 	// of iface types (i.e., the targ type set must be a subset of the iface type set).
 	// Type arguments with empty type sets were already excluded above.
-	if targ := asTypeParam(targ); targ != nil {
+	if targ, _ := targ.(*TypeParam); targ != nil {
 		targBound := targ.iface()
 		if !targBound.typeSet().subsetOf(iface.typeSet()) {
 			// TODO(gri) report which type is missing
diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index aae6fa206d..98af6bfcd7 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -134,14 +134,8 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 					continue // we can't have a matching field or interface method
 				}
 
-				// continue with underlying type, but only if it's not a type parameter
-				// TODO(gri) is this what we want to do for type parameters? (spec question)
-				// TODO(#45639) the error message produced as a result of skipping an
-				//              underlying type parameter should be improved.
+				// continue with underlying type
 				typ = named.under()
-				if asTypeParam(typ) != nil {
-					continue
-				}
 			}
 
 			tpar = nil
diff --git a/src/go/types/operand.go b/src/go/types/operand.go
index 8b76e939b6..6f902e9749 100644
--- a/src/go/types/operand.go
+++ b/src/go/types/operand.go
@@ -166,7 +166,7 @@ func operandString(x *operand, qf Qualifier) string {
 			}
 			buf.WriteString(intro)
 			WriteType(&buf, x.typ, qf)
-			if tpar := asTypeParam(x.typ); tpar != nil {
+			if tpar, _ := x.typ.(*TypeParam); tpar != nil {
 				buf.WriteString(" constrained by ")
 				WriteType(&buf, tpar.bound, qf) // do not compute interface type sets here
 			}
@@ -241,8 +241,8 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 
 	Vu := under(V)
 	Tu := under(T)
-	Vp, _ := Vu.(*TypeParam)
-	Tp, _ := Tu.(*TypeParam)
+	Vp, _ := V.(*TypeParam)
+	Tp, _ := T.(*TypeParam)
 
 	// x is an untyped value representable by a value of type T.
 	if isUntyped(Vu) {
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index 2d9b9c4c07..d0697b1ad7 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -92,7 +92,7 @@ func IsInterface(t Type) bool {
 
 // isTypeParam reports whether t is a type parameter.
 func isTypeParam(t Type) bool {
-	_, ok := under(t).(*TypeParam)
+	_, ok := t.(*TypeParam)
 	return ok
 }
 
diff --git a/src/go/types/type.go b/src/go/types/type.go
index e26d8189d1..555eb9e8b9 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -88,9 +88,3 @@ func asNamed(t Type) *Named {
 	}
 	return e
 }
-
-// If t is a type parameter, asTypeParam returns that type, otherwise it returns nil.
-func asTypeParam(t Type) *TypeParam {
-	u, _ := under(t).(*TypeParam)
-	return u
-}
diff --git a/src/go/types/typeset.go b/src/go/types/typeset.go
index 1e6b9dd390..d0464aeaa0 100644
--- a/src/go/types/typeset.go
+++ b/src/go/types/typeset.go
@@ -289,10 +289,6 @@ func computeInterfaceTypeSet(check *Checker, pos token.Pos, ityp *Interface) *_T
 				continue // ignore invalid unions
 			}
 			terms = tset.terms
-		case *TypeParam:
-			// Embedding stand-alone type parameters is not permitted.
-			// Union parsing reports a (delayed) error, so we can ignore this entry.
-			continue
 		default:
 			if u == Typ[Invalid] {
 				continue
@@ -370,10 +366,6 @@ func computeUnionTypeSet(check *Checker, pos token.Pos, utyp *Union) *_TypeSet {
 		switch u := under(t.typ).(type) {
 		case *Interface:
 			terms = computeInterfaceTypeSet(check, pos, u).terms
-		case *TypeParam:
-			// A stand-alone type parameters is not permitted as union term.
-			// Union parsing reports a (delayed) error, so we can ignore this entry.
-			continue
 		default:
 			if t.typ == Typ[Invalid] {
 				continue
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 5828c2e7c3..89264ee9eb 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -337,7 +337,7 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 		check.later(func() {
 			if !Comparable(typ.key) {
 				var why string
-				if asTypeParam(typ.key) != nil {
+				if isTypeParam(typ.key) {
 					why = " (missing comparable constraint)"
 				}
 				check.errorf(e.Key, _IncomparableMapKey, "incomparable map key type %s%s", typ.key, why)
diff --git a/src/go/types/union.go b/src/go/types/union.go
index bb08174728..2a65ca4d8e 100644
--- a/src/go/types/union.go
+++ b/src/go/types/union.go
@@ -118,15 +118,14 @@ func parseTilde(check *Checker, x ast.Expr) (tilde bool, typ Type) {
 	}
 	typ = check.typ(x)
 	// Embedding stand-alone type parameters is not permitted (issue #47127).
-	// Do this check later because it requires computation of the underlying type (see also issue #46461).
-	// Note: If an underlying type cannot be a type parameter, the call to
-	//       under() will not be needed and then we don't need to delay this
-	//       check to later and could return Typ[Invalid] instead.
-	check.later(func() {
-		if _, ok := under(typ).(*TypeParam); ok {
-			check.error(x, _MisplacedTypeParam, "cannot embed a type parameter")
-		}
-	})
+	// We don't need this restriction anymore if we make the underlying type of a type
+	// parameter its constraint interface: if we embed a lone type parameter, we will
+	// simply use its underlying type (like we do for other named, embedded interfaces),
+	// and since the underlying type is an interface the embedding is well defined.
+	if isTypeParam(typ) {
+		check.error(x, _MisplacedTypeParam, "cannot embed a type parameter")
+		typ = Typ[Invalid]
+	}
 	return
 }
 

From 7f4a946fa26f2ffdc14c354f2f1cc193ab5d0e90 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le 
Date: Tue, 16 Nov 2021 21:59:15 +0700
Subject: [PATCH 189/752] cmd/compile: prevent irgen crashing for empty local
 declaration stmt

Updates #47631
Fixes #49611

Change-Id: Ib4a4466038e0d4a9aa9380d7909f29f7d15c6c69
Reviewed-on: https://go-review.googlesource.com/c/go/+/364314
Trust: Cuong Manh Le 
Run-TryBot: Cuong Manh Le 
TryBot-Result: Go Bot 
Reviewed-by: Keith Randall 
---
 src/cmd/compile/internal/noder/stmt.go |  8 +++++---
 test/fixedbugs/issue49611.go           | 11 +++++++++++
 test/typeparam/issue49611.go           | 11 +++++++++++
 3 files changed, 27 insertions(+), 3 deletions(-)
 create mode 100644 test/fixedbugs/issue49611.go
 create mode 100644 test/typeparam/issue49611.go

diff --git a/src/cmd/compile/internal/noder/stmt.go b/src/cmd/compile/internal/noder/stmt.go
index e329a59156..1e996b95c4 100644
--- a/src/cmd/compile/internal/noder/stmt.go
+++ b/src/cmd/compile/internal/noder/stmt.go
@@ -46,9 +46,11 @@ func (g *irgen) stmt(stmt syntax.Stmt) ir.Node {
 		n.SetTypecheck(1)
 		return n
 	case *syntax.DeclStmt:
-		if _, ok := stmt.DeclList[0].(*syntax.TypeDecl); ok && g.topFuncIsGeneric {
-			// TODO: remove this restriction. See issue 47631.
-			base.ErrorfAt(g.pos(stmt), "type declarations inside generic functions are not currently supported")
+		if g.topFuncIsGeneric && len(stmt.DeclList) > 0 {
+			if _, ok := stmt.DeclList[0].(*syntax.TypeDecl); ok {
+				// TODO: remove this restriction. See issue 47631.
+				base.ErrorfAt(g.pos(stmt), "type declarations inside generic functions are not currently supported")
+			}
 		}
 		n := ir.NewBlockStmt(g.pos(stmt), nil)
 		g.decls(&n.List, stmt.DeclList)
diff --git a/test/fixedbugs/issue49611.go b/test/fixedbugs/issue49611.go
new file mode 100644
index 0000000000..b40ad58649
--- /dev/null
+++ b/test/fixedbugs/issue49611.go
@@ -0,0 +1,11 @@
+// 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 ()
+}
diff --git a/test/typeparam/issue49611.go b/test/typeparam/issue49611.go
new file mode 100644
index 0000000000..96c651e2b5
--- /dev/null
+++ b/test/typeparam/issue49611.go
@@ -0,0 +1,11 @@
+// compile -G=3
+
+// 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[T any]() {
+	var ()
+}

From 79d0013f53d4199b9f84d813221b71adf7eb1e4d Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 15 Nov 2021 09:42:03 -0500
Subject: [PATCH 190/752] go/types, types2: improve error messages referencing
 any

Because any is an a alias, it is naively formatted as interface{} in
error messages. This is a source of verbosity and potential confusion.

We can improve the situation by looking for pointer equality with the
any type. To avoid churn in the importers, do this all at once across
the compiler, go/types, and go/internal/gcimporter. CL 364194 makes the
corresponding change in x/tools/go/internal/gcimporter, allowing the
x/tools trybots to pass.

Fixes #49583

Change-Id: Ib59570937601308483f6273364cc59338f9b8b3b
Reviewed-on: https://go-review.googlesource.com/c/go/+/363974
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
Reviewed-by: Matthew Dempsky 
---
 src/cmd/compile/internal/importer/support.go             | 4 ++++
 src/cmd/compile/internal/noder/types.go                  | 8 ++++++++
 src/cmd/compile/internal/types2/api_test.go              | 6 +++---
 src/cmd/compile/internal/types2/object.go                | 8 ++++++++
 src/cmd/compile/internal/types2/object_test.go           | 9 +++++----
 .../internal/types2/testdata/fixedbugs/issue48008.go2    | 2 +-
 src/cmd/compile/internal/types2/typestring.go            | 7 +++++++
 src/cmd/compile/internal/types2/universe.go              | 5 ++++-
 src/go/internal/gcimporter/support.go                    | 4 ++++
 src/go/types/api_test.go                                 | 6 +++---
 src/go/types/object.go                                   | 8 ++++++++
 src/go/types/object_test.go                              | 9 +++++----
 src/go/types/testdata/fixedbugs/issue48008.go2           | 2 +-
 src/go/types/typestring.go                               | 7 +++++++
 src/go/types/universe.go                                 | 5 ++++-
 15 files changed, 72 insertions(+), 18 deletions(-)

diff --git a/src/cmd/compile/internal/importer/support.go b/src/cmd/compile/internal/importer/support.go
index 6ceb413601..9377d99779 100644
--- a/src/cmd/compile/internal/importer/support.go
+++ b/src/cmd/compile/internal/importer/support.go
@@ -118,10 +118,14 @@ var predeclared = []types2.Type{
 	types2.Typ[types2.Invalid], // only appears in packages with errors
 
 	// used internally by gc; never used by this package or in .a files
+	// not to be confused with the universe any
 	anyType{},
 
 	// comparable
 	types2.Universe.Lookup("comparable").Type(),
+
+	// any
+	types2.Universe.Lookup("any").Type(),
 }
 
 type anyType struct{}
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index f035e0da97..fa24ab1844 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -26,6 +26,8 @@ func (g *irgen) pkg(pkg *types2.Package) *types.Pkg {
 	return types.NewPkg(pkg.Path(), pkg.Name())
 }
 
+var universeAny = types2.Universe.Lookup("any").Type()
+
 // typ converts a types2.Type to a types.Type, including caching of previously
 // translated types.
 func (g *irgen) typ(typ types2.Type) *types.Type {
@@ -53,6 +55,12 @@ func (g *irgen) typ(typ types2.Type) *types.Type {
 // constructed part of a recursive type. Should not be called from outside this
 // file (g.typ is the "external" entry point).
 func (g *irgen) typ1(typ types2.Type) *types.Type {
+	// See issue 49583: the type checker has trouble keeping track of aliases,
+	// but for such a common alias as any we can improve things by preserving a
+	// pointer identity that can be checked when formatting type strings.
+	if typ == universeAny {
+		return types.AnyType
+	}
 	// Cache type2-to-type mappings. Important so that each defined generic
 	// type (instantiated or not) has a single types.Type representation.
 	// Also saves a lot of computation and memory by avoiding re-translating
diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index a59c9a4eee..866ebb8684 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -319,16 +319,16 @@ func TestTypesInfo(t *testing.T) {
 		{brokenPkg + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string]invalid type`},
 
 		// parameterized functions
-		{`package p0; func f[T any](T) {}; var _ = f[int]`, `f`, `func[T interface{}](T)`},
+		{`package p0; func f[T any](T) {}; var _ = f[int]`, `f`, `func[T any](T)`},
 		{`package p1; func f[T any](T) {}; var _ = f[int]`, `f[int]`, `func(int)`},
 		{`package p2; func f[T any](T) {}; func _() { f(42) }`, `f`, `func(int)`},
 		{`package p3; func f[T any](T) {}; func _() { f[int](42) }`, `f[int]`, `func(int)`},
-		{`package p4; func f[T any](T) {}; func _() { f[int](42) }`, `f`, `func[T interface{}](T)`},
+		{`package p4; func f[T any](T) {}; func _() { f[int](42) }`, `f`, `func[T any](T)`},
 		{`package p5; func f[T any](T) {}; func _() { f(42) }`, `f(42)`, `()`},
 
 		// type parameters
 		{`package t0; type t[] int; var _ t`, `t`, `t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
-		{`package t1; type t[P any] int; var _ t[int]`, `t`, `t1.t[P interface{}]`},
+		{`package t1; type t[P any] int; var _ t[int]`, `t`, `t1.t[P any]`},
 		{`package t2; type t[P interface{}] int; var _ t[int]`, `t`, `t2.t[P interface{}]`},
 		{`package t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `t3.t[P, Q interface{}]`},
 		{brokenPkg + `t4; type t[P, Q interface{ m() }] int; var _ t[int, int]`, `t`, `broken_t4.t[P, Q interface{m()}]`},
diff --git a/src/cmd/compile/internal/types2/object.go b/src/cmd/compile/internal/types2/object.go
index da3e1a2abc..c7c64ca9d5 100644
--- a/src/cmd/compile/internal/types2/object.go
+++ b/src/cmd/compile/internal/types2/object.go
@@ -528,6 +528,14 @@ func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) {
 		}
 	}
 
+	// Special handling for any: because WriteType will format 'any' as 'any',
+	// resulting in the object string `type any = any` rather than `type any =
+	// interface{}`. To avoid this, swap in a different empty interface.
+	if obj == universeAny {
+		assert(Identical(typ, &emptyInterface))
+		typ = &emptyInterface
+	}
+
 	buf.WriteByte(' ')
 	WriteType(buf, typ, qf)
 }
diff --git a/src/cmd/compile/internal/types2/object_test.go b/src/cmd/compile/internal/types2/object_test.go
index 93b3dfb44b..8f0303d4b2 100644
--- a/src/cmd/compile/internal/types2/object_test.go
+++ b/src/cmd/compile/internal/types2/object_test.go
@@ -101,8 +101,8 @@ var testObjects = []struct {
 
 	{"type t struct{f int}", "t", "type p.t struct{f int}"},
 	{"type t func(int)", "t", "type p.t func(int)"},
-	{"type t[P any] struct{f P}", "t", "type p.t[P interface{}] struct{f P}"},
-	{"type t[P any] struct{f P}", "t.P", "type parameter P interface{}"},
+	{"type t[P any] struct{f P}", "t", "type p.t[P any] struct{f P}"},
+	{"type t[P any] struct{f P}", "t.P", "type parameter P any"},
 	{"type C interface{m()}; type t[P C] struct{}", "t.P", "type parameter P p.C"},
 
 	{"type t = struct{f int}", "t", "type p.t = struct{f int}"},
@@ -111,8 +111,9 @@ var testObjects = []struct {
 	{"var v int", "v", "var p.v int"},
 
 	{"func f(int) string", "f", "func p.f(int) string"},
-	{"func g[P any](x P){}", "g", "func p.g[P interface{}](x P)"},
+	{"func g[P any](x P){}", "g", "func p.g[P any](x P)"},
 	{"func g[P interface{~int}](x P){}", "g.P", "type parameter P interface{~int}"},
+	{"", "any", "type any = interface{}"},
 }
 
 func TestObjectString(t *testing.T) {
@@ -131,7 +132,7 @@ func TestObjectString(t *testing.T) {
 			t.Errorf("%s: invalid object path %s", test.src, test.obj)
 			continue
 		}
-		obj := pkg.Scope().Lookup(names[0])
+		_, obj := pkg.Scope().LookupParent(names[0], nopos)
 		if obj == nil {
 			t.Errorf("%s: %s not found", test.src, names[0])
 			continue
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48008.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48008.go2
index 5c9726875c..6c14c78e4c 100644
--- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48008.go2
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48008.go2
@@ -21,7 +21,7 @@ func _(x interface{}) {
 	case map[T[int]] string:
 	case chan T[int]:
 
-	case T /* ERROR cannot use generic type T\[P interface{}\] without instantiation */ :
+	case T /* ERROR cannot use generic type T\[P any\] without instantiation */ :
 	case []T /* ERROR cannot use generic type */ :
 	case [10]T /* ERROR cannot use generic type */ :
 	case struct{T /* ERROR cannot use generic type */ }:
diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
index f151f47a5e..0c93a7e6e4 100644
--- a/src/cmd/compile/internal/types2/typestring.go
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -197,6 +197,13 @@ func (w *typeWriter) typ(typ Type) {
 		}
 
 	case *Interface:
+		if t == universeAny.Type() && w.ctxt == nil {
+			// When not hashing, we can try to improve type strings by writing "any"
+			// for a type that is pointer-identical to universeAny. This logic should
+			// be deprecated by more robust handling for aliases.
+			w.string("any")
+			break
+		}
 		if t.implicit {
 			if len(t.methods) == 0 && len(t.embeddeds) == 1 {
 				w.typ(t.embeddeds[0])
diff --git a/src/cmd/compile/internal/types2/universe.go b/src/cmd/compile/internal/types2/universe.go
index fccab145f8..c16ae3f63e 100644
--- a/src/cmd/compile/internal/types2/universe.go
+++ b/src/cmd/compile/internal/types2/universe.go
@@ -79,7 +79,10 @@ func defPredeclaredTypes() {
 	}
 
 	// type any = interface{}
-	def(NewTypeName(nopos, nil, "any", &emptyInterface))
+	// Note: don't use &emptyInterface for the type of any. Using a unique
+	// pointer allows us to detect any and format it as "any" rather than
+	// interface{}, which clarifies user-facing error messages significantly.
+	def(NewTypeName(nopos, nil, "any", &Interface{complete: true, tset: &topTypeSet}))
 
 	// type error interface{ Error() string }
 	{
diff --git a/src/go/internal/gcimporter/support.go b/src/go/internal/gcimporter/support.go
index 5aef63ec1e..965e5d8838 100644
--- a/src/go/internal/gcimporter/support.go
+++ b/src/go/internal/gcimporter/support.go
@@ -134,10 +134,14 @@ var predeclared = []types.Type{
 	types.Typ[types.Invalid], // only appears in packages with errors
 
 	// used internally by gc; never used by this package or in .a files
+	// not to be confused with the universe any
 	anyType{},
 
 	// comparable
 	types.Universe.Lookup("comparable").Type(),
+
+	// any
+	types.Universe.Lookup("any").Type(),
 }
 
 type anyType struct{}
diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index c9127f366a..d8ca8ad611 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -349,16 +349,16 @@ func TestTypesInfo(t *testing.T) {
 		{broken + `x5; func _() { var x map[string][...]int; x = map[string][...]int{"": {1,2,3}} }`, `x`, `map[string]invalid type`},
 
 		// parameterized functions
-		{genericPkg + `p0; func f[T any](T) {}; var _ = f[int]`, `f`, `func[T interface{}](T)`},
+		{genericPkg + `p0; func f[T any](T) {}; var _ = f[int]`, `f`, `func[T any](T)`},
 		{genericPkg + `p1; func f[T any](T) {}; var _ = f[int]`, `f[int]`, `func(int)`},
 		{genericPkg + `p2; func f[T any](T) {}; func _() { f(42) }`, `f`, `func(int)`},
 		{genericPkg + `p3; func f[T any](T) {}; func _() { f[int](42) }`, `f[int]`, `func(int)`},
-		{genericPkg + `p4; func f[T any](T) {}; func _() { f[int](42) }`, `f`, `func[T interface{}](T)`},
+		{genericPkg + `p4; func f[T any](T) {}; func _() { f[int](42) }`, `f`, `func[T any](T)`},
 		{genericPkg + `p5; func f[T any](T) {}; func _() { f(42) }`, `f(42)`, `()`},
 
 		// type parameters
 		{genericPkg + `t0; type t[] int; var _ t`, `t`, `generic_t0.t`}, // t[] is a syntax error that is ignored in this test in favor of t
-		{genericPkg + `t1; type t[P any] int; var _ t[int]`, `t`, `generic_t1.t[P interface{}]`},
+		{genericPkg + `t1; type t[P any] int; var _ t[int]`, `t`, `generic_t1.t[P any]`},
 		{genericPkg + `t2; type t[P interface{}] int; var _ t[int]`, `t`, `generic_t2.t[P interface{}]`},
 		{genericPkg + `t3; type t[P, Q interface{}] int; var _ t[int, int]`, `t`, `generic_t3.t[P, Q interface{}]`},
 
diff --git a/src/go/types/object.go b/src/go/types/object.go
index 9309a529c4..cf05384a87 100644
--- a/src/go/types/object.go
+++ b/src/go/types/object.go
@@ -482,6 +482,14 @@ func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) {
 		}
 	}
 
+	// Special handling for any: because WriteType will format 'any' as 'any',
+	// resulting in the object string `type any = any` rather than `type any =
+	// interface{}`. To avoid this, swap in a different empty interface.
+	if obj == universeAny {
+		assert(Identical(typ, &emptyInterface))
+		typ = &emptyInterface
+	}
+
 	buf.WriteByte(' ')
 	WriteType(buf, typ, qf)
 }
diff --git a/src/go/types/object_test.go b/src/go/types/object_test.go
index 46b92a4006..47c7fcd349 100644
--- a/src/go/types/object_test.go
+++ b/src/go/types/object_test.go
@@ -104,8 +104,8 @@ var testObjects = []struct {
 
 	{"type t struct{f int}", "t", "type p.t struct{f int}"},
 	{"type t func(int)", "t", "type p.t func(int)"},
-	{"type t[P any] struct{f P}", "t", "type p.t[P interface{}] struct{f P}"},
-	{"type t[P any] struct{f P}", "t.P", "type parameter P interface{}"},
+	{"type t[P any] struct{f P}", "t", "type p.t[P any] struct{f P}"},
+	{"type t[P any] struct{f P}", "t.P", "type parameter P any"},
 	{"type C interface{m()}; type t[P C] struct{}", "t.P", "type parameter P p.C"},
 
 	{"type t = struct{f int}", "t", "type p.t = struct{f int}"},
@@ -114,8 +114,9 @@ var testObjects = []struct {
 	{"var v int", "v", "var p.v int"},
 
 	{"func f(int) string", "f", "func p.f(int) string"},
-	{"func g[P any](x P){}", "g", "func p.g[P interface{}](x P)"},
+	{"func g[P any](x P){}", "g", "func p.g[P any](x P)"},
 	{"func g[P interface{~int}](x P){}", "g.P", "type parameter P interface{~int}"},
+	{"", "any", "type any = interface{}"},
 }
 
 func TestObjectString(t *testing.T) {
@@ -134,7 +135,7 @@ func TestObjectString(t *testing.T) {
 			t.Errorf("%s: invalid object path %s", test.src, test.obj)
 			continue
 		}
-		obj := pkg.Scope().Lookup(names[0])
+		_, obj := pkg.Scope().LookupParent(names[0], token.NoPos)
 		if obj == nil {
 			t.Errorf("%s: %s not found", test.src, names[0])
 			continue
diff --git a/src/go/types/testdata/fixedbugs/issue48008.go2 b/src/go/types/testdata/fixedbugs/issue48008.go2
index 5c9726875c..6c14c78e4c 100644
--- a/src/go/types/testdata/fixedbugs/issue48008.go2
+++ b/src/go/types/testdata/fixedbugs/issue48008.go2
@@ -21,7 +21,7 @@ func _(x interface{}) {
 	case map[T[int]] string:
 	case chan T[int]:
 
-	case T /* ERROR cannot use generic type T\[P interface{}\] without instantiation */ :
+	case T /* ERROR cannot use generic type T\[P any\] without instantiation */ :
 	case []T /* ERROR cannot use generic type */ :
 	case [10]T /* ERROR cannot use generic type */ :
 	case struct{T /* ERROR cannot use generic type */ }:
diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go
index f33175f97e..cf86f9f720 100644
--- a/src/go/types/typestring.go
+++ b/src/go/types/typestring.go
@@ -202,6 +202,13 @@ func (w *typeWriter) typ(typ Type) {
 		}
 
 	case *Interface:
+		if t == universeAny.Type() && w.ctxt == nil {
+			// When not hashing, we can try to improve type strings by writing "any"
+			// for a type that is pointer-identical to universeAny. This logic should
+			// be deprecated by more robust handling for aliases.
+			w.string("any")
+			break
+		}
 		if t.implicit {
 			if len(t.methods) == 0 && len(t.embeddeds) == 1 {
 				w.typ(t.embeddeds[0])
diff --git a/src/go/types/universe.go b/src/go/types/universe.go
index 519cf0b707..e30ab12bc3 100644
--- a/src/go/types/universe.go
+++ b/src/go/types/universe.go
@@ -80,7 +80,10 @@ func defPredeclaredTypes() {
 	}
 
 	// type any = interface{}
-	def(NewTypeName(token.NoPos, nil, "any", &emptyInterface))
+	// Note: don't use &emptyInterface for the type of any. Using a unique
+	// pointer allows us to detect any and format it as "any" rather than
+	// interface{}, which clarifies user-facing error messages significantly.
+	def(NewTypeName(token.NoPos, nil, "any", &Interface{complete: true, tset: &topTypeSet}))
 
 	// type error interface{ Error() string }
 	{

From 29ec902efc0ae53c4435097efdb738667466756c Mon Sep 17 00:00:00 2001
From: Michael Pratt 
Date: Tue, 16 Nov 2021 11:46:42 -0500
Subject: [PATCH 191/752] runtime: get tracking time only when needed

casgstatus currently calls nanotime on every casgstatus when tracking,
even though the time is only used in some cases. For goroutines making
lots of transitions that aren't covered here, this can add a small
overhead. Switch to calling nanotime only when necessary.

Change-Id: I2617869332e8289ef33dd674d786e44dea09aaba
Reviewed-on: https://go-review.googlesource.com/c/go/+/364375
Trust: Michael Pratt 
Run-TryBot: Michael Pratt 
Reviewed-by: Michael Knyszek 
TryBot-Result: Go Bot 
---
 src/runtime/proc.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index bf5fa8e4fc..a238ea77f3 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -980,17 +980,18 @@ func casgstatus(gp *g, oldval, newval uint32) {
 		gp.trackingSeq++
 	}
 	if gp.tracking {
-		now := nanotime()
 		if oldval == _Grunnable {
 			// We transitioned out of runnable, so measure how much
 			// time we spent in this state and add it to
 			// runnableTime.
+			now := nanotime()
 			gp.runnableTime += now - gp.runnableStamp
 			gp.runnableStamp = 0
 		}
 		if newval == _Grunnable {
 			// We just transitioned into runnable, so record what
 			// time that happened.
+			now := nanotime()
 			gp.runnableStamp = now
 		} else if newval == _Grunning {
 			// We're transitioning into running, so turn off

From 40effca7a13d11f3549a24a5d4b02e87c12fc6bb Mon Sep 17 00:00:00 2001
From: Michael Matloob 
Date: Mon, 15 Nov 2021 16:19:29 -0500
Subject: [PATCH 192/752] cmd: pull in golang.org/x/mod@3a5865c

This change updates the cmd module's requirement on x/mod and vendors in
the changes.

This pulls in the following changes into our vendored copy of x/mod:
golang.org/cl/351319: module: accept trailing slash in MatchPrefixPattern
golang.org/cl/353749: semver: remove unused err field
golang.org/cl/355630: x/mod: update requirement on x/crypto
golang.org/cl/359412: modfile: rename directory directive to use

Changes have been made in cmd/go renaming all uses of directory to use
and fixing references to functions in x/mod/modfile to account for the
changes in the last of thse CLs.

For #45713

Change-Id: I9121d08f6e6b11838bca50e6cbd756baeeae867b
Reviewed-on: https://go-review.googlesource.com/c/go/+/364114
Trust: Michael Matloob 
Run-TryBot: Michael Matloob 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
---
 src/cmd/go.mod                                |  2 +-
 src/cmd/go.sum                                |  4 +-
 src/cmd/go/alldocs.go                         |  8 +--
 src/cmd/go/internal/modload/init.go           |  8 +--
 src/cmd/go/internal/workcmd/edit.go           | 40 +++++++-------
 src/cmd/go/internal/workcmd/use.go            |  6 +--
 src/cmd/go/testdata/script/work.txt           | 10 ++--
 src/cmd/go/testdata/script/work_edit.txt      | 52 +++++++++----------
 src/cmd/go/testdata/script/work_env.txt       |  2 +-
 src/cmd/go/testdata/script/work_prune.txt     |  2 +-
 src/cmd/go/testdata/script/work_replace.txt   |  2 +-
 .../testdata/script/work_replace_conflict.txt |  4 +-
 .../script/work_replace_conflict_override.txt |  4 +-
 src/cmd/go/testdata/script/work_sum.txt       |  2 +-
 .../go/testdata/script/work_sum_mismatch.txt  |  4 +-
 src/cmd/go/testdata/script/work_sync.txt      |  2 +-
 .../work_sync_irrelevant_dependency.txt       |  2 +-
 .../script/work_sync_relevant_dependency.txt  |  2 +-
 src/cmd/go/testdata/script/work_use.txt       |  6 +--
 .../script/work_why_download_graph.txt        |  2 +-
 .../vendor/golang.org/x/mod/modfile/rule.go   |  4 +-
 .../vendor/golang.org/x/mod/modfile/work.go   | 50 +++++++++---------
 .../vendor/golang.org/x/mod/module/module.go  |  2 +
 .../vendor/golang.org/x/mod/semver/semver.go  | 10 ----
 src/cmd/vendor/modules.txt                    |  2 +-
 25 files changed, 112 insertions(+), 120 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 014c854a73..75a93e6bd1 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -5,7 +5,7 @@ go 1.18
 require (
 	github.com/google/pprof v0.0.0-20211104044539-f987b9c94b31
 	golang.org/x/arch v0.0.0-20210923205945-b76863e36670
-	golang.org/x/mod v0.6.0-dev.0.20210913215816-37dd6891021a
+	golang.org/x/mod v0.6.0-dev.0.20211102181907-3a5865c02020
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
 	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211
 	golang.org/x/tools v0.1.8-0.20211116011028-4adea5033c5c
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 4f50e7c6c8..62619b8d01 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -9,8 +9,8 @@ golang.org/x/arch v0.0.0-20210923205945-b76863e36670 h1:18EFjUmQOcUvxNYSkA6jO9VA
 golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
 golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa h1:idItI2DDfCokpg0N51B2VtiLdJ4vAuXC9fnCb2gACo4=
 golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/mod v0.6.0-dev.0.20210913215816-37dd6891021a h1:gAiIC0JKDJwXAQFyqEYxROcAzeeh5ZTwWjKORCFuQxs=
-golang.org/x/mod v0.6.0-dev.0.20210913215816-37dd6891021a/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro=
+golang.org/x/mod v0.6.0-dev.0.20211102181907-3a5865c02020 h1:HjtpZuJcnSa+yHlL4Y5aypjDvbHkJne5FS8JRmKI2+I=
+golang.org/x/mod v0.6.0-dev.0.20211102181907-3a5865c02020/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index a53ff7c66d..6805d56e2c 100644
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -1411,8 +1411,8 @@
 // rewrite the go.mod file. The only time this flag is needed is if no other
 // flags are specified, as in 'go mod editwork -fmt'.
 //
-// The -directory=path and -dropdirectory=path flags
-// add and drop a directory from the go.work files set of module directories.
+// The -use=path and -dropuse=path flags
+// add and drop a use directive from the go.work file's set of module directories.
 //
 // The -replace=old[@v]=new[@v] flag adds a replacement of the given
 // module path and version pair. If the @v in old@v is omitted, a
@@ -1426,7 +1426,7 @@
 // module path and version pair. If the @v is omitted, a replacement without
 // a version on the left side is dropped.
 //
-// The -directory, -dropdirectory, -replace, and -dropreplace,
+// The -use, -dropuse, -replace, and -dropreplace,
 // editing flags may be repeated, and the changes are applied in the order given.
 //
 // The -go=version flag sets the expected Go language version.
@@ -1448,7 +1448,7 @@
 // 		Replace   []Replace
 // 	}
 //
-// 	type Directory struct {
+// 	type Use struct {
 // 		Path       string
 // 		ModulePath string
 // 	}
diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go
index ab899fac1e..8bb3875e37 100644
--- a/src/cmd/go/internal/modload/init.go
+++ b/src/cmd/go/internal/modload/init.go
@@ -565,7 +565,7 @@ func loadWorkFile(path string) (goVersion string, modRoots []string, replaces []
 		goVersion = wf.Go.Version
 	}
 	seen := map[string]bool{}
-	for _, d := range wf.Directory {
+	for _, d := range wf.Use {
 		modRoot := d.Path
 		if !filepath.IsAbs(modRoot) {
 			modRoot = filepath.Join(workDir, modRoot)
@@ -606,7 +606,7 @@ func WriteWorkFile(path string, wf *modfile.WorkFile) error {
 func UpdateWorkFile(wf *modfile.WorkFile) {
 	missingModulePaths := map[string]string{} // module directory listed in file -> abspath modroot
 
-	for _, d := range wf.Directory {
+	for _, d := range wf.Use {
 		modRoot := d.Path
 		if d.ModulePath == "" {
 			missingModulePaths[d.Path] = modRoot
@@ -620,7 +620,7 @@ func UpdateWorkFile(wf *modfile.WorkFile) {
 		if err != nil {
 			continue // Error will be reported if modules are loaded.
 		}
-		wf.AddDirectory(moddir, f.Module.Mod.Path)
+		wf.AddUse(moddir, f.Module.Mod.Path)
 	}
 }
 
@@ -887,7 +887,7 @@ func CreateWorkFile(ctx context.Context, workFile string, modDirs []string) {
 			}
 			base.Fatalf("go: error parsing go.mod in directory %s: %v", dir, err)
 		}
-		workF.AddDirectory(ToDirectoryPath(dir), f.Module.Mod.Path)
+		workF.AddUse(ToDirectoryPath(dir), f.Module.Mod.Path)
 	}
 
 	UpdateWorkFile(workF)
diff --git a/src/cmd/go/internal/workcmd/edit.go b/src/cmd/go/internal/workcmd/edit.go
index 5158ac9b49..03a27f2bc6 100644
--- a/src/cmd/go/internal/workcmd/edit.go
+++ b/src/cmd/go/internal/workcmd/edit.go
@@ -37,8 +37,8 @@ This reformatting is also implied by any other modifications that use or
 rewrite the go.mod file. The only time this flag is needed is if no other
 flags are specified, as in 'go mod editwork -fmt'.
 
-The -directory=path and -dropdirectory=path flags
-add and drop a directory from the go.work files set of module directories.
+The -use=path and -dropuse=path flags
+add and drop a use directive from the go.work file's set of module directories.
 
 The -replace=old[@v]=new[@v] flag adds a replacement of the given
 module path and version pair. If the @v in old@v is omitted, a
@@ -52,7 +52,7 @@ The -dropreplace=old[@v] flag drops a replacement of the given
 module path and version pair. If the @v is omitted, a replacement without
 a version on the left side is dropped.
 
-The -directory, -dropdirectory, -replace, and -dropreplace,
+The -use, -dropuse, -replace, and -dropreplace,
 editing flags may be repeated, and the changes are applied in the order given.
 
 The -go=version flag sets the expected Go language version.
@@ -74,7 +74,7 @@ writing it back to go.mod. The JSON output corresponds to these Go types:
 		Replace   []Replace
 	}
 
-	type Directory struct {
+	type Use struct {
 		Path       string
 		ModulePath string
 	}
@@ -106,8 +106,8 @@ func (f flagFunc) Set(s string) error { f(s); return nil }
 func init() {
 	cmdEdit.Run = runEditwork // break init cycle
 
-	cmdEdit.Flag.Var(flagFunc(flagEditworkDirectory), "directory", "")
-	cmdEdit.Flag.Var(flagFunc(flagEditworkDropDirectory), "dropdirectory", "")
+	cmdEdit.Flag.Var(flagFunc(flagEditworkUse), "use", "")
+	cmdEdit.Flag.Var(flagFunc(flagEditworkDropUse), "dropuse", "")
 	cmdEdit.Flag.Var(flagFunc(flagEditworkReplace), "replace", "")
 	cmdEdit.Flag.Var(flagFunc(flagEditworkDropReplace), "dropreplace", "")
 
@@ -182,25 +182,25 @@ func runEditwork(ctx context.Context, cmd *base.Command, args []string) {
 	modload.WriteWorkFile(gowork, workFile)
 }
 
-// flagEditworkDirectory implements the -directory flag.
-func flagEditworkDirectory(arg string) {
+// flagEditworkUse implements the -use flag.
+func flagEditworkUse(arg string) {
 	workedits = append(workedits, func(f *modfile.WorkFile) {
 		_, mf, err := modload.ReadModFile(filepath.Join(arg, "go.mod"), nil)
 		modulePath := ""
 		if err == nil {
 			modulePath = mf.Module.Mod.Path
 		}
-		f.AddDirectory(modload.ToDirectoryPath(arg), modulePath)
-		if err := f.AddDirectory(modload.ToDirectoryPath(arg), ""); err != nil {
-			base.Fatalf("go: -directory=%s: %v", arg, err)
+		f.AddUse(modload.ToDirectoryPath(arg), modulePath)
+		if err := f.AddUse(modload.ToDirectoryPath(arg), ""); err != nil {
+			base.Fatalf("go: -use=%s: %v", arg, err)
 		}
 	})
 }
 
-// flagEditworkDropDirectory implements the -dropdirectory flag.
-func flagEditworkDropDirectory(arg string) {
+// flagEditworkDropUse implements the -dropuse flag.
+func flagEditworkDropUse(arg string) {
 	workedits = append(workedits, func(f *modfile.WorkFile) {
-		if err := f.DropDirectory(modload.ToDirectoryPath(arg)); err != nil {
+		if err := f.DropUse(modload.ToDirectoryPath(arg)); err != nil {
 			base.Fatalf("go: -dropdirectory=%s: %v", arg, err)
 		}
 	})
@@ -287,8 +287,8 @@ func editPrintJSON(workFile *modfile.WorkFile) {
 	if workFile.Go != nil {
 		f.Go = workFile.Go.Version
 	}
-	for _, d := range workFile.Directory {
-		f.Directory = append(f.Directory, directoryJSON{DiskPath: d.Path, ModPath: d.ModulePath})
+	for _, d := range workFile.Use {
+		f.Use = append(f.Use, useJSON{DiskPath: d.Path, ModPath: d.ModulePath})
 	}
 
 	for _, r := range workFile.Replace {
@@ -304,12 +304,12 @@ func editPrintJSON(workFile *modfile.WorkFile) {
 
 // workfileJSON is the -json output data structure.
 type workfileJSON struct {
-	Go        string `json:",omitempty"`
-	Directory []directoryJSON
-	Replace   []replaceJSON
+	Go      string `json:",omitempty"`
+	Use     []useJSON
+	Replace []replaceJSON
 }
 
-type directoryJSON struct {
+type useJSON struct {
 	DiskPath string
 	ModPath  string `json:",omitempty"`
 }
diff --git a/src/cmd/go/internal/workcmd/use.go b/src/cmd/go/internal/workcmd/use.go
index b2218280e4..97c493685a 100644
--- a/src/cmd/go/internal/workcmd/use.go
+++ b/src/cmd/go/internal/workcmd/use.go
@@ -53,7 +53,7 @@ func runUse(ctx context.Context, cmd *base.Command, args []string) {
 	}
 
 	haveDirs := make(map[string]bool)
-	for _, dir := range workFile.Directory {
+	for _, dir := range workFile.Use {
 		haveDirs[filepath.Join(filepath.Dir(gowork), filepath.FromSlash(dir.Path))] = true
 	}
 
@@ -105,10 +105,10 @@ func runUse(ctx context.Context, cmd *base.Command, args []string) {
 	}
 
 	for dir := range removeDirs {
-		workFile.DropDirectory(filepath.ToSlash(dir))
+		workFile.DropUse(filepath.ToSlash(dir))
 	}
 	for dir := range addDirs {
-		workFile.AddDirectory(filepath.ToSlash(dir), "")
+		workFile.AddUse(filepath.ToSlash(dir), "")
 	}
 	modload.UpdateWorkFile(workFile)
 	modload.WriteWorkFile(gowork, workFile)
diff --git a/src/cmd/go/testdata/script/work.txt b/src/cmd/go/testdata/script/work.txt
index 68bd3ea08b..cbb3746a69 100644
--- a/src/cmd/go/testdata/script/work.txt
+++ b/src/cmd/go/testdata/script/work.txt
@@ -34,7 +34,7 @@ go list -mod=readonly all
 stderr '^go: -mod may only be set to readonly when in workspace mode'
 go list -mod=mod -workfile=off all
 
-# Test that duplicates in the directory list return an error
+# Test that duplicates in the use list return an error
 cp go.work go.work.backup
 cp go.work.dup go.work
 ! go run example.com/b
@@ -59,7 +59,7 @@ go build -n -o foo foo.go
 -- go.work.dup --
 go 1.18
 
-directory (
+use (
   a
   b
   ../src/a
@@ -67,14 +67,14 @@ directory (
 -- go.work.want --
 go 1.18
 
-directory (
+use (
 	./a
 	./b
 )
 -- go.work.d --
 go 1.18
 
-directory (
+use (
 	a
 	b
 	d
@@ -133,7 +133,7 @@ func main() {
 -- go.work.backwards --
 go 1.18
 
-directory (
+use (
     d
     b
     a
diff --git a/src/cmd/go/testdata/script/work_edit.txt b/src/cmd/go/testdata/script/work_edit.txt
index 060d1f0386..fd04bbda6e 100644
--- a/src/cmd/go/testdata/script/work_edit.txt
+++ b/src/cmd/go/testdata/script/work_edit.txt
@@ -3,31 +3,31 @@
 go work init m
 cmp go.work go.work.want_initial
 
-go work edit -directory n
-cmp go.work go.work.want_directory_n
+go work edit -use n
+cmp go.work go.work.want_use_n
 
 go work edit -go 1.18
 cmp go.work go.work.want_go_118
 
-go work edit -dropdirectory m
-cmp go.work go.work.want_dropdirectory_m
+go work edit -dropuse m
+cmp go.work go.work.want_dropuse_m
 
 go work edit -replace=x.1@v1.3.0=y.1@v1.4.0 -replace='x.1@v1.4.0 = ../z'
 cmp go.work go.work.want_add_replaces
 
-go work edit -directory n -directory ../a -directory /b -directory c -directory c
-cmp go.work go.work.want_multidirectory
+go work edit -use n -use ../a -use /b -use c -use c
+cmp go.work go.work.want_multiuse
 
-go work edit -dropdirectory /b -dropdirectory n
-cmp go.work go.work.want_multidropdirectory
+go work edit -dropuse /b -dropuse n
+cmp go.work go.work.want_multidropuse
 
 go work edit -dropreplace='x.1@v1.4.0'
 cmp go.work go.work.want_dropreplace
 
-go work edit -print -go 1.19 -directory b -dropdirectory c -replace 'x.1@v1.4.0 = ../z' -dropreplace x.1 -dropreplace x.1@v1.3.0
+go work edit -print -go 1.19 -use b -dropuse c -replace 'x.1@v1.4.0 = ../z' -dropreplace x.1 -dropreplace x.1@v1.3.0
 cmp stdout go.work.want_print
 
-go work edit -json -go 1.19 -directory b -dropdirectory c -replace 'x.1@v1.4.0 = ../z' -dropreplace x.1 -dropreplace x.1@v1.3.0
+go work edit -json -go 1.19 -use b -dropuse c -replace 'x.1@v1.4.0 = ../z' -dropreplace x.1 -dropreplace x.1@v1.3.0
 cmp stdout go.work.want_json
 
 go work edit -print -fmt -workfile $GOPATH/src/unformatted
@@ -40,38 +40,38 @@ go 1.18
 -- go.work.want_initial --
 go 1.18
 
-directory ./m
--- go.work.want_directory_n --
+use ./m
+-- go.work.want_use_n --
 go 1.18
 
-directory (
+use (
 	./m
 	./n
 )
 -- go.work.want_go_118 --
 go 1.18
 
-directory (
+use (
 	./m
 	./n
 )
--- go.work.want_dropdirectory_m --
+-- go.work.want_dropuse_m --
 go 1.18
 
-directory ./n
+use ./n
 -- go.work.want_add_replaces --
 go 1.18
 
-directory ./n
+use ./n
 
 replace (
 	x.1 v1.3.0 => y.1 v1.4.0
 	x.1 v1.4.0 => ../z
 )
--- go.work.want_multidirectory --
+-- go.work.want_multiuse --
 go 1.18
 
-directory (
+use (
 	../a
 	./c
 	./n
@@ -82,10 +82,10 @@ replace (
 	x.1 v1.3.0 => y.1 v1.4.0
 	x.1 v1.4.0 => ../z
 )
--- go.work.want_multidropdirectory --
+-- go.work.want_multidropuse --
 go 1.18
 
-directory (
+use (
 	../a
 	./c
 )
@@ -97,7 +97,7 @@ replace (
 -- go.work.want_dropreplace --
 go 1.18
 
-directory (
+use (
 	../a
 	./c
 )
@@ -106,7 +106,7 @@ replace x.1 v1.3.0 => y.1 v1.4.0
 -- go.work.want_print --
 go 1.19
 
-directory (
+use (
 	../a
 	./b
 )
@@ -115,7 +115,7 @@ replace x.1 v1.4.0 => ../z
 -- go.work.want_json --
 {
 	"Go": "1.19",
-	"Directory": [
+	"Use": [
 		{
 			"DiskPath": "../a"
 		},
@@ -137,7 +137,7 @@ replace x.1 v1.4.0 => ../z
 }
 -- unformatted --
 go 1.18
- directory (
+ use (
  a
   b
   c
@@ -149,7 +149,7 @@ go 1.18
 -- formatted --
 go 1.18
 
-directory (
+use (
 	a
 	b
 	c
diff --git a/src/cmd/go/testdata/script/work_env.txt b/src/cmd/go/testdata/script/work_env.txt
index de67255696..ec3d3be3ed 100644
--- a/src/cmd/go/testdata/script/work_env.txt
+++ b/src/cmd/go/testdata/script/work_env.txt
@@ -19,6 +19,6 @@ stderr '^go: GOWORK cannot be modified$'
 -- go.work --
 go 1.18
 
-directory a
+use a
 -- a/go.mod --
 module example.com/a
diff --git a/src/cmd/go/testdata/script/work_prune.txt b/src/cmd/go/testdata/script/work_prune.txt
index 00c3e10663..7e2ae4e6ce 100644
--- a/src/cmd/go/testdata/script/work_prune.txt
+++ b/src/cmd/go/testdata/script/work_prune.txt
@@ -19,7 +19,7 @@ stdout '^v1.1.0$'
 -- go.work --
 go 1.18
 
-directory (
+use (
 	./a
 	./p
 )
diff --git a/src/cmd/go/testdata/script/work_replace.txt b/src/cmd/go/testdata/script/work_replace.txt
index 5a4cb0eebb..81268e5069 100644
--- a/src/cmd/go/testdata/script/work_replace.txt
+++ b/src/cmd/go/testdata/script/work_replace.txt
@@ -10,7 +10,7 @@ go list -m example.com/other
 stdout 'example.com/other v1.0.0 => ./other2'
 
 -- go.work --
-directory m
+use m
 
 replace example.com/dep => ./dep
 replace example.com/other => ./other2
diff --git a/src/cmd/go/testdata/script/work_replace_conflict.txt b/src/cmd/go/testdata/script/work_replace_conflict.txt
index f91b63cd86..e5677b21d7 100644
--- a/src/cmd/go/testdata/script/work_replace_conflict.txt
+++ b/src/cmd/go/testdata/script/work_replace_conflict.txt
@@ -9,8 +9,8 @@ stdout 'example.com/dep v1.0.0 => ./dep1'
 
 -- foo --
 -- go.work --
-directory m
-directory n
+use m
+use n
 -- m/go.mod --
 module example.com/m
 
diff --git a/src/cmd/go/testdata/script/work_replace_conflict_override.txt b/src/cmd/go/testdata/script/work_replace_conflict_override.txt
index ebb517dd7c..c62084bee6 100644
--- a/src/cmd/go/testdata/script/work_replace_conflict_override.txt
+++ b/src/cmd/go/testdata/script/work_replace_conflict_override.txt
@@ -5,8 +5,8 @@ go list -m example.com/dep
 stdout 'example.com/dep v1.0.0 => ./dep3'
 
 -- go.work --
-directory m
-directory n
+use m
+use n
 replace example.com/dep => ./dep3
 -- m/go.mod --
 module example.com/m
diff --git a/src/cmd/go/testdata/script/work_sum.txt b/src/cmd/go/testdata/script/work_sum.txt
index 20261e7cbd..19dbb90507 100644
--- a/src/cmd/go/testdata/script/work_sum.txt
+++ b/src/cmd/go/testdata/script/work_sum.txt
@@ -11,7 +11,7 @@ rsc.io/quote v1.5.2/go.mod h1:LzX7hefJvL54yjefDEDHNONDjII0t9xZLPXsUe+TKr0=
 -- go.work --
 go 1.18
 
-directory .
+use .
 -- go.mod --
 go 1.18
 
diff --git a/src/cmd/go/testdata/script/work_sum_mismatch.txt b/src/cmd/go/testdata/script/work_sum_mismatch.txt
index 42994ea5d5..9e9474304e 100644
--- a/src/cmd/go/testdata/script/work_sum_mismatch.txt
+++ b/src/cmd/go/testdata/script/work_sum_mismatch.txt
@@ -17,8 +17,8 @@ For more information, see 'go help module-auth'.
 -- go.work --
 go 1.18
 
-directory ./a
-directory ./b
+use ./a
+use ./b
 -- a/go.mod --
 go 1.18
 
diff --git a/src/cmd/go/testdata/script/work_sync.txt b/src/cmd/go/testdata/script/work_sync.txt
index 16ad8c8cfa..69167d4cc1 100644
--- a/src/cmd/go/testdata/script/work_sync.txt
+++ b/src/cmd/go/testdata/script/work_sync.txt
@@ -5,7 +5,7 @@ cmp b/go.mod b/want_go.mod
 -- go.work --
 go 1.18
 
-directory (
+use (
 	./a
 	./b
 )
diff --git a/src/cmd/go/testdata/script/work_sync_irrelevant_dependency.txt b/src/cmd/go/testdata/script/work_sync_irrelevant_dependency.txt
index bbb8579b4f..072323d15d 100644
--- a/src/cmd/go/testdata/script/work_sync_irrelevant_dependency.txt
+++ b/src/cmd/go/testdata/script/work_sync_irrelevant_dependency.txt
@@ -11,7 +11,7 @@ cmp b/go.mod b/want_go.mod
 -- go.work --
 go 1.18
 
-directory (
+use (
 	./a
 	./b
 )
diff --git a/src/cmd/go/testdata/script/work_sync_relevant_dependency.txt b/src/cmd/go/testdata/script/work_sync_relevant_dependency.txt
index e95ac26707..d7997027d9 100644
--- a/src/cmd/go/testdata/script/work_sync_relevant_dependency.txt
+++ b/src/cmd/go/testdata/script/work_sync_relevant_dependency.txt
@@ -11,7 +11,7 @@ cmp b/go.mod b/want_go.mod
 -- go.work --
 go 1.18
 
-directory (
+use (
 	./a
 	./b
 )
diff --git a/src/cmd/go/testdata/script/work_use.txt b/src/cmd/go/testdata/script/work_use.txt
index dddce0fe22..f5ea89c900 100644
--- a/src/cmd/go/testdata/script/work_use.txt
+++ b/src/cmd/go/testdata/script/work_use.txt
@@ -6,21 +6,21 @@ cmp go.work go.want_work_other
 -- go.work --
 go 1.18
 
-directory (
+use (
 	foo
 	foo/bar // doesn't exist
 )
 -- go.want_work_r --
 go 1.18
 
-directory (
+use (
 	foo
 	foo/bar/baz
 )
 -- go.want_work_other --
 go 1.18
 
-directory (
+use (
 	foo
 	foo/bar/baz
 	other
diff --git a/src/cmd/go/testdata/script/work_why_download_graph.txt b/src/cmd/go/testdata/script/work_why_download_graph.txt
index c03b4a7a62..7964c914a2 100644
--- a/src/cmd/go/testdata/script/work_why_download_graph.txt
+++ b/src/cmd/go/testdata/script/work_why_download_graph.txt
@@ -24,7 +24,7 @@ stdout 'example.com/a rsc.io/quote@v1.5.2\nexample.com/b example.com/c@v1.0.0\nr
 -- go.work --
 go 1.18
 
-directory (
+use (
     ./a
     ./b
 )
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 98211a450a..ed2f31aa70 100644
--- a/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
+++ b/src/cmd/vendor/golang.org/x/mod/modfile/rule.go
@@ -609,7 +609,7 @@ func (f *WorkFile) add(errs *ErrorList, line *Line, verb string, args []string,
 		f.Go = &Go{Syntax: line}
 		f.Go.Version = args[0]
 
-	case "directory":
+	case "use":
 		if len(args) != 1 {
 			errorf("usage: %s local/dir", verb)
 			return
@@ -619,7 +619,7 @@ func (f *WorkFile) add(errs *ErrorList, line *Line, verb string, args []string,
 			errorf("invalid quoted string: %v", err)
 			return
 		}
-		f.Directory = append(f.Directory, &Directory{
+		f.Use = append(f.Use, &Use{
 			Path:   s,
 			Syntax: line,
 		})
diff --git a/src/cmd/vendor/golang.org/x/mod/modfile/work.go b/src/cmd/vendor/golang.org/x/mod/modfile/work.go
index b1fabff51b..0c0e521525 100644
--- a/src/cmd/vendor/golang.org/x/mod/modfile/work.go
+++ b/src/cmd/vendor/golang.org/x/mod/modfile/work.go
@@ -12,16 +12,16 @@ import (
 
 // A WorkFile is the parsed, interpreted form of a go.work file.
 type WorkFile struct {
-	Go        *Go
-	Directory []*Directory
-	Replace   []*Replace
+	Go      *Go
+	Use     []*Use
+	Replace []*Replace
 
 	Syntax *FileSyntax
 }
 
-// A Directory is a single directory statement.
-type Directory struct {
-	Path       string // Directory path of module.
+// A Use is a single directory statement.
+type Use struct {
+	Path       string // Use path of module.
 	ModulePath string // Module path in the comment.
 	Syntax     *Line
 }
@@ -67,7 +67,7 @@ func ParseWork(file string, data []byte, fix VersionFixer) (*WorkFile, error) {
 					Err:      fmt.Errorf("unknown block type: %s", strings.Join(x.Token, " ")),
 				})
 				continue
-			case "directory", "replace":
+			case "use", "replace":
 				for _, l := range x.Line {
 					f.add(&errs, l, x.Token[0], l.Token, fix)
 				}
@@ -87,13 +87,13 @@ func ParseWork(file string, data []byte, fix VersionFixer) (*WorkFile, error) {
 // Cleanup cleans out all the cleared entries.
 func (f *WorkFile) Cleanup() {
 	w := 0
-	for _, r := range f.Directory {
+	for _, r := range f.Use {
 		if r.Path != "" {
-			f.Directory[w] = r
+			f.Use[w] = r
 			w++
 		}
 	}
-	f.Directory = f.Directory[:w]
+	f.Use = f.Use[:w]
 
 	w = 0
 	for _, r := range f.Replace {
@@ -133,60 +133,60 @@ func (f *WorkFile) AddGoStmt(version string) error {
 	return nil
 }
 
-func (f *WorkFile) AddDirectory(diskPath, modulePath string) error {
+func (f *WorkFile) AddUse(diskPath, modulePath string) error {
 	need := true
-	for _, d := range f.Directory {
+	for _, d := range f.Use {
 		if d.Path == diskPath {
 			if need {
 				d.ModulePath = modulePath
-				f.Syntax.updateLine(d.Syntax, "directory", AutoQuote(diskPath))
+				f.Syntax.updateLine(d.Syntax, "use", AutoQuote(diskPath))
 				need = false
 			} else {
 				d.Syntax.markRemoved()
-				*d = Directory{}
+				*d = Use{}
 			}
 		}
 	}
 
 	if need {
-		f.AddNewDirectory(diskPath, modulePath)
+		f.AddNewUse(diskPath, modulePath)
 	}
 	return nil
 }
 
-func (f *WorkFile) AddNewDirectory(diskPath, modulePath string) {
-	line := f.Syntax.addLine(nil, "directory", AutoQuote(diskPath))
-	f.Directory = append(f.Directory, &Directory{Path: diskPath, ModulePath: modulePath, Syntax: line})
+func (f *WorkFile) AddNewUse(diskPath, modulePath string) {
+	line := f.Syntax.addLine(nil, "use", AutoQuote(diskPath))
+	f.Use = append(f.Use, &Use{Path: diskPath, ModulePath: modulePath, Syntax: line})
 }
 
-func (f *WorkFile) SetDirectory(dirs []*Directory) {
+func (f *WorkFile) SetUse(dirs []*Use) {
 	need := make(map[string]string)
 	for _, d := range dirs {
 		need[d.Path] = d.ModulePath
 	}
 
-	for _, d := range f.Directory {
+	for _, d := range f.Use {
 		if modulePath, ok := need[d.Path]; ok {
 			d.ModulePath = modulePath
 		} else {
 			d.Syntax.markRemoved()
-			*d = Directory{}
+			*d = Use{}
 		}
 	}
 
 	// TODO(#45713): Add module path to comment.
 
 	for diskPath, modulePath := range need {
-		f.AddNewDirectory(diskPath, modulePath)
+		f.AddNewUse(diskPath, modulePath)
 	}
 	f.SortBlocks()
 }
 
-func (f *WorkFile) DropDirectory(path string) error {
-	for _, d := range f.Directory {
+func (f *WorkFile) DropUse(path string) error {
+	for _, d := range f.Use {
 		if d.Path == path {
 			d.Syntax.markRemoved()
-			*d = Directory{}
+			*d = Use{}
 		}
 	}
 	return nil
diff --git a/src/cmd/vendor/golang.org/x/mod/module/module.go b/src/cmd/vendor/golang.org/x/mod/module/module.go
index 89bd3ede27..355b5a4568 100644
--- a/src/cmd/vendor/golang.org/x/mod/module/module.go
+++ b/src/cmd/vendor/golang.org/x/mod/module/module.go
@@ -798,6 +798,7 @@ func unescapeString(escaped string) (string, bool) {
 // GOPRIVATE environment variable, as described by 'go help module-private'.
 //
 // It ignores any empty or malformed patterns in the list.
+// Trailing slashes on patterns are ignored.
 func MatchPrefixPatterns(globs, target string) bool {
 	for globs != "" {
 		// Extract next non-empty glob in comma-separated list.
@@ -807,6 +808,7 @@ func MatchPrefixPatterns(globs, target string) bool {
 		} else {
 			glob, globs = globs, ""
 		}
+		glob = strings.TrimSuffix(glob, "/")
 		if glob == "" {
 			continue
 		}
diff --git a/src/cmd/vendor/golang.org/x/mod/semver/semver.go b/src/cmd/vendor/golang.org/x/mod/semver/semver.go
index 7be398f80d..a30a22bf20 100644
--- a/src/cmd/vendor/golang.org/x/mod/semver/semver.go
+++ b/src/cmd/vendor/golang.org/x/mod/semver/semver.go
@@ -32,7 +32,6 @@ type parsed struct {
 	short      string
 	prerelease string
 	build      string
-	err        string
 }
 
 // IsValid reports whether v is a valid semantic version string.
@@ -172,12 +171,10 @@ func Sort(list []string) {
 
 func parse(v string) (p parsed, ok bool) {
 	if v == "" || v[0] != 'v' {
-		p.err = "missing v prefix"
 		return
 	}
 	p.major, v, ok = parseInt(v[1:])
 	if !ok {
-		p.err = "bad major version"
 		return
 	}
 	if v == "" {
@@ -187,13 +184,11 @@ func parse(v string) (p parsed, ok bool) {
 		return
 	}
 	if v[0] != '.' {
-		p.err = "bad minor prefix"
 		ok = false
 		return
 	}
 	p.minor, v, ok = parseInt(v[1:])
 	if !ok {
-		p.err = "bad minor version"
 		return
 	}
 	if v == "" {
@@ -202,31 +197,26 @@ func parse(v string) (p parsed, ok bool) {
 		return
 	}
 	if v[0] != '.' {
-		p.err = "bad patch prefix"
 		ok = false
 		return
 	}
 	p.patch, v, ok = parseInt(v[1:])
 	if !ok {
-		p.err = "bad patch version"
 		return
 	}
 	if len(v) > 0 && v[0] == '-' {
 		p.prerelease, v, ok = parsePrerelease(v)
 		if !ok {
-			p.err = "bad prerelease"
 			return
 		}
 	}
 	if len(v) > 0 && v[0] == '+' {
 		p.build, v, ok = parseBuild(v)
 		if !ok {
-			p.err = "bad build"
 			return
 		}
 	}
 	if v != "" {
-		p.err = "junk on end"
 		ok = false
 		return
 	}
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index 82e04c1d33..fd955a6932 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -28,7 +28,7 @@ golang.org/x/arch/x86/x86asm
 ## explicit; go 1.17
 golang.org/x/crypto/ed25519
 golang.org/x/crypto/ed25519/internal/edwards25519
-# golang.org/x/mod v0.6.0-dev.0.20210913215816-37dd6891021a
+# golang.org/x/mod v0.6.0-dev.0.20211102181907-3a5865c02020
 ## explicit; go 1.17
 golang.org/x/mod/internal/lazyregexp
 golang.org/x/mod/modfile

From 6c36c332fefdd433cfe6e6468a2542fc310e9f8a Mon Sep 17 00:00:00 2001
From: Alessandro Arzilli 
Date: Mon, 15 Nov 2021 10:14:04 +0100
Subject: [PATCH 193/752] debug/pe,debug/macho: add support for DWARF5 sections

Adds the same logic used in debug/elf to load DWARF5 sections.

Fixes #49590

Change-Id: Iee05b9927a6f521842b330eab8942ade3fc2bd86
Reviewed-on: https://go-review.googlesource.com/c/go/+/363895
Reviewed-by: Ian Lance Taylor 
Trust: Than McIntosh 
---
 src/debug/macho/file.go | 14 +++++++++++---
 src/debug/pe/file.go    | 14 +++++++++++---
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/src/debug/macho/file.go b/src/debug/macho/file.go
index 73cfce3c76..cdc500e476 100644
--- a/src/debug/macho/file.go
+++ b/src/debug/macho/file.go
@@ -650,10 +650,14 @@ func (f *File) DWARF() (*dwarf.Data, error) {
 		return nil, err
 	}
 
-	// Look for DWARF4 .debug_types sections.
+	// Look for DWARF4 .debug_types sections and DWARF5 sections.
 	for i, s := range f.Sections {
 		suffix := dwarfSuffix(s)
-		if suffix != "types" {
+		if suffix == "" {
+			continue
+		}
+		if _, ok := dat[suffix]; ok {
+			// Already handled.
 			continue
 		}
 
@@ -662,7 +666,11 @@ func (f *File) DWARF() (*dwarf.Data, error) {
 			return nil, err
 		}
 
-		err = d.AddTypes(fmt.Sprintf("types-%d", i), b)
+		if suffix == "types" {
+			err = d.AddTypes(fmt.Sprintf("types-%d", i), b)
+		} else {
+			err = d.AddSection(".debug_"+suffix, b)
+		}
 		if err != nil {
 			return nil, err
 		}
diff --git a/src/debug/pe/file.go b/src/debug/pe/file.go
index e50229e5a3..ab00a48f5c 100644
--- a/src/debug/pe/file.go
+++ b/src/debug/pe/file.go
@@ -272,10 +272,14 @@ func (f *File) DWARF() (*dwarf.Data, error) {
 		return nil, err
 	}
 
-	// Look for DWARF4 .debug_types sections.
+	// Look for DWARF4 .debug_types sections and DWARF5 sections.
 	for i, s := range f.Sections {
 		suffix := dwarfSuffix(s)
-		if suffix != "types" {
+		if suffix == "" {
+			continue
+		}
+		if _, ok := dat[suffix]; ok {
+			// Already handled.
 			continue
 		}
 
@@ -284,7 +288,11 @@ func (f *File) DWARF() (*dwarf.Data, error) {
 			return nil, err
 		}
 
-		err = d.AddTypes(fmt.Sprintf("types-%d", i), b)
+		if suffix == "types" {
+			err = d.AddTypes(fmt.Sprintf("types-%d", i), b)
+		} else {
+			err = d.AddSection(".debug_"+suffix, b)
+		}
 		if err != nil {
 			return nil, err
 		}

From f6591839727e09cc5cb11d08b333fd2386e8aa1b Mon Sep 17 00:00:00 2001
From: Michael Pratt 
Date: Mon, 15 Nov 2021 13:50:39 -0500
Subject: [PATCH 194/752] os/exec: avoid NewFile on unknown FDs

exec_test.go's init function uses os.NewFile(fd) + f.Stat as a portable
mechanism to determine if an FD is in use.

Unfortunately, the current use is racy: if an unused FD becomes used
between NewFile and f.Close, then we will unintentionally close an FD we
do not use.

We cannot simply drop Close, as the finalizer will close the FD. We
could hold all of the os.Files in a global for the lifetime of the
process, but the need for such a hack is indicative of the larger
problem: we should not create an os.File for an FD that we do not own.

Instead, the new fdtest.Exists provides a helper that performs the
equivalent of fstat(2) on each OS to determine if the FD is valid,
without using os.File.

We also reuse this helper on a variety of other tests that look at open
FDs.

Fixes #49533

Change-Id: I36e2bdb15f271ab01e55c18db6564271995a15af
Reviewed-on: https://go-review.googlesource.com/c/go/+/364035
Trust: Michael Pratt 
Run-TryBot: Michael Pratt 
Reviewed-by: Bryan C. Mills 
---
 src/go/build/deps_test.go                     |   3 +
 src/os/exec/exec_test.go                      | 132 +++---------------
 src/os/exec/internal/fdtest/exists_js.go      |  18 +++
 src/os/exec/internal/fdtest/exists_plan9.go   |  20 +++
 src/os/exec/internal/fdtest/exists_test.go    |  21 +++
 src/os/exec/internal/fdtest/exists_unix.go    |  19 +++
 src/os/exec/internal/fdtest/exists_windows.go |  12 ++
 src/os/exec/read3.go                          |  98 ++++++-------
 8 files changed, 157 insertions(+), 166 deletions(-)
 create mode 100644 src/os/exec/internal/fdtest/exists_js.go
 create mode 100644 src/os/exec/internal/fdtest/exists_plan9.go
 create mode 100644 src/os/exec/internal/fdtest/exists_test.go
 create mode 100644 src/os/exec/internal/fdtest/exists_unix.go
 create mode 100644 src/os/exec/internal/fdtest/exists_windows.go

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 2f68cbcffc..7f25038d2d 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -545,6 +545,9 @@ var depsRules = `
 	NET, testing, math/rand
 	< golang.org/x/net/nettest;
 
+	syscall
+	< os/exec/internal/fdtest;
+
 	FMT, container/heap, math/rand
 	< internal/trace;
 `
diff --git a/src/os/exec/exec_test.go b/src/os/exec/exec_test.go
index 459ba39dff..6172c78dd4 100644
--- a/src/os/exec/exec_test.go
+++ b/src/os/exec/exec_test.go
@@ -21,7 +21,9 @@ import (
 	"net/http/httptest"
 	"os"
 	"os/exec"
+	"os/exec/internal/fdtest"
 	"path/filepath"
+	"reflect"
 	"runtime"
 	"strconv"
 	"strings"
@@ -29,15 +31,10 @@ import (
 	"time"
 )
 
-// haveUnexpectedFDs is set at init time to report whether any
-// file descriptors were open at program start.
+// haveUnexpectedFDs is set at init time to report whether any file descriptors
+// were open at program start.
 var haveUnexpectedFDs bool
 
-// unfinalizedFiles holds files that should not be finalized,
-// because that would close the associated file descriptor,
-// which we don't want to do.
-var unfinalizedFiles []*os.File
-
 func init() {
 	if os.Getenv("GO_WANT_HELPER_PROCESS") == "1" {
 		return
@@ -49,21 +46,10 @@ func init() {
 		if poll.IsPollDescriptor(fd) {
 			continue
 		}
-		// We have no good portable way to check whether an FD is open.
-		// We use NewFile to create a *os.File, which lets us
-		// know whether it is open, but then we have to cope with
-		// the finalizer on the *os.File.
-		f := os.NewFile(fd, "")
-		if _, err := f.Stat(); err != nil {
-			// Close the file to clear the finalizer.
-			// We expect the Close to fail.
-			f.Close()
-		} else {
-			fmt.Printf("fd %d open at test start\n", fd)
+
+		if fdtest.Exists(fd) {
 			haveUnexpectedFDs = true
-			// Use a global variable to avoid running
-			// the finalizer, which would close the FD.
-			unfinalizedFiles = append(unfinalizedFiles, f)
+			return
 		}
 	}
 }
@@ -377,50 +363,21 @@ func TestStdinCloseRace(t *testing.T) {
 
 // Issue 5071
 func TestPipeLookPathLeak(t *testing.T) {
-	// If we are reading from /proc/self/fd we (should) get an exact result.
-	tolerance := 0
-
-	// Reading /proc/self/fd is more reliable than calling lsof, so try that
-	// first.
-	numOpenFDs := func() (int, []byte, error) {
-		fds, err := os.ReadDir("/proc/self/fd")
-		if err != nil {
-			return 0, nil, err
-		}
-		return len(fds), nil, nil
+	if runtime.GOOS == "windows" {
+		t.Skip("we don't currently suppore counting open handles on windows")
 	}
-	want, before, err := numOpenFDs()
-	if err != nil {
-		// We encountered a problem reading /proc/self/fd (we might be on
-		// a platform that doesn't have it). Fall back onto lsof.
-		t.Logf("using lsof because: %v", err)
-		numOpenFDs = func() (int, []byte, error) {
-			// Android's stock lsof does not obey the -p option,
-			// so extra filtering is needed.
-			// https://golang.org/issue/10206
-			if runtime.GOOS == "android" {
-				// numOpenFDsAndroid handles errors itself and
-				// might skip or fail the test.
-				n, lsof := numOpenFDsAndroid(t)
-				return n, lsof, nil
+
+	openFDs := func() []uintptr {
+		var fds []uintptr
+		for i := uintptr(0); i < 100; i++ {
+			if fdtest.Exists(i) {
+				fds = append(fds, i)
 			}
-			lsof, err := exec.Command("lsof", "-b", "-n", "-p", strconv.Itoa(os.Getpid())).Output()
-			return bytes.Count(lsof, []byte("\n")), lsof, err
-		}
-
-		// lsof may see file descriptors associated with the fork itself,
-		// so we allow some extra margin if we have to use it.
-		// https://golang.org/issue/19243
-		tolerance = 5
-
-		// Retry reading the number of open file descriptors.
-		want, before, err = numOpenFDs()
-		if err != nil {
-			t.Log(err)
-			t.Skipf("skipping test; error finding or running lsof")
 		}
+		return fds
 	}
 
+	want := openFDs()
 	for i := 0; i < 6; i++ {
 		cmd := exec.Command("something-that-does-not-exist-executable")
 		cmd.StdoutPipe()
@@ -430,59 +387,10 @@ func TestPipeLookPathLeak(t *testing.T) {
 			t.Fatal("unexpected success")
 		}
 	}
-	got, after, err := numOpenFDs()
-	if err != nil {
-		// numOpenFDs has already succeeded once, it should work here.
-		t.Errorf("unexpected failure: %v", err)
+	got := openFDs()
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("set of open file descriptors changed: got %v, want %v", got, want)
 	}
-	if got-want > tolerance {
-		t.Errorf("number of open file descriptors changed: got %v, want %v", got, want)
-		if before != nil {
-			t.Errorf("before:\n%v\n", before)
-		}
-		if after != nil {
-			t.Errorf("after:\n%v\n", after)
-		}
-	}
-}
-
-func numOpenFDsAndroid(t *testing.T) (n int, lsof []byte) {
-	raw, err := exec.Command("lsof").Output()
-	if err != nil {
-		t.Skip("skipping test; error finding or running lsof")
-	}
-
-	// First find the PID column index by parsing the first line, and
-	// select lines containing pid in the column.
-	pid := []byte(strconv.Itoa(os.Getpid()))
-	pidCol := -1
-
-	s := bufio.NewScanner(bytes.NewReader(raw))
-	for s.Scan() {
-		line := s.Bytes()
-		fields := bytes.Fields(line)
-		if pidCol < 0 {
-			for i, v := range fields {
-				if bytes.Equal(v, []byte("PID")) {
-					pidCol = i
-					break
-				}
-			}
-			lsof = append(lsof, line...)
-			continue
-		}
-		if bytes.Equal(fields[pidCol], pid) {
-			lsof = append(lsof, '\n')
-			lsof = append(lsof, line...)
-		}
-	}
-	if pidCol < 0 {
-		t.Fatal("error processing lsof output: unexpected header format")
-	}
-	if err := s.Err(); err != nil {
-		t.Fatalf("error processing lsof output: %v", err)
-	}
-	return bytes.Count(lsof, []byte("\n")), lsof
 }
 
 func TestExtraFilesFDShuffle(t *testing.T) {
diff --git a/src/os/exec/internal/fdtest/exists_js.go b/src/os/exec/internal/fdtest/exists_js.go
new file mode 100644
index 0000000000..a7ce33c74f
--- /dev/null
+++ b/src/os/exec/internal/fdtest/exists_js.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.
+
+//go:build js
+
+package fdtest
+
+import (
+	"syscall"
+)
+
+// Exists returns true if fd is a valid file descriptor.
+func Exists(fd uintptr) bool {
+	var s syscall.Stat_t
+	err := syscall.Fstat(int(fd), &s)
+	return err != syscall.EBADF
+}
diff --git a/src/os/exec/internal/fdtest/exists_plan9.go b/src/os/exec/internal/fdtest/exists_plan9.go
new file mode 100644
index 0000000000..8886e06027
--- /dev/null
+++ b/src/os/exec/internal/fdtest/exists_plan9.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.
+
+//go:build plan9
+
+package fdtest
+
+import (
+	"syscall"
+)
+
+const errBadFd = syscall.ErrorString("fd out of range or not open")
+
+// Exists returns true if fd is a valid file descriptor.
+func Exists(fd uintptr) bool {
+	var buf [1]byte
+	_, err := syscall.Fstat(int(fd), buf[:])
+	return err != errBadFd
+}
diff --git a/src/os/exec/internal/fdtest/exists_test.go b/src/os/exec/internal/fdtest/exists_test.go
new file mode 100644
index 0000000000..a02dddf7f7
--- /dev/null
+++ b/src/os/exec/internal/fdtest/exists_test.go
@@ -0,0 +1,21 @@
+// 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 fdtest
+
+import (
+	"os"
+	"runtime"
+	"testing"
+)
+
+func TestExists(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("Exists not implemented for windows")
+	}
+
+	if !Exists(os.Stdout.Fd()) {
+		t.Errorf("Exists(%d) got false want true", os.Stdout.Fd())
+	}
+}
diff --git a/src/os/exec/internal/fdtest/exists_unix.go b/src/os/exec/internal/fdtest/exists_unix.go
new file mode 100644
index 0000000000..49f264cebd
--- /dev/null
+++ b/src/os/exec/internal/fdtest/exists_unix.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.
+
+//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
+
+// Package fdtest provides test helpers for working with file descriptors across exec.
+package fdtest
+
+import (
+	"syscall"
+)
+
+// Exists returns true if fd is a valid file descriptor.
+func Exists(fd uintptr) bool {
+	var s syscall.Stat_t
+	err := syscall.Fstat(int(fd), &s)
+	return err != syscall.EBADF
+}
diff --git a/src/os/exec/internal/fdtest/exists_windows.go b/src/os/exec/internal/fdtest/exists_windows.go
new file mode 100644
index 0000000000..72b8ccfd23
--- /dev/null
+++ b/src/os/exec/internal/fdtest/exists_windows.go
@@ -0,0 +1,12 @@
+// 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.
+
+//go:build windows
+
+package fdtest
+
+// Exists is not implemented on windows and panics.
+func Exists(fd uintptr) bool {
+	panic("unimplemented")
+}
diff --git a/src/os/exec/read3.go b/src/os/exec/read3.go
index 8aae5735c4..10cbfbd54a 100644
--- a/src/os/exec/read3.go
+++ b/src/os/exec/read3.go
@@ -18,12 +18,15 @@ import (
 	"io"
 	"os"
 	"os/exec"
+	"os/exec/internal/fdtest"
 	"runtime"
 	"strings"
 )
 
 func main() {
 	fd3 := os.NewFile(3, "fd3")
+	defer fd3.Close()
+
 	bs, err := io.ReadAll(fd3)
 	if err != nil {
 		fmt.Printf("ReadAll from fd 3: %v\n", err)
@@ -37,65 +40,52 @@ func main() {
 	// descriptor from parent == 3
 	// All descriptors 4 and up should be available,
 	// except for any used by the network poller.
-	var files []*os.File
-	for wantfd := uintptr(4); wantfd <= 100; wantfd++ {
-		if poll.IsPollDescriptor(wantfd) {
+	for fd := uintptr(4); fd <= 100; fd++ {
+		if poll.IsPollDescriptor(fd) {
 			continue
 		}
-		f, err := os.Open(os.Args[0])
+
+		if !fdtest.Exists(fd) {
+			continue
+		}
+
+		fmt.Printf("leaked parent file. fdtest.Exists(%d) got true want false\n", fd)
+
+		fdfile := fmt.Sprintf("/proc/self/fd/%d", fd)
+		link, err := os.Readlink(fdfile)
+		fmt.Printf("readlink(%q) = %q, %v\n", fdfile, link, err)
+
+		var args []string
+		switch runtime.GOOS {
+		case "plan9":
+			args = []string{fmt.Sprintf("/proc/%d/fd", os.Getpid())}
+		case "aix", "solaris", "illumos":
+			args = []string{fmt.Sprint(os.Getpid())}
+		default:
+			args = []string{"-p", fmt.Sprint(os.Getpid())}
+		}
+
+		// Determine which command to use to display open files.
+		ofcmd := "lsof"
+		switch runtime.GOOS {
+		case "dragonfly", "freebsd", "netbsd", "openbsd":
+			ofcmd = "fstat"
+		case "plan9":
+			ofcmd = "/bin/cat"
+		case "aix":
+			ofcmd = "procfiles"
+		case "solaris", "illumos":
+			ofcmd = "pfiles"
+		}
+
+		cmd := exec.Command(ofcmd, args...)
+		out, err := cmd.CombinedOutput()
 		if err != nil {
-			fmt.Printf("error opening file with expected fd %d: %v", wantfd, err)
-			os.Exit(1)
+			fmt.Fprintf(os.Stderr, "%s failed: %v\n", strings.Join(cmd.Args, " "), err)
 		}
-		if got := f.Fd(); got != wantfd {
-			fmt.Printf("leaked parent file. fd = %d; want %d\n", got, wantfd)
-			fdfile := fmt.Sprintf("/proc/self/fd/%d", wantfd)
-			link, err := os.Readlink(fdfile)
-			fmt.Printf("readlink(%q) = %q, %v\n", fdfile, link, err)
-			var args []string
-			switch runtime.GOOS {
-			case "plan9":
-				args = []string{fmt.Sprintf("/proc/%d/fd", os.Getpid())}
-			case "aix", "solaris", "illumos":
-				args = []string{fmt.Sprint(os.Getpid())}
-			default:
-				args = []string{"-p", fmt.Sprint(os.Getpid())}
-			}
-
-			// Determine which command to use to display open files.
-			ofcmd := "lsof"
-			switch runtime.GOOS {
-			case "dragonfly", "freebsd", "netbsd", "openbsd":
-				ofcmd = "fstat"
-			case "plan9":
-				ofcmd = "/bin/cat"
-			case "aix":
-				ofcmd = "procfiles"
-			case "solaris", "illumos":
-				ofcmd = "pfiles"
-			}
-
-			cmd := exec.Command(ofcmd, args...)
-			out, err := cmd.CombinedOutput()
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "%s failed: %v\n", strings.Join(cmd.Args, " "), err)
-			}
-			fmt.Printf("%s", out)
-			os.Exit(1)
-		}
-		files = append(files, f)
+		fmt.Printf("%s", out)
+		os.Exit(1)
 	}
 
-	for _, f := range files {
-		f.Close()
-	}
-
-	// Referring to fd3 here ensures that it is not
-	// garbage collected, and therefore closed, while
-	// executing the wantfd loop above. It doesn't matter
-	// what we do with fd3 as long as we refer to it;
-	// closing it is the easy choice.
-	fd3.Close()
-
 	os.Stdout.Write(bs)
 }

From 5e59d6ebd110a7c19770c7d996930ff379ba5726 Mon Sep 17 00:00:00 2001
From: jiahua wang 
Date: Wed, 22 Sep 2021 07:59:11 +0800
Subject: [PATCH 195/752] sort: improve sort documentation

Fixes #48527

Change-Id: Ib5df0819cbcd5c2e4f03bda841871d237af96b19
Reviewed-on: https://go-review.googlesource.com/c/go/+/351336
Reviewed-by: Rob Pike 
Reviewed-by: Ian Lance Taylor 
---
 src/sort/sort.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/sort/sort.go b/src/sort/sort.go
index cbaa8c3aac..749310764a 100644
--- a/src/sort/sort.go
+++ b/src/sort/sort.go
@@ -223,7 +223,7 @@ func quickSort(data Interface, a, b, maxDepth int) {
 	}
 }
 
-// Sort sorts data.
+// Sort sorts data in ascending order as determined by the Less method.
 // It makes one call to data.Len to determine n and O(n*log(n)) calls to
 // data.Less and data.Swap. The sort is not guaranteed to be stable.
 func Sort(data Interface) {
@@ -370,7 +370,8 @@ func StringsAreSorted(x []string) bool { return IsSorted(StringSlice(x)) }
 //  - Often "optimal" algorithms are optimal in the number of assignments
 //    but Interface has only Swap as operation.
 
-// Stable sorts data while keeping the original order of equal elements.
+// Stable sorts data in ascending order as determined by the Less method,
+// while keeping the original order of equal elements.
 //
 // It makes one call to data.Len to determine n, O(n*log(n)) calls to
 // data.Less and O(n*log(n)*log(n)) calls to data.Swap.

From 01b6cf09fc9f272d9db3d30b4c93982f4911d120 Mon Sep 17 00:00:00 2001
From: Keith Randall 
Date: Mon, 15 Nov 2021 15:56:39 -0800
Subject: [PATCH 196/752] runtime: check GOAMD64 compatibility after setting up
 TLS
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

We need TLS set up to be able to print an error without crashing.

Fixes #49586
Update #45453

Change-Id: I97f0efcd716a8dca614e82ab73f2d855b7277599
Reviewed-on: https://go-review.googlesource.com/c/go/+/364174
Run-TryBot: Keith Randall 
TryBot-Result: Go Bot 
Reviewed-by: Martin Möhrmann 
Trust: Martin Möhrmann 
Trust: Keith Randall 
---
 src/runtime/asm_amd64.s | 136 +++++++++++++++++++---------------------
 1 file changed, 64 insertions(+), 72 deletions(-)

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index 0f0e5be21a..c08ae610fb 100644
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -145,28 +145,14 @@ GLOBL bad_cpu_msg<>(SB), RODATA, $84
 
 #endif
 
-#ifdef GOAMD64_v1
-#define SKIP_GOAMD64_CHECK
-#endif
-
-#ifndef GOAMD64_v1
-#ifndef GOAMD64_v2
-#ifndef GOAMD64_v3
-#ifndef GOAMD64_v4
-#define SKIP_GOAMD64_CHECK
-#endif
-#endif
-#endif
-#endif
-
 TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
 	// copy arguments forward on an even stack
 	MOVQ	DI, AX		// argc
 	MOVQ	SI, BX		// argv
-	SUBQ	$(4*8+7), SP		// 2args 2auto
+	SUBQ	$(5*8), SP		// 3args 2auto
 	ANDQ	$~15, SP
-	MOVQ	AX, 16(SP)
-	MOVQ	BX, 24(SP)
+	MOVQ	AX, 24(SP)
+	MOVQ	BX, 32(SP)
 
 	// create istack out of the given (operating system) stack.
 	// _cgo_init may update stackguard.
@@ -181,23 +167,8 @@ TEXT runtime·rt0_go(SB),NOSPLIT|TOPFRAME,$0
 	MOVL	$0, AX
 	CPUID
 	CMPL	AX, $0
-#ifdef SKIP_GOAMD64_CHECK
 	JE	nocpuinfo
-#else
-	JNE	has_cpuinfo
 
-bad_cpu: // show that the program requires a certain microarchitecture level.
-	MOVQ	$2, 0(SP)
-	MOVQ	$bad_cpu_msg<>(SB), AX
-	MOVQ	AX, 8(SP)
-	MOVQ	$84, 16(SP)
-	CALL	runtime·write(SB)
-	MOVQ	$1, 0(SP)
-	CALL	runtime·exit(SB)
-	CALL	runtime·abort(SB)
-#endif
-
-has_cpuinfo:
 	CMPL	BX, $0x756E6547  // "Genu"
 	JNE	notintel
 	CMPL	DX, $0x49656E69  // "ineI"
@@ -212,44 +183,6 @@ notintel:
 	CPUID
 	MOVL	AX, runtime·processorVersionInfo(SB)
 
-#ifdef NEED_FEATURES_CX
-	ANDL	$NEED_FEATURES_CX, CX
-	CMPL	CX, $NEED_FEATURES_CX
-	JNE	bad_cpu
-#endif
-
-#ifdef NEED_MAX_CPUID
-	MOVL	$0x80000000, AX
-	CPUID
-	CMPL	AX, $NEED_MAX_CPUID
-	JL	bad_cpu
-#endif
-
-#ifdef NEED_EXT_FEATURES_BX
-	MOVL	$7, AX
-	MOVL	$0, CX
-	CPUID
-	ANDL	$NEED_EXT_FEATURES_BX, BX
-	CMPL	BX, $NEED_EXT_FEATURES_BX
-	JNE	bad_cpu
-#endif
-
-#ifdef NEED_EXT_FEATURES_CX
-	MOVL	$0x80000001, AX
-	CPUID
-	ANDL	$NEED_EXT_FEATURES_CX, CX
-	CMPL	CX, $NEED_EXT_FEATURES_CX
-	JNE	bad_cpu
-#endif
-
-#ifdef NEED_OS_SUPPORT_AX
-	XORL    CX, CX
-	XGETBV
-	ANDL	$NEED_OS_SUPPORT_AX, AX
-	CMPL	AX, $NEED_OS_SUPPORT_AX
-	JNE	bad_cpu
-#endif
-
 nocpuinfo:
 	// if there is an _cgo_init, call it.
 	MOVQ	_cgo_init(SB), AX
@@ -330,11 +263,59 @@ ok:
 	MOVQ	AX, g_m(CX)
 
 	CLD				// convention is D is always left cleared
+
+	// Check GOAMD64 reqirements
+	// We need to do this after setting up TLS, so that
+	// we can report an error if there is a failure. See issue 49586.
+#ifdef NEED_FEATURES_CX
+	MOVL	$0, AX
+	CPUID
+	CMPL	AX, $0
+	JE	bad_cpu
+	MOVL	$1, AX
+	CPUID
+	ANDL	$NEED_FEATURES_CX, CX
+	CMPL	CX, $NEED_FEATURES_CX
+	JNE	bad_cpu
+#endif
+
+#ifdef NEED_MAX_CPUID
+	MOVL	$0x80000000, AX
+	CPUID
+	CMPL	AX, $NEED_MAX_CPUID
+	JL	bad_cpu
+#endif
+
+#ifdef NEED_EXT_FEATURES_BX
+	MOVL	$7, AX
+	MOVL	$0, CX
+	CPUID
+	ANDL	$NEED_EXT_FEATURES_BX, BX
+	CMPL	BX, $NEED_EXT_FEATURES_BX
+	JNE	bad_cpu
+#endif
+
+#ifdef NEED_EXT_FEATURES_CX
+	MOVL	$0x80000001, AX
+	CPUID
+	ANDL	$NEED_EXT_FEATURES_CX, CX
+	CMPL	CX, $NEED_EXT_FEATURES_CX
+	JNE	bad_cpu
+#endif
+
+#ifdef NEED_OS_SUPPORT_AX
+	XORL    CX, CX
+	XGETBV
+	ANDL	$NEED_OS_SUPPORT_AX, AX
+	CMPL	AX, $NEED_OS_SUPPORT_AX
+	JNE	bad_cpu
+#endif
+
 	CALL	runtime·check(SB)
 
-	MOVL	16(SP), AX		// copy argc
+	MOVL	24(SP), AX		// copy argc
 	MOVL	AX, 0(SP)
-	MOVQ	24(SP), AX		// copy argv
+	MOVQ	32(SP), AX		// copy argv
 	MOVQ	AX, 8(SP)
 	CALL	runtime·args(SB)
 	CALL	runtime·osinit(SB)
@@ -352,6 +333,17 @@ ok:
 	CALL	runtime·abort(SB)	// mstart should never return
 	RET
 
+bad_cpu: // show that the program requires a certain microarchitecture level.
+	MOVQ	$2, 0(SP)
+	MOVQ	$bad_cpu_msg<>(SB), AX
+	MOVQ	AX, 8(SP)
+	MOVQ	$84, 16(SP)
+	CALL	runtime·write(SB)
+	MOVQ	$1, 0(SP)
+	CALL	runtime·exit(SB)
+	CALL	runtime·abort(SB)
+	RET
+
 	// Prevent dead-code elimination of debugCallV2, which is
 	// intended to be called by debuggers.
 	MOVQ	$runtime·debugCallV2(SB), AX

From a2b8231b91e8c4c9e95875b8063bf364f5b0db97 Mon Sep 17 00:00:00 2001
From: Josh Bleecher Snyder 
Date: Tue, 16 Nov 2021 13:01:57 -0800
Subject: [PATCH 197/752] runtime: remove defer test log spam

This appears to be leftover debugging
from CL 356011.

Change-Id: Ieeda0b7e297e0cb943827b28644135e6cad12e3c
Reviewed-on: https://go-review.googlesource.com/c/go/+/364555
Trust: Josh Bleecher Snyder 
Trust: Dan Scales 
Run-TryBot: Josh Bleecher Snyder 
Reviewed-by: Michael Pratt 
Reviewed-by: Dan Scales 
TryBot-Result: Go Bot 
---
 src/runtime/defer_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/runtime/defer_test.go b/src/runtime/defer_test.go
index 1d5745d60b..821db0ca12 100644
--- a/src/runtime/defer_test.go
+++ b/src/runtime/defer_test.go
@@ -467,7 +467,6 @@ func TestIssue43920(t *testing.T) {
 }
 
 func step(t *testing.T, steps *int, want int) {
-	println("step", want)
 	*steps++
 	if *steps != want {
 		t.Fatalf("have %v, want %v", *steps, want)

From 3d7cb23e3d5e7880d582f1b0300064bd1138f3ee Mon Sep 17 00:00:00 2001
From: Than McIntosh 
Date: Tue, 16 Nov 2021 18:44:08 -0500
Subject: [PATCH 198/752] cmd/compile: emit definition of 'any' when compiling
 runtime

Include the predefined type 'any' in the list of other important
predefined types that are emitted when compiling the runtime package
(uintptr, string, etc).

Fixes #49619.

Change-Id: I4a851ba2f302fbc3a425e65daa325c6bf83659da
Reviewed-on: https://go-review.googlesource.com/c/go/+/364377
Trust: Than McIntosh 
Trust: Dan Scales 
Run-TryBot: Than McIntosh 
TryBot-Result: Go Bot 
Reviewed-by: Dan Scales 
---
 .../compile/internal/reflectdata/reflect.go   |  1 +
 test/fixedbugs/issue49619.go                  | 19 +++++++++++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 test/fixedbugs/issue49619.go

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index 4e20dbf29e..e22fabb410 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1384,6 +1384,7 @@ func WriteBasicTypes() {
 		}
 		writeType(types.NewPtr(types.Types[types.TSTRING]))
 		writeType(types.NewPtr(types.Types[types.TUNSAFEPTR]))
+		writeType(types.AnyType)
 
 		// emit type structs for error and func(error) string.
 		// The latter is the type of an auto-generated wrapper.
diff --git a/test/fixedbugs/issue49619.go b/test/fixedbugs/issue49619.go
new file mode 100644
index 0000000000..c9f3cbc4ad
--- /dev/null
+++ b/test/fixedbugs/issue49619.go
@@ -0,0 +1,19 @@
+// build
+
+// 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.
+
+// This testcase caused a linker crash in DWARF generation.
+
+package main
+
+//go:noinline
+func f() any {
+	var a []any
+	return a[0]
+}
+
+func main() {
+	f()
+}

From f384c707ac3dd946e3c895d0f4e154744048ef36 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 16 Nov 2021 17:02:11 -0800
Subject: [PATCH 199/752] cmd/compile/internal/types2: tweaks to ArgumentError
 to be more idiomatic

This CL is a clean port of CL 351335 from go/types to types2.

Updates #47916

Change-Id: Idc377fb71d480a51d5e93a348f3a880346011974
Reviewed-on: https://go-review.googlesource.com/c/go/+/364535
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/api.go         | 13 +++++--------
 src/cmd/compile/internal/types2/api_test.go    | 11 ++++++++---
 src/cmd/compile/internal/types2/instantiate.go |  6 +++---
 3 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index 83c4b02abf..367cb8f700 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -55,17 +55,14 @@ func (err Error) FullError() string {
 	return fmt.Sprintf("%s: %s", err.Pos, err.Full)
 }
 
-// An ArgumentError holds an error that is associated with an argument.
+// An ArgumentError holds an error associated with an argument index.
 type ArgumentError struct {
-	index int
-	error
+	Index int
+	Err   error
 }
 
-// Index returns the positional index of the argument associated with the
-// error.
-func (e ArgumentError) Index() int {
-	return e.index
-}
+func (e *ArgumentError) Error() string { return e.Err.Error() }
+func (e *ArgumentError) Unwrap() error { return e.Err }
 
 // An Importer resolves import paths to Packages.
 //
diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 866ebb8684..7ec1063843 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -7,6 +7,7 @@ package types2_test
 import (
 	"bytes"
 	"cmd/compile/internal/syntax"
+	"errors"
 	"fmt"
 	"internal/testenv"
 	"reflect"
@@ -2002,9 +2003,13 @@ func TestInstantiateErrors(t *testing.T) {
 			t.Fatalf("Instantiate(%v, %v) returned nil error, want non-nil", T, test.targs)
 		}
 
-		gotAt := err.(ArgumentError).Index()
-		if gotAt != test.wantAt {
-			t.Errorf("Instantate(%v, %v): error at index %d, want index %d", T, test.targs, gotAt, test.wantAt)
+		var argErr *ArgumentError
+		if !errors.As(err, &argErr) {
+			t.Fatalf("Instantiate(%v, %v): error is not an *ArgumentError", T, test.targs)
+		}
+
+		if argErr.Index != test.wantAt {
+			t.Errorf("Instantate(%v, %v): error at index %d, want index %d", T, test.targs, argErr.Index, test.wantAt)
 		}
 	}
 }
diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index 299d63dc60..09ca1b7c16 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -24,8 +24,8 @@ import (
 // instances with the same identity.
 //
 // If verify is set and constraint satisfaction fails, the returned error may
-// be of dynamic type ArgumentError indicating which type argument did not
-// satisfy its corresponding type parameter constraint, and why.
+// wrap an *ArgumentError indicating which type argument did not satisfy its
+// corresponding type parameter constraint, and why.
 //
 // TODO(rfindley): change this function to also return an error if lengths of
 // tparams and targs do not match.
@@ -42,7 +42,7 @@ func Instantiate(ctxt *Context, typ Type, targs []Type, validate bool) (Type, er
 			tparams = t.TypeParams().list()
 		}
 		if i, err := (*Checker)(nil).verify(nopos, tparams, targs); err != nil {
-			return inst, ArgumentError{i, err}
+			return inst, &ArgumentError{i, err}
 		}
 	}
 

From fceca2c0f1ff21e1b2b0bf9960b776bb08e58d86 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 16 Nov 2021 17:30:47 -0800
Subject: [PATCH 200/752] cmd/compile/internal/types2: add a test for argument
 error unwrapping

This CL is a clean port of CL 351338 from go/types to types2.

Change-Id: I7fd0e5a447bf51cb359e71731c2f9b95e3960da6
Reviewed-on: https://go-review.googlesource.com/c/go/+/364536
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/api_test.go | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 7ec1063843..ca90e6b97d 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -2014,6 +2014,20 @@ func TestInstantiateErrors(t *testing.T) {
 	}
 }
 
+func TestArgumentErrorUnwrapping(t *testing.T) {
+	var err error = &ArgumentError{
+		Index: 1,
+		Err:   Error{Msg: "test"},
+	}
+	var e Error
+	if !errors.As(err, &e) {
+		t.Fatalf("error %v does not wrap types.Error", err)
+	}
+	if e.Msg != "test" {
+		t.Errorf("e.Msg = %q, want %q", e.Msg, "test")
+	}
+}
+
 func TestInstanceIdentity(t *testing.T) {
 	imports := make(testImporter)
 	conf := Config{Importer: imports}

From a17a21c190c3e3ea8e88af3e89ccb3c2f101c35b Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 16 Nov 2021 08:22:53 -0800
Subject: [PATCH 201/752] cmd/compile/internal/types2: deduplicate signatures
 with the context

This CL is a mostly clean port of CL 362801 from go/types to types2.
It deviates from go/types in some of the testing code because types2
already had made some of the changes.

It also re-introduces some empty lines that got lost in earlier CLs.

Change-Id: I0bebd68f0880fac61631a5d0c323a9f8ce853ac6
Reviewed-on: https://go-review.googlesource.com/c/go/+/364335
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/context.go    |  41 ++++---
 .../compile/internal/types2/instantiate.go    |  43 +++----
 .../internal/types2/instantiate_test.go       | 107 +++++++++++++++---
 src/cmd/compile/internal/types2/named.go      |   2 +-
 src/cmd/compile/internal/types2/subst.go      |   2 +-
 src/cmd/compile/internal/types2/typestring.go |   2 +-
 src/cmd/compile/internal/types2/typexpr.go    |   2 +-
 7 files changed, 140 insertions(+), 59 deletions(-)

diff --git a/src/cmd/compile/internal/types2/context.go b/src/cmd/compile/internal/types2/context.go
index 93a0cb8d40..7abea6b654 100644
--- a/src/cmd/compile/internal/types2/context.go
+++ b/src/cmd/compile/internal/types2/context.go
@@ -1,11 +1,13 @@
 // 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 types2
 
 import (
 	"bytes"
 	"fmt"
+	"strconv"
 	"strings"
 	"sync"
 )
@@ -16,10 +18,10 @@ import (
 //
 // It is safe for concurrent use.
 type Context struct {
-	mu      sync.Mutex
-	typeMap map[string][]ctxtEntry // type hash -> instances entries
-	nextID  int                    // next unique ID
-	seen    map[*Named]int         // assigned unique IDs
+	mu        sync.Mutex
+	typeMap   map[string][]ctxtEntry // type hash -> instances entries
+	nextID    int                    // next unique ID
+	originIDs map[Type]int           // origin type -> unique ID
 }
 
 type ctxtEntry struct {
@@ -31,23 +33,25 @@ type ctxtEntry struct {
 // NewContext creates a new Context.
 func NewContext() *Context {
 	return &Context{
-		typeMap: make(map[string][]ctxtEntry),
-		seen:    make(map[*Named]int),
+		typeMap:   make(map[string][]ctxtEntry),
+		originIDs: make(map[Type]int),
 	}
 }
 
-// typeHash returns a string representation of typ instantiated with targs,
-// which can be used as an exact type hash: types that are identical produce
-// identical string representations. If targs is not empty, typ is printed as
-// if it were instantiated with targs. The result is guaranteed to not contain
-// blanks (" ").
-func (ctxt *Context) typeHash(typ Type, targs []Type) string {
+// instanceHash returns a string representation of typ instantiated with targs.
+// The hash should be a perfect hash, though out of caution the type checker
+// does not assume this. The result is guaranteed to not contain blanks.
+func (ctxt *Context) instanceHash(orig Type, targs []Type) string {
 	assert(ctxt != nil)
-	assert(typ != nil)
+	assert(orig != nil)
 	var buf bytes.Buffer
 
 	h := newTypeHasher(&buf, ctxt)
-	h.typ(typ)
+	h.string(strconv.Itoa(ctxt.getID(orig)))
+	// Because we've already written the unique origin ID this call to h.typ is
+	// unnecessary, but we leave it for hash readability. It can be removed later
+	// if performance is an issue.
+	h.typ(orig)
 	if len(targs) > 0 {
 		// TODO(rfindley): consider asserting on isGeneric(typ) here, if and when
 		// isGeneric handles *Signature types.
@@ -82,6 +86,7 @@ func (ctxt *Context) lookup(h string, orig Type, targs []Type) Type {
 // h.
 func (ctxt *Context) update(h string, orig Type, targs []Type, inst Type) Type {
 	assert(inst != nil)
+
 	ctxt.mu.Lock()
 	defer ctxt.mu.Unlock()
 
@@ -104,14 +109,14 @@ func (ctxt *Context) update(h string, orig Type, targs []Type, inst Type) Type {
 	return inst
 }
 
-// idForType returns a unique ID for the pointer n.
-func (ctxt *Context) idForType(n *Named) int {
+// getID returns a unique ID for the type t.
+func (ctxt *Context) getID(t Type) int {
 	ctxt.mu.Lock()
 	defer ctxt.mu.Unlock()
-	id, ok := ctxt.seen[n]
+	id, ok := ctxt.originIDs[t]
 	if !ok {
 		id = ctxt.nextID
-		ctxt.seen[n] = id
+		ctxt.originIDs[t] = id
 		ctxt.nextID++
 	}
 	return id
diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index 09ca1b7c16..35fcc7c040 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -52,30 +52,26 @@ func Instantiate(ctxt *Context, typ Type, targs []Type, validate bool) (Type, er
 // instance creates a type or function instance using the given original type
 // typ and arguments targs. For Named types the resulting instance will be
 // unexpanded.
-func (check *Checker) instance(pos syntax.Pos, orig Type, targs []Type, ctxt *Context) Type {
+func (check *Checker) instance(pos syntax.Pos, orig Type, targs []Type, ctxt *Context) (res Type) {
+	var h string
+	if ctxt != nil {
+		h = ctxt.instanceHash(orig, targs)
+		// typ may already have been instantiated with identical type arguments. In
+		// that case, re-use the existing instance.
+		if inst := ctxt.lookup(h, orig, targs); inst != nil {
+			return inst
+		}
+	}
+
 	switch orig := orig.(type) {
 	case *Named:
-		var h string
-		if ctxt != nil {
-			h = ctxt.typeHash(orig, targs)
-			// typ may already have been instantiated with identical type arguments. In
-			// that case, re-use the existing instance.
-			if inst := ctxt.lookup(h, orig, targs); inst != nil {
-				return inst
-			}
-		}
 		tname := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil)
 		named := check.newNamed(tname, orig, nil, nil, nil) // underlying, tparams, and methods are set when named is resolved
 		named.targs = NewTypeList(targs)
 		named.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) {
 			return expandNamed(ctxt, n, pos)
 		}
-		if ctxt != nil {
-			// It's possible that we've lost a race to add named to the context.
-			// In this case, use whichever instance is recorded in the context.
-			named = ctxt.update(h, orig, targs, named).(*Named)
-		}
-		return named
+		res = named
 
 	case *Signature:
 		tparams := orig.TypeParams()
@@ -96,10 +92,19 @@ func (check *Checker) instance(pos syntax.Pos, orig Type, targs []Type, ctxt *Co
 		// After instantiating a generic signature, it is not generic
 		// anymore; we need to set tparams to nil.
 		sig.tparams = nil
-		return sig
+		res = sig
+	default:
+		// only types and functions can be generic
+		panic(fmt.Sprintf("%v: cannot instantiate %v", pos, orig))
 	}
-	// only types and functions can be generic
-	panic(fmt.Sprintf("%v: cannot instantiate %v", pos, orig))
+
+	if ctxt != nil {
+		// It's possible that we've lost a race to add named to the context.
+		// In this case, use whichever instance is recorded in the context.
+		res = ctxt.update(h, orig, targs, res)
+	}
+
+	return res
 }
 
 // validateTArgLen verifies that the length of targs and tparams matches,
diff --git a/src/cmd/compile/internal/types2/instantiate_test.go b/src/cmd/compile/internal/types2/instantiate_test.go
index 4f10dd929f..289fe98fd2 100644
--- a/src/cmd/compile/internal/types2/instantiate_test.go
+++ b/src/cmd/compile/internal/types2/instantiate_test.go
@@ -10,27 +10,98 @@ import (
 )
 
 func TestInstantiateEquality(t *testing.T) {
-	const src = "package p; type T[P any] int"
-	pkg, err := pkgFor(".", src, nil)
-	if err != nil {
-		t.Fatal(err)
+	tests := []struct {
+		src       string
+		name1     string
+		targs1    []Type
+		name2     string
+		targs2    []Type
+		wantEqual bool
+	}{
+		{
+			"package basictype; type T[P any] int",
+			"T", []Type{Typ[Int]},
+			"T", []Type{Typ[Int]},
+			true,
+		},
+		{
+			"package differenttypeargs; type T[P any] int",
+			"T", []Type{Typ[Int]},
+			"T", []Type{Typ[String]},
+			false,
+		},
+		{
+			"package typeslice; type T[P any] int",
+			"T", []Type{NewSlice(Typ[Int])},
+			"T", []Type{NewSlice(Typ[Int])},
+			true,
+		},
+		{
+			"package basicfunc; func F[P any]() {}",
+			"F", []Type{Typ[Int]},
+			"F", []Type{Typ[Int]},
+			true,
+		},
+		{
+			"package funcslice; func F[P any]() {}",
+			"F", []Type{NewSlice(Typ[Int])},
+			"F", []Type{NewSlice(Typ[Int])},
+			true,
+		},
+		{
+			"package funcwithparams; func F[P any](x string) float64 { return 0 }",
+			"F", []Type{Typ[Int]},
+			"F", []Type{Typ[Int]},
+			true,
+		},
+		{
+			"package differentfuncargs; func F[P any](x string) float64 { return 0 }",
+			"F", []Type{Typ[Int]},
+			"F", []Type{Typ[String]},
+			false,
+		},
+		{
+			"package funcequality; func F1[P any](x int) {}; func F2[Q any](x int) {}",
+			"F1", []Type{Typ[Int]},
+			"F2", []Type{Typ[Int]},
+			false,
+		},
+		{
+			"package funcsymmetry; func F1[P any](x P) {}; func F2[Q any](x Q) {}",
+			"F1", []Type{Typ[Int]},
+			"F2", []Type{Typ[Int]},
+			false,
+		},
 	}
-	T := pkg.Scope().Lookup("T").Type().(*Named)
-	// Instantiating the same type twice should result in pointer-equivalent
-	// instances.
-	ctxt := NewContext()
-	res1, err := Instantiate(ctxt, T, []Type{Typ[Int]}, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	res2, err := Instantiate(ctxt, T, []Type{Typ[Int]}, false)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res1 != res2 {
-		t.Errorf("first instance (%s) not pointer-equivalent to second instance (%s)", res1, res2)
+
+	for _, test := range tests {
+		pkg, err := pkgFor(".", test.src, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		t.Run(pkg.Name(), func(t *testing.T) {
+			ctxt := NewContext()
+
+			T1 := pkg.Scope().Lookup(test.name1).Type()
+			res1, err := Instantiate(ctxt, T1, test.targs1, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			T2 := pkg.Scope().Lookup(test.name2).Type()
+			res2, err := Instantiate(ctxt, T2, test.targs2, false)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if gotEqual := res1 == res2; gotEqual != test.wantEqual {
+				t.Errorf("%s == %s: %t, want %t", res1, res2, gotEqual, test.wantEqual)
+			}
+		})
 	}
 }
+
 func TestInstantiateNonEquality(t *testing.T) {
 	const src = "package p; type T[P any] int"
 	pkg1, err := pkgFor(".", src, nil)
diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go
index e90c301a0d..a455489cd6 100644
--- a/src/cmd/compile/internal/types2/named.go
+++ b/src/cmd/compile/internal/types2/named.go
@@ -251,7 +251,7 @@ func expandNamed(ctxt *Context, n *Named, instPos syntax.Pos) (tparams *TypePara
 	if n.orig.tparams.Len() == n.targs.Len() {
 		// We must always have a context, to avoid infinite recursion.
 		ctxt = check.bestContext(ctxt)
-		h := ctxt.typeHash(n.orig, n.targs.list())
+		h := ctxt.instanceHash(n.orig, n.targs.list())
 		// ensure that an instance is recorded for h to avoid infinite recursion.
 		ctxt.update(h, n.orig, n.TypeArgs().list(), n)
 
diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go
index 9b82f8889a..516f248127 100644
--- a/src/cmd/compile/internal/types2/subst.go
+++ b/src/cmd/compile/internal/types2/subst.go
@@ -207,7 +207,7 @@ func (subst *subster) typ(typ Type) Type {
 		}
 
 		// before creating a new named type, check if we have this one already
-		h := subst.ctxt.typeHash(t.orig, newTArgs)
+		h := subst.ctxt.instanceHash(t.orig, newTArgs)
 		dump(">>> new type hash: %s", h)
 		if named := subst.ctxt.lookup(h, t.orig, newTArgs); named != nil {
 			dump(">>> found %s", named)
diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
index 0c93a7e6e4..1857f58a4b 100644
--- a/src/cmd/compile/internal/types2/typestring.go
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -297,7 +297,7 @@ func (w *typeWriter) typ(typ Type) {
 // nothing.
 func (w *typeWriter) typePrefix(t *Named) {
 	if w.ctxt != nil {
-		w.string(strconv.Itoa(w.ctxt.idForType(t)))
+		w.string(strconv.Itoa(w.ctxt.getID(t)))
 	}
 }
 
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 4ba21fa9a0..0380c3461d 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -437,7 +437,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 	}
 
 	// create the instance
-	h := check.conf.Context.typeHash(orig, targs)
+	h := check.conf.Context.instanceHash(orig, targs)
 	// targs may be incomplete, and require inference. In any case we should de-duplicate.
 	inst, _ := check.conf.Context.lookup(h, orig, targs).(*Named)
 	// If inst is non-nil, we can't just return here. Inst may have been

From 489f58779ce073ef8f6b1505f80580211200ff60 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 16 Nov 2021 08:31:38 -0800
Subject: [PATCH 202/752] cmd/compile/internal/types2: when type hashing, use
 placeholders for type parameters

This is a port of CL 363114 from go/types to types2 with a temporary
work-around in tparamIndex to avoid a crash with the unified build
and test/typeparam/setsimp.go.

Change-Id: Id4805385f21c95b461911b246fb47ee278a84ac9
Reviewed-on: https://go-review.googlesource.com/c/go/+/364336
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/typestring.go | 55 +++++++++++--------
 src/cmd/compile/internal/types2/unify.go      |  7 +++
 2 files changed, 40 insertions(+), 22 deletions(-)

diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
index 1857f58a4b..ba3494d9d9 100644
--- a/src/cmd/compile/internal/types2/typestring.go
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -8,6 +8,7 @@ package types2
 
 import (
 	"bytes"
+	"fmt"
 	"strconv"
 	"unicode/utf8"
 )
@@ -70,20 +71,21 @@ func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier) {
 }
 
 type typeWriter struct {
-	buf   *bytes.Buffer
-	seen  map[Type]bool
-	qf    Qualifier
-	ctxt  *Context // if non-nil, we are type hashing
-	debug bool     // if true, write debug annotations
+	buf     *bytes.Buffer
+	seen    map[Type]bool
+	qf      Qualifier
+	ctxt    *Context       // if non-nil, we are type hashing
+	tparams *TypeParamList // local type parameters
+	debug   bool           // if true, write debug annotations
 }
 
 func newTypeWriter(buf *bytes.Buffer, qf Qualifier) *typeWriter {
-	return &typeWriter{buf, make(map[Type]bool), qf, nil, false}
+	return &typeWriter{buf, make(map[Type]bool), qf, nil, nil, false}
 }
 
 func newTypeHasher(buf *bytes.Buffer, ctxt *Context) *typeWriter {
 	assert(ctxt != nil)
-	return &typeWriter{buf, make(map[Type]bool), nil, ctxt, false}
+	return &typeWriter{buf, make(map[Type]bool), nil, ctxt, nil, false}
 }
 
 func (w *typeWriter) byte(b byte) {
@@ -265,12 +267,16 @@ func (w *typeWriter) typ(typ Type) {
 		}
 
 	case *Named:
-		w.typePrefix(t)
-		w.typeName(t.obj)
+		// If hashing, write a unique prefix for t to represent its identity, since
+		// named type identity is pointer identity.
+		if w.ctxt != nil {
+			w.string(strconv.Itoa(w.ctxt.getID(t)))
+		}
+		w.typeName(t.obj) // when hashing written for readability of the hash only
 		if t.targs != nil {
 			// instantiated type
 			w.typeList(t.targs.list())
-		} else if w.ctxt == nil && t.TypeParams().Len() != 0 { // For type hashing, don't need to format the TParams
+		} else if w.ctxt == nil && t.TypeParams().Len() != 0 { // For type hashing, don't need to format the TypeParams
 			// parameterized type
 			w.tParamList(t.TypeParams().list())
 		}
@@ -280,9 +286,16 @@ func (w *typeWriter) typ(typ Type) {
 			w.error("unnamed type parameter")
 			break
 		}
-		w.string(t.obj.name)
-		if w.debug || w.ctxt != nil {
-			w.string(subscript(t.id))
+		if i := tparamIndex(w.tparams.list(), t); i >= 0 {
+			// The names of type parameters that are declared by the type being
+			// hashed are not part of the type identity. Replace them with a
+			// placeholder indicating their index.
+			w.string(fmt.Sprintf("$%d", i))
+		} else {
+			w.string(t.obj.name)
+			if w.debug || w.ctxt != nil {
+				w.string(subscript(t.id))
+			}
 		}
 
 	default:
@@ -292,15 +305,6 @@ func (w *typeWriter) typ(typ Type) {
 	}
 }
 
-// If w.ctxt is non-nil, typePrefix writes a unique prefix for the named type t
-// based on the types already observed by w.ctxt. If w.ctxt is nil, it does
-// nothing.
-func (w *typeWriter) typePrefix(t *Named) {
-	if w.ctxt != nil {
-		w.string(strconv.Itoa(w.ctxt.getID(t)))
-	}
-}
-
 func (w *typeWriter) typeList(list []Type) {
 	w.byte('[')
 	for i, typ := range list {
@@ -385,6 +389,13 @@ func (w *typeWriter) tuple(tup *Tuple, variadic bool) {
 
 func (w *typeWriter) signature(sig *Signature) {
 	if sig.TypeParams().Len() != 0 {
+		if w.ctxt != nil {
+			assert(w.tparams == nil)
+			w.tparams = sig.TypeParams()
+			defer func() {
+				w.tparams = nil
+			}()
+		}
 		w.tParamList(sig.TypeParams().list())
 	}
 
diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go
index ccb6ee8709..651bba1a6b 100644
--- a/src/cmd/compile/internal/types2/unify.go
+++ b/src/cmd/compile/internal/types2/unify.go
@@ -9,6 +9,7 @@ package types2
 import (
 	"bytes"
 	"fmt"
+	"internal/buildcfg"
 )
 
 // The unifier maintains two separate sets of type parameters x and y
@@ -161,6 +162,12 @@ func (d *tparamsList) index(typ Type) int {
 // If tpar is a type parameter in list, tparamIndex returns the type parameter index.
 // Otherwise, the result is < 0. tpar must not be nil.
 func tparamIndex(list []*TypeParam, tpar *TypeParam) int {
+	// Temporary work-around for getting around a crash
+	// with unified build.
+	// TODO(gri) investigate and implement proper fix
+	if buildcfg.Experiment.Unified && tpar.index < 0 {
+		return -1
+	}
 	if i := tpar.index; i < len(list) && list[i] == tpar {
 		return i
 	}

From 633d8c120b8f9c2ce4a0d079cd700a152a27dad6 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 16 Nov 2021 08:39:44 -0800
Subject: [PATCH 203/752] cmd/compile/internal/types2: when type hashing,
 canonicalize interfaces

This CL is a clean port of CL 363115 from go/types to types2.

Change-Id: Ic2bd9388c57ffa02e75ab136d952e3ab49eb9018
Reviewed-on: https://go-review.googlesource.com/c/go/+/364394
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 .../internal/types2/instantiate_test.go       | 32 +++++++++
 src/cmd/compile/internal/types2/typestring.go | 66 +++++++++++++++----
 2 files changed, 86 insertions(+), 12 deletions(-)

diff --git a/src/cmd/compile/internal/types2/instantiate_test.go b/src/cmd/compile/internal/types2/instantiate_test.go
index 289fe98fd2..591b467a2e 100644
--- a/src/cmd/compile/internal/types2/instantiate_test.go
+++ b/src/cmd/compile/internal/types2/instantiate_test.go
@@ -10,6 +10,7 @@ import (
 )
 
 func TestInstantiateEquality(t *testing.T) {
+	emptySignature := NewSignatureType(nil, nil, nil, nil, nil, false)
 	tests := []struct {
 		src       string
 		name1     string
@@ -36,6 +37,37 @@ func TestInstantiateEquality(t *testing.T) {
 			"T", []Type{NewSlice(Typ[Int])},
 			true,
 		},
+		{
+			// interface{interface{...}} is equivalent to interface{...}
+			"package equivalentinterfaces; type T[P any] int",
+			"T", []Type{
+				NewInterfaceType([]*Func{NewFunc(nopos, nil, "M", emptySignature)}, nil),
+			},
+			"T", []Type{
+				NewInterfaceType(
+					nil,
+					[]Type{
+						NewInterfaceType([]*Func{NewFunc(nopos, nil, "M", emptySignature)}, nil),
+					},
+				),
+			},
+			true,
+		},
+		{
+			// int|string is equivalent to string|int
+			"package equivalenttypesets; type T[P any] int",
+			"T", []Type{
+				NewInterfaceType(nil, []Type{
+					NewUnion([]*Term{NewTerm(false, Typ[Int]), NewTerm(false, Typ[String])}),
+				}),
+			},
+			"T", []Type{
+				NewInterfaceType(nil, []Type{
+					NewUnion([]*Term{NewTerm(false, Typ[String]), NewTerm(false, Typ[Int])}),
+				}),
+			},
+			true,
+		},
 		{
 			"package basicfunc; func F[P any]() {}",
 			"F", []Type{Typ[Int]},
diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
index ba3494d9d9..4d03eba657 100644
--- a/src/cmd/compile/internal/types2/typestring.go
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -9,7 +9,9 @@ package types2
 import (
 	"bytes"
 	"fmt"
+	"sort"
 	"strconv"
+	"strings"
 	"unicode/utf8"
 )
 
@@ -217,20 +219,24 @@ func (w *typeWriter) typ(typ Type) {
 		}
 		w.string("interface{")
 		first := true
-		for _, m := range t.methods {
-			if !first {
-				w.byte(';')
+		if w.ctxt != nil {
+			w.typeSet(t.typeSet())
+		} else {
+			for _, m := range t.methods {
+				if !first {
+					w.byte(';')
+				}
+				first = false
+				w.string(m.name)
+				w.signature(m.typ.(*Signature))
 			}
-			first = false
-			w.string(m.name)
-			w.signature(m.typ.(*Signature))
-		}
-		for _, typ := range t.embeddeds {
-			if !first {
-				w.byte(';')
+			for _, typ := range t.embeddeds {
+				if !first {
+					w.byte(';')
+				}
+				first = false
+				w.typ(typ)
 			}
-			first = false
-			w.typ(typ)
 		}
 		w.byte('}')
 
@@ -305,6 +311,42 @@ func (w *typeWriter) typ(typ Type) {
 	}
 }
 
+// typeSet writes a canonical hash for an interface type set.
+func (w *typeWriter) typeSet(s *_TypeSet) {
+	assert(w.ctxt != nil)
+	first := true
+	for _, m := range s.methods {
+		if !first {
+			w.byte(';')
+		}
+		first = false
+		w.string(m.name)
+		w.signature(m.typ.(*Signature))
+	}
+	switch {
+	case s.terms.isAll():
+		// nothing to do
+	case s.terms.isEmpty():
+		w.string(s.terms.String())
+	default:
+		var termHashes []string
+		for _, term := range s.terms {
+			// terms are not canonically sorted, so we sort their hashes instead.
+			var buf bytes.Buffer
+			if term.tilde {
+				buf.WriteByte('~')
+			}
+			newTypeHasher(&buf, w.ctxt).typ(term.typ)
+			termHashes = append(termHashes, buf.String())
+		}
+		sort.Strings(termHashes)
+		if !first {
+			w.byte(';')
+		}
+		w.string(strings.Join(termHashes, "|"))
+	}
+}
+
 func (w *typeWriter) typeList(list []Type) {
 	w.byte('[')
 	for i, typ := range list {

From 9c60a0968987ca3245b115a46d358d63b6b31b0f Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 16 Nov 2021 11:18:53 -0800
Subject: [PATCH 204/752] cmd/compile/internal/types2: don't set a
 Config.Context if none is provided

This CL is a clean port of CL 363175 from go/types to types2.

Change-Id: I149789be07c0ca7ddef7bfaa4ea9507778a63775
Reviewed-on: https://go-review.googlesource.com/c/go/+/364454
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/call.go      | 2 +-
 src/cmd/compile/internal/types2/check.go     | 8 +++-----
 src/cmd/compile/internal/types2/decl.go      | 2 +-
 src/cmd/compile/internal/types2/named.go     | 8 +++++---
 src/cmd/compile/internal/types2/signature.go | 2 +-
 src/cmd/compile/internal/types2/typexpr.go   | 9 +++++----
 6 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index fef493b2ae..4e2c2a2989 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -78,7 +78,7 @@ func (check *Checker) instantiateSignature(pos syntax.Pos, typ *Signature, targs
 		}()
 	}
 
-	inst := check.instance(pos, typ, targs, check.conf.Context).(*Signature)
+	inst := check.instance(pos, typ, targs, check.bestContext(nil)).(*Signature)
 	assert(len(posList) <= len(targs))
 	tparams := typ.TypeParams().list()
 	if i, err := check.verify(pos, tparams, targs); err != nil {
diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index 247bb5a649..faf4ccac0b 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -103,6 +103,7 @@ type Checker struct {
 	// package information
 	// (initialized by NewChecker, valid for the life-time of checker)
 	conf *Config
+	ctxt *Context // context for de-duplicating instances
 	pkg  *Package
 	*Info
 	version version                // accepted language version
@@ -200,11 +201,6 @@ func NewChecker(conf *Config, pkg *Package, info *Info) *Checker {
 		conf = new(Config)
 	}
 
-	// make sure we have a context
-	if conf.Context == nil {
-		conf.Context = NewContext()
-	}
-
 	// make sure we have an info struct
 	if info == nil {
 		info = new(Info)
@@ -217,6 +213,7 @@ func NewChecker(conf *Config, pkg *Package, info *Info) *Checker {
 
 	return &Checker{
 		conf:    conf,
+		ctxt:    conf.Context,
 		pkg:     pkg,
 		Info:    info,
 		version: version,
@@ -333,6 +330,7 @@ func (check *Checker) checkFiles(files []*syntax.File) (err error) {
 	check.seenPkgMap = nil
 	check.recvTParamMap = nil
 	check.defTypes = nil
+	check.ctxt = nil
 
 	// TODO(gri) There's more memory we should release at this point.
 
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 91503f1fcd..e85abbb82f 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -69,7 +69,7 @@ func (check *Checker) objDecl(obj Object, def *Named) {
 	// Funcs with m.instRecv set have not yet be completed. Complete them now
 	// so that they have a type when objDecl exits.
 	if m, _ := obj.(*Func); m != nil && m.instRecv != nil {
-		check.completeMethod(check.conf.Context, m)
+		check.completeMethod(nil, m)
 	}
 
 	// Checking the declaration of obj means inferring its type
diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go
index a455489cd6..51ea27a6db 100644
--- a/src/cmd/compile/internal/types2/named.go
+++ b/src/cmd/compile/internal/types2/named.go
@@ -220,15 +220,17 @@ func (n *Named) setUnderlying(typ Type) {
 
 // bestContext returns the best available context. In order of preference:
 // - the given ctxt, if non-nil
-// - check.Config.Context, if check is non-nil
+// - check.ctxt, if check is non-nil
 // - a new Context
 func (check *Checker) bestContext(ctxt *Context) *Context {
 	if ctxt != nil {
 		return ctxt
 	}
 	if check != nil {
-		assert(check.conf.Context != nil)
-		return check.conf.Context
+		if check.ctxt == nil {
+			check.ctxt = NewContext()
+		}
+		return check.ctxt
 	}
 	return NewContext()
 }
diff --git a/src/cmd/compile/internal/types2/signature.go b/src/cmd/compile/internal/types2/signature.go
index b0b8ad49d9..06dcd9131a 100644
--- a/src/cmd/compile/internal/types2/signature.go
+++ b/src/cmd/compile/internal/types2/signature.go
@@ -216,7 +216,7 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []
 			var err string
 			switch T := rtyp.(type) {
 			case *Named:
-				T.resolve(check.conf.Context)
+				T.resolve(check.bestContext(nil))
 				// The receiver type may be an instantiated type referred to
 				// by an alias (which cannot have receiver parameters for now).
 				if T.TypeArgs() != nil && sig.RecvTypeParams() == nil {
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 0380c3461d..862a31544a 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -437,9 +437,10 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 	}
 
 	// create the instance
-	h := check.conf.Context.instanceHash(orig, targs)
+	ctxt := check.bestContext(nil)
+	h := ctxt.instanceHash(orig, targs)
 	// targs may be incomplete, and require inference. In any case we should de-duplicate.
-	inst, _ := check.conf.Context.lookup(h, orig, targs).(*Named)
+	inst, _ := ctxt.lookup(h, orig, targs).(*Named)
 	// If inst is non-nil, we can't just return here. Inst may have been
 	// constructed via recursive substitution, in which case we wouldn't do the
 	// validation below. Ensure that the validation (and resulting errors) runs
@@ -448,7 +449,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 		tname := NewTypeName(x.Pos(), orig.obj.pkg, orig.obj.name, nil)
 		inst = check.newNamed(tname, orig, nil, nil, nil) // underlying, methods and tparams are set when named is resolved
 		inst.targs = NewTypeList(targs)
-		inst = check.conf.Context.update(h, orig, targs, inst).(*Named)
+		inst = ctxt.update(h, orig, targs, inst).(*Named)
 	}
 	def.setUnderlying(inst)
 
@@ -474,7 +475,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 		// This is an instance from the source, not from recursive substitution,
 		// and so it must be resolved during type-checking so that we can report
 		// errors.
-		inst.resolve(check.conf.Context)
+		inst.resolve(ctxt)
 		// Since check is non-nil, we can still mutate inst. Unpinning the resolver
 		// frees some memory.
 		inst.resolver = nil

From 1c13b58abaaeaaaa54a5471613c020fe78105016 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 16 Nov 2021 11:27:56 -0800
Subject: [PATCH 205/752] cmd/compile/internal/types2: rename types.context to
 types.environment

This CL is a clean port of CL 363176 from go/types to types2.

It also includes a minor adjustment to a field access in go/types
to match types2 in that respect.

Change-Id: If33fc7e68372b12d61d06b75dd9f7c0715b57bc1
Reviewed-on: https://go-review.googlesource.com/c/go/+/364474
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/check.go | 17 +++++++++--------
 src/cmd/compile/internal/types2/decl.go  | 14 +++++++-------
 src/cmd/compile/internal/types2/stmt.go  | 10 +++++-----
 src/go/types/decl.go                     |  2 +-
 4 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index faf4ccac0b..38fc25c74d 100644
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -39,8 +39,9 @@ type exprInfo struct {
 	val   constant.Value // constant value; or nil (if not a constant)
 }
 
-// A context represents the context within which an object is type-checked.
-type context struct {
+// An environment represents the environment within which an object is
+// type-checked.
+type environment struct {
 	decl          *declInfo                 // package-level declaration whose init expression/function body is checked
 	scope         *Scope                    // top-most scope for lookups
 	pos           syntax.Pos                // if valid, identifiers are looked up as if at position pos (used by Eval)
@@ -53,9 +54,9 @@ type context struct {
 	hasCallOrRecv bool                      // set if an expression contains a function call or channel receive operation
 }
 
-// lookup looks up name in the current context and returns the matching object, or nil.
-func (ctxt *context) lookup(name string) Object {
-	_, obj := ctxt.scope.LookupParent(name, ctxt.pos)
+// lookup looks up name in the current environment and returns the matching object, or nil.
+func (env *environment) lookup(name string) Object {
+	_, obj := env.scope.LookupParent(name, env.pos)
 	return obj
 }
 
@@ -137,9 +138,9 @@ type Checker struct {
 	objPath  []Object                 // path of object dependencies during type inference (for cycle reporting)
 	defTypes []*Named                 // defined types created during type checking, for final validation.
 
-	// context within which the current object is type-checked
-	// (valid only for the duration of type-checking a specific object)
-	context
+	// environment within which the current object is type-checked (valid only
+	// for the duration of type-checking a specific object)
+	environment
 
 	// debugging
 	indent int // indentation for tracing
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index e85abbb82f..4b79c59af3 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -51,7 +51,7 @@ func pathString(path []Object) string {
 	return s
 }
 
-// objDecl type-checks the declaration of obj in its respective (file) context.
+// objDecl type-checks the declaration of obj in its respective (file) environment.
 // For the meaning of def, see Checker.definedType, in typexpr.go.
 func (check *Checker) objDecl(obj Object, def *Named) {
 	if check.conf.Trace && obj.Type() == nil {
@@ -178,11 +178,11 @@ func (check *Checker) objDecl(obj Object, def *Named) {
 		unreachable()
 	}
 
-	// save/restore current context and setup object context
-	defer func(ctxt context) {
-		check.context = ctxt
-	}(check.context)
-	check.context = context{
+	// save/restore current environment and set up object environment
+	defer func(env environment) {
+		check.environment = env
+	}(check.environment)
+	check.environment = environment{
 		scope: d.file,
 	}
 
@@ -646,7 +646,7 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list []*syntax.Fiel
 	// function closures may appear inside a type parameter list but they
 	// cannot be generic, and their bodies are processed in delayed and
 	// sequential fashion. Note that with each new declaration, we save
-	// the existing context and restore it when done; thus inTParamList
+	// the existing environment and restore it when done; thus inTParamList
 	// is true exactly only when we are in a specific type parameter list.
 	assert(!check.inTParamList)
 	check.inTParamList = true
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 6869c87929..44d9256c50 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -28,13 +28,13 @@ func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body
 	sig.scope.pos = body.Pos()
 	sig.scope.end = syntax.EndPos(body)
 
-	// save/restore current context and setup function context
+	// save/restore current environment and set up function environment
 	// (and use 0 indentation at function start)
-	defer func(ctxt context, indent int) {
-		check.context = ctxt
+	defer func(env environment, indent int) {
+		check.environment = env
 		check.indent = indent
-	}(check.context, check.indent)
-	check.context = context{
+	}(check.environment, check.indent)
+	check.environment = environment{
 		decl:  decl,
 		scope: sig.scope,
 		iota:  iota,
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 2108cf6b05..4f28553aa6 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -239,7 +239,7 @@ loop:
 			// If we reach a generic type that is part of a cycle
 			// and we are in a type parameter list, we have a cycle
 			// through a type parameter list, which is invalid.
-			if check.environment.inTParamList && isGeneric(obj.typ) {
+			if check.inTParamList && isGeneric(obj.typ) {
 				tparCycle = true
 				break loop
 			}

From 2f937d9bfcbb1e95c089a3af37677bacb185aedb Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 16 Nov 2021 11:36:09 -0800
Subject: [PATCH 206/752] cmd/compile/internal/types2: add a test for Context
 deduplication of hash collisions

This CL is a clean port of CL 363517 from go/types to types2,
with the exception that types_test.go was not removed because
it's still needed to set a types2-specific test flag.

Change-Id: I12177866537c0f95f3fa36fa0f4aa02016609ca9
Reviewed-on: https://go-review.googlesource.com/c/go/+/364494
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 .../compile/internal/types2/context_test.go   | 69 +++++++++++++++++++
 src/cmd/compile/internal/types2/types_test.go |  3 -
 2 files changed, 69 insertions(+), 3 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/context_test.go

diff --git a/src/cmd/compile/internal/types2/context_test.go b/src/cmd/compile/internal/types2/context_test.go
new file mode 100644
index 0000000000..aa649b1448
--- /dev/null
+++ b/src/cmd/compile/internal/types2/context_test.go
@@ -0,0 +1,69 @@
+// 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 types2
+
+import (
+	"testing"
+)
+
+func TestContextHashCollisions(t *testing.T) {
+	if debug {
+		t.Skip("hash collisions are expected, and would fail debug assertions")
+	}
+	// Unit test the de-duplication fall-back logic in Context.
+	//
+	// We can't test this via Instantiate because this is only a fall-back in
+	// case our hash is imperfect.
+	//
+	// These lookups and updates use reasonable looking types in an attempt to
+	// make them robust to internal type assertions, but could equally well use
+	// arbitrary types.
+
+	// Create some distinct origin types. nullaryP and nullaryQ have no
+	// parameters and are identical (but have different type parameter names).
+	// unaryP has a parameter.
+	var nullaryP, nullaryQ, unaryP Type
+	{
+		// type nullaryP = func[P any]()
+		tparam := NewTypeParam(NewTypeName(nopos, nil, "P", nil), &emptyInterface)
+		nullaryP = NewSignatureType(nil, nil, []*TypeParam{tparam}, nil, nil, false)
+	}
+	{
+		// type nullaryQ = func[Q any]()
+		tparam := NewTypeParam(NewTypeName(nopos, nil, "Q", nil), &emptyInterface)
+		nullaryQ = NewSignatureType(nil, nil, []*TypeParam{tparam}, nil, nil, false)
+	}
+	{
+		// type unaryP = func[P any](_ P)
+		tparam := NewTypeParam(NewTypeName(nopos, nil, "P", nil), &emptyInterface)
+		params := NewTuple(NewVar(nopos, nil, "_", tparam))
+		unaryP = NewSignatureType(nil, nil, []*TypeParam{tparam}, params, nil, false)
+	}
+
+	ctxt := NewContext()
+
+	// Update the context with an instantiation of nullaryP.
+	inst := NewSignatureType(nil, nil, nil, nil, nil, false)
+	if got := ctxt.update("", nullaryP, []Type{Typ[Int]}, inst); got != inst {
+		t.Error("bad")
+	}
+
+	// unaryP is not identical to nullaryP, so we should not get inst when
+	// instantiated with identical type arguments.
+	if got := ctxt.lookup("", unaryP, []Type{Typ[Int]}); got != nil {
+		t.Error("bad")
+	}
+
+	// nullaryQ is identical to nullaryP, so we *should* get inst when
+	// instantiated with identical type arguments.
+	if got := ctxt.lookup("", nullaryQ, []Type{Typ[Int]}); got != inst {
+		t.Error("bad")
+	}
+
+	// ...but verify we don't get inst with different type arguments.
+	if got := ctxt.lookup("", nullaryQ, []Type{Typ[String]}); got != nil {
+		t.Error("bad")
+	}
+}
diff --git a/src/cmd/compile/internal/types2/types_test.go b/src/cmd/compile/internal/types2/types_test.go
index 1525844f2d..11dca0b53d 100644
--- a/src/cmd/compile/internal/types2/types_test.go
+++ b/src/cmd/compile/internal/types2/types_test.go
@@ -7,6 +7,3 @@ package types2
 func init() {
 	acceptMethodTypeParams = true
 }
-
-// Debug is set if types2 is built with debug mode enabled.
-const Debug = debug

From 3c00a2839a8b577912f78d5fe1ba2d765d0f6c7c Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 16 Nov 2021 12:20:11 -0800
Subject: [PATCH 207/752] cmd/compile/internal/types2: return an error from
 Instantiate on incorrect len(targs)

This CL is a clean port of CL 363635 from go/types to types2.

Updates #47916

Change-Id: Ib46758435c31ad9a6a4a63f552503d5afa66b5c0
Reviewed-on: https://go-review.googlesource.com/c/go/+/364534
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 .../compile/internal/types2/instantiate.go    | 50 +++++++++++--------
 1 file changed, 30 insertions(+), 20 deletions(-)

diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index 35fcc7c040..3f5fc56f5d 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -13,40 +13,50 @@ import (
 	"fmt"
 )
 
-// Instantiate instantiates the type typ with the given type arguments targs.
-// typ must be a *Named or a *Signature type, and its number of type parameters
-// must match the number of provided type arguments. The result is a new,
-// instantiated (not parameterized) type of the same kind (either a *Named or a
-// *Signature). Any methods attached to a *Named are simply copied; they are
-// not instantiated.
+// Instantiate instantiates the type orig with the given type arguments targs.
+// orig must be a *Named or a *Signature type. If there is no error, the
+// resulting Type is a new, instantiated (not parameterized) type of the same
+// kind (either a *Named or a *Signature). Methods attached to a *Named type
+// are also instantiated, and associated with a new *Func that has the same
+// position as the original method, but nil function scope.
 //
-// If ctxt is non-nil, it may be used to de-dupe the instance against previous
-// instances with the same identity.
+// If ctxt is non-nil, it may be used to de-duplicate the instance against
+// previous instances with the same identity. As a special case, generic
+// *Signature origin types are only considered identical if they are pointer
+// equivalent, so that instantiating distinct (but possibly identical)
+// signatures will yield different instances.
 //
-// If verify is set and constraint satisfaction fails, the returned error may
-// wrap an *ArgumentError indicating which type argument did not satisfy its
-// corresponding type parameter constraint, and why.
+// If validate is set, Instantiate verifies that the number of type arguments
+// and parameters match, and that the type arguments satisfy their
+// corresponding type constraints. If verification fails, the resulting error
+// may wrap an *ArgumentError indicating which type argument did not satisfy
+// its corresponding type parameter constraint, and why.
 //
-// TODO(rfindley): change this function to also return an error if lengths of
-// tparams and targs do not match.
-func Instantiate(ctxt *Context, typ Type, targs []Type, validate bool) (Type, error) {
-	inst := (*Checker)(nil).instance(nopos, typ, targs, ctxt)
-
-	var err error
+// If validate is not set, Instantiate does not verify the type argument count
+// or whether the type arguments satisfy their constraints. Instantiate is
+// guaranteed to not return an error, but may panic. Specifically, for
+// *Signature types, Instantiate will panic immediately if the type argument
+// count is incorrect; for *Named types, a panic may occur later inside the
+// *Named API.
+func Instantiate(ctxt *Context, orig Type, targs []Type, validate bool) (Type, error) {
 	if validate {
 		var tparams []*TypeParam
-		switch t := typ.(type) {
+		switch t := orig.(type) {
 		case *Named:
 			tparams = t.TypeParams().list()
 		case *Signature:
 			tparams = t.TypeParams().list()
 		}
+		if len(targs) != len(tparams) {
+			return nil, fmt.Errorf("got %d type arguments but %s has %d type parameters", len(targs), orig, len(tparams))
+		}
 		if i, err := (*Checker)(nil).verify(nopos, tparams, targs); err != nil {
-			return inst, &ArgumentError{i, err}
+			return nil, &ArgumentError{i, err}
 		}
 	}
 
-	return inst, err
+	inst := (*Checker)(nil).instance(nopos, orig, targs, ctxt)
+	return inst, nil
 }
 
 // instance creates a type or function instance using the given original type

From 03dd049d6efcbca6b829d7ed504ceea6318f2036 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 16 Nov 2021 17:51:58 -0800
Subject: [PATCH 208/752] go/types: make sure we are safe for nil in underIs

This CL is a clean port CL 363658 from types2 to go/types.

Change-Id: Ie2032f85a9cfca62161c2e629c78f1ecd8c6e4c0
Reviewed-on: https://go-review.googlesource.com/c/go/+/364537
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/go/types/expr.go       | 3 +++
 src/go/types/predicates.go | 4 +++-
 src/go/types/type.go       | 3 +++
 3 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 660c92de3b..ddb0149bf4 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -679,6 +679,9 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 	case *TypeParam:
 		// TODO(gri) review this code - doesn't look quite right
 		ok := u.underIs(func(t Type) bool {
+			if t == nil {
+				return false
+			}
 			target, _, _ := check.implicitTypeAndValue(x, t)
 			return target != nil
 		})
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index d0697b1ad7..78ad6c4f23 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -149,7 +149,9 @@ func hasNil(t Type) bool {
 	case *Slice, *Pointer, *Signature, *Interface, *Map, *Chan:
 		return true
 	case *TypeParam:
-		return u.underIs(hasNil)
+		return u.underIs(func(u Type) bool {
+			return u != nil && hasNil(u)
+		})
 	}
 	return false
 }
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 555eb9e8b9..756bdcf0a5 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -65,6 +65,9 @@ func match(x, y Type) Type {
 func structuralType(typ Type) Type {
 	var su Type
 	if underIs(typ, func(u Type) bool {
+		if u == nil {
+			return false
+		}
 		if su != nil {
 			u = match(su, u)
 			if u == nil {

From 1d004fa2015d128acf6302fc74b95f6a36c35680 Mon Sep 17 00:00:00 2001
From: Cuong Manh Le 
Date: Wed, 17 Nov 2021 10:17:31 +0700
Subject: [PATCH 209/752] cmd/compile: emit definition of 'any' only if generic
 enabled

CL 364377 emitted definition of 'any' when compiling runtime. But 'any'
is only available when generic enabled. Thus emitting its definition
unconditionally causes the compiler crashes.

Updates #49619

Change-Id: I0888ca1cbc7a7df300310a99a344f170636333f2
Reviewed-on: https://go-review.googlesource.com/c/go/+/364614
Trust: Cuong Manh Le 
Trust: Dan Scales 
Run-TryBot: Cuong Manh Le 
TryBot-Result: Go Bot 
Reviewed-by: Dan Scales 
---
 src/cmd/compile/internal/reflectdata/reflect.go | 4 +++-
 test/fixedbugs/issue49619.go                    | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index e22fabb410..f35baabbf9 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1384,7 +1384,9 @@ func WriteBasicTypes() {
 		}
 		writeType(types.NewPtr(types.Types[types.TSTRING]))
 		writeType(types.NewPtr(types.Types[types.TUNSAFEPTR]))
-		writeType(types.AnyType)
+		if base.Flag.G > 0 {
+			writeType(types.AnyType)
+		}
 
 		// emit type structs for error and func(error) string.
 		// The latter is the type of an auto-generated wrapper.
diff --git a/test/fixedbugs/issue49619.go b/test/fixedbugs/issue49619.go
index c9f3cbc4ad..f34dfac192 100644
--- a/test/fixedbugs/issue49619.go
+++ b/test/fixedbugs/issue49619.go
@@ -1,4 +1,4 @@
-// build
+// build -gcflags=-G=3
 
 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

From 4083a6f3776487e707d4c56c63b1d7dbabb01fb0 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Tue, 16 Nov 2021 11:24:22 -0500
Subject: [PATCH 210/752] go/types: better error for type assertion/switch on
 type parameter value

This is a port of CL 363439 from types2 to go/types.

Change-Id: Ic71871874345e1d0a4a42703e3673aadd11f2bfc
Reviewed-on: https://go-review.googlesource.com/c/go/+/364378
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/expr.go                       | 5 +++++
 src/go/types/stmt.go                       | 5 +++++
 src/go/types/testdata/check/typeparams.go2 | 8 ++++----
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index ddb0149bf4..5e66a4a4b5 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1432,6 +1432,11 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		if x.mode == invalid {
 			goto Error
 		}
+		// TODO(gri) we may want to permit type assertions on type parameter values at some point
+		if isTypeParam(x.typ) {
+			check.invalidOp(x, _InvalidAssert, "cannot use type assertion on type parameter value %s", x)
+			goto Error
+		}
 		xtyp, _ := under(x.typ).(*Interface)
 		if xtyp == nil {
 			check.invalidOp(x, _InvalidAssert, "%s is not an interface", x)
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index 363ea35acf..ee7d4e4cf1 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -685,6 +685,11 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 		if x.mode == invalid {
 			return
 		}
+		// TODO(gri) we may want to permit type switches on type parameter values at some point
+		if isTypeParam(x.typ) {
+			check.errorf(&x, _InvalidTypeSwitch, "cannot use type switch on type parameter value %s", &x)
+			return
+		}
 		xtyp, _ := under(x.typ).(*Interface)
 		if xtyp == nil {
 			check.errorf(&x, _InvalidTypeSwitch, "%s is not an interface", &x)
diff --git a/src/go/types/testdata/check/typeparams.go2 b/src/go/types/testdata/check/typeparams.go2
index 9e2bffb539..fdbb7a2740 100644
--- a/src/go/types/testdata/check/typeparams.go2
+++ b/src/go/types/testdata/check/typeparams.go2
@@ -481,8 +481,8 @@ func (_ R2[X, Y]) m2(X) Y
 // type assertions and type switches over generic types lead to errors for now
 
 func _[T any](x T) {
-	_ = x /* ERROR not an interface */ .(int)
-	switch x /* ERROR not an interface */ .(type) {
+	_ = x /* ERROR cannot use type assertion */ .(int)
+	switch x /* ERROR cannot use type switch */ .(type) {
 	}
 
 	// work-around
@@ -493,8 +493,8 @@ func _[T any](x T) {
 }
 
 func _[T interface{~int}](x T) {
-	_ = x /* ERROR not an interface */ .(int)
-	switch x /* ERROR not an interface */ .(type) {
+	_ = x /* ERROR cannot use type assertion */ .(int)
+	switch x /* ERROR cannot use type switch */ .(type) {
 	}
 
 	// work-around

From 54b9cb80372f45b5e86c5246717c766fac6f1fe6 Mon Sep 17 00:00:00 2001
From: Patrik Nyblom 
Date: Tue, 16 Nov 2021 14:35:59 -0800
Subject: [PATCH 211/752] runtime: make sure to properly park before going to
 sleep in Windows ConsoleControlHandler

This change avoids the program intermittently hanging on windows/arm64 after getting
a signal for which the ConsoleControlHandler can not return.

Fixes #49458

Change-Id: Ie28f0f437c7e0f9634b6b3e29dc6cdebd5d996f6
Reviewed-on: https://go-review.googlesource.com/c/go/+/364556
Trust: Patrik Nyblom 
Trust: Dan Scales 
Run-TryBot: Patrik Nyblom 
Run-TryBot: Cherry Mui 
Reviewed-by: Cherry Mui 
Reviewed-by: Michael Knyszek 
TryBot-Result: Go Bot 
---
 src/runtime/os_windows.go | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index 648239fb36..7ffb3a11b5 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -1194,8 +1194,10 @@ func ctrlHandler(_type uint32) uintptr {
 	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))
+			// Block indefinitely to give signal handlers a chance to clean up,
+			// but make sure to be properly parked first, so the rest of the
+			// program can continue executing.
+			block()
 		}
 		return 1
 	}

From ab75484d7130496ac9b204b0d418b1ec95bee2f8 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker 
Date: Mon, 15 Nov 2021 17:47:15 -0800
Subject: [PATCH 212/752] internal/fuzz: limit number of consecutive mutations

This makes two changes: (1) mutator.mutate now only applies a single
mutation to the input, and (2) in workerServer.fuzz if, after five
mutations are applied to the input, no new coverage is found the input
is reset to its initial state. This process is repeated until new
coverage is found, or the fuzz call times out.

This results in finding new coverage expanding inputs which have less
divergence from the initial input they were mutated from, which makes
traversing certain types of call graphs significantly more efficient.

Fixes #49601
Fixes #48179
Fixes #47090

Change-Id: I74d18a56ca2669f20192951090b281f58ee0b5dc
Reviewed-on: https://go-review.googlesource.com/c/go/+/364214
Trust: Roland Shoemaker 
Trust: Katie Hockman 
Run-TryBot: Roland Shoemaker 
TryBot-Result: Go Bot 
Reviewed-by: Katie Hockman 
---
 src/internal/fuzz/mutator.go | 39 ++++++++++++++----------------------
 src/internal/fuzz/worker.go  | 23 ++++++++++++++++++---
 2 files changed, 35 insertions(+), 27 deletions(-)

diff --git a/src/internal/fuzz/mutator.go b/src/internal/fuzz/mutator.go
index da7200dcbe..a3161c04ea 100644
--- a/src/internal/fuzz/mutator.go
+++ b/src/internal/fuzz/mutator.go
@@ -125,15 +125,13 @@ func (m *mutator) mutate(vals []interface{}, maxBytes int) {
 }
 
 func (m *mutator) mutateInt(v, maxValue int64) int64 {
-	numIters := 1 + m.r.exp2()
 	var max int64
-	for iter := 0; iter < numIters; iter++ {
+	for {
 		max = 100
 		switch m.rand(2) {
 		case 0:
 			// Add a random number
 			if v >= maxValue {
-				iter--
 				continue
 			}
 			if v > 0 && maxValue-v < max {
@@ -141,10 +139,10 @@ func (m *mutator) mutateInt(v, maxValue int64) int64 {
 				max = maxValue - v
 			}
 			v += int64(1 + m.rand(int(max)))
+			return v
 		case 1:
 			// Subtract a random number
 			if v <= -maxValue {
-				iter--
 				continue
 			}
 			if v < 0 && maxValue+v < max {
@@ -152,21 +150,19 @@ func (m *mutator) mutateInt(v, maxValue int64) int64 {
 				max = maxValue + v
 			}
 			v -= int64(1 + m.rand(int(max)))
+			return v
 		}
 	}
-	return v
 }
 
 func (m *mutator) mutateUInt(v, maxValue uint64) uint64 {
-	numIters := 1 + m.r.exp2()
 	var max uint64
-	for iter := 0; iter < numIters; iter++ {
+	for {
 		max = 100
 		switch m.rand(2) {
 		case 0:
 			// Add a random number
 			if v >= maxValue {
-				iter--
 				continue
 			}
 			if v > 0 && maxValue-v < max {
@@ -175,10 +171,10 @@ func (m *mutator) mutateUInt(v, maxValue uint64) uint64 {
 			}
 
 			v += uint64(1 + m.rand(int(max)))
+			return v
 		case 1:
 			// Subtract a random number
 			if v <= 0 {
-				iter--
 				continue
 			}
 			if v < max {
@@ -186,20 +182,18 @@ func (m *mutator) mutateUInt(v, maxValue uint64) uint64 {
 				max = v
 			}
 			v -= uint64(1 + m.rand(int(max)))
+			return v
 		}
 	}
-	return v
 }
 
 func (m *mutator) mutateFloat(v, maxValue float64) float64 {
-	numIters := 1 + m.r.exp2()
 	var max float64
-	for iter := 0; iter < numIters; iter++ {
+	for {
 		switch m.rand(4) {
 		case 0:
 			// Add a random number
 			if v >= maxValue {
-				iter--
 				continue
 			}
 			max = 100
@@ -208,10 +202,10 @@ func (m *mutator) mutateFloat(v, maxValue float64) float64 {
 				max = maxValue - v
 			}
 			v += float64(1 + m.rand(int(max)))
+			return v
 		case 1:
 			// Subtract a random number
 			if v <= -maxValue {
-				iter--
 				continue
 			}
 			max = 100
@@ -220,11 +214,11 @@ func (m *mutator) mutateFloat(v, maxValue float64) float64 {
 				max = maxValue + v
 			}
 			v -= float64(1 + m.rand(int(max)))
+			return v
 		case 2:
 			// Multiply by a random number
 			absV := math.Abs(v)
 			if v == 0 || absV >= maxValue {
-				iter--
 				continue
 			}
 			max = 10
@@ -233,16 +227,16 @@ func (m *mutator) mutateFloat(v, maxValue float64) float64 {
 				max = maxValue / absV
 			}
 			v *= float64(1 + m.rand(int(max)))
+			return v
 		case 3:
 			// Divide by a random number
 			if v == 0 {
-				iter--
 				continue
 			}
 			v /= float64(1 + m.rand(10))
+			return v
 		}
 	}
-	return v
 }
 
 type byteSliceMutator func(*mutator, []byte) []byte
@@ -279,15 +273,12 @@ func (m *mutator) mutateBytes(ptrB *[]byte) {
 		*ptrB = b
 	}()
 
-	numIters := 1 + m.r.exp2()
-	for iter := 0; iter < numIters; iter++ {
+	for {
 		mut := byteSliceMutators[m.rand(len(byteSliceMutators))]
-		mutated := mut(m, b)
-		if mutated == nil {
-			iter--
-			continue
+		if mutated := mut(m, b); mutated != nil {
+			b = mutated
+			return
 		}
-		b = mutated
 	}
 }
 
diff --git a/src/internal/fuzz/worker.go b/src/internal/fuzz/worker.go
index 48a3923112..e7d824bea1 100644
--- a/src/internal/fuzz/worker.go
+++ b/src/internal/fuzz/worker.go
@@ -661,6 +661,17 @@ func (ws *workerServer) serve(ctx context.Context) error {
 	}
 }
 
+// chainedMutations is how many mutations are applied before the worker
+// resets the input to it's original state.
+// NOTE: this number was picked without much thought. It is low enough that
+// it seems to create a significant diversity in mutated inputs. We may want
+// to consider looking into this more closely once we have a proper performance
+// testing framework. Another option is to randomly pick the number of chained
+// mutations on each invocation of the workerServer.fuzz method (this appears to
+// be what libFuzzer does, although there seems to be no documentation which
+// explains why this choice was made.)
+const chainedMutations = 5
+
 // fuzz runs the test function on random variations of the input value in shared
 // memory for a limited duration or number of iterations.
 //
@@ -699,11 +710,13 @@ func (ws *workerServer) fuzz(ctx context.Context, args fuzzArgs) (resp fuzzRespo
 		return resp
 	}
 
-	vals, err := unmarshalCorpusFile(mem.valueCopy())
+	originalVals, err := unmarshalCorpusFile(mem.valueCopy())
 	if err != nil {
 		resp.InternalErr = err.Error()
 		return resp
 	}
+	vals := make([]interface{}, len(originalVals))
+	copy(vals, originalVals)
 
 	shouldStop := func() bool {
 		return args.Limit > 0 && mem.header().count >= args.Limit
@@ -742,9 +755,13 @@ func (ws *workerServer) fuzz(ctx context.Context, args fuzzArgs) (resp fuzzRespo
 		select {
 		case <-ctx.Done():
 			return resp
-
 		default:
+			if mem.header().count%chainedMutations == 0 {
+				copy(vals, originalVals)
+				ws.m.r.save(&mem.header().randState, &mem.header().randInc)
+			}
 			ws.m.mutate(vals, cap(mem.valueRef()))
+
 			entry := CorpusEntry{Values: vals}
 			dur, cov, errMsg := fuzzOnce(entry)
 			if errMsg != "" {
@@ -1094,7 +1111,7 @@ func (wc *workerClient) fuzz(ctx context.Context, entryIn CorpusEntry, args fuzz
 		wc.m.r.restore(mem.header().randState, mem.header().randInc)
 		if !args.Warmup {
 			// Only mutate the valuesOut if fuzzing actually occurred.
-			for i := int64(0); i < resp.Count; i++ {
+			for i := int64(0); i < resp.Count%chainedMutations; i++ {
 				wc.m.mutate(valuesOut, cap(mem.valueRef()))
 			}
 		}

From 0555ea3ce997db6e6ef14ba9f55857f359b3fbf2 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor 
Date: Tue, 16 Nov 2021 22:18:02 -0800
Subject: [PATCH 213/752] runtime: don't serialize all builds in test

Permit a test whose program is already built to run immediately,
rather than waiting for another test to complete its build.

For #44422

Change-Id: I2d1b35d055ee4c4251f4caef3b52dccc82b71a1b
Reviewed-on: https://go-review.googlesource.com/c/go/+/364654
Trust: Ian Lance Taylor 
Run-TryBot: Ian Lance Taylor 
Reviewed-by: Bryan C. Mills 
TryBot-Result: Go Bot 
---
 src/runtime/crash_test.go | 61 +++++++++++++++++++++++++++------------
 1 file changed, 42 insertions(+), 19 deletions(-)

diff --git a/src/runtime/crash_test.go b/src/runtime/crash_test.go
index e0c0bac892..91a1a41ed5 100644
--- a/src/runtime/crash_test.go
+++ b/src/runtime/crash_test.go
@@ -6,6 +6,7 @@ package runtime_test
 
 import (
 	"bytes"
+	"errors"
 	"flag"
 	"fmt"
 	"internal/testenv"
@@ -34,12 +35,13 @@ func TestMain(m *testing.M) {
 var testprog struct {
 	sync.Mutex
 	dir    string
-	target map[string]buildexe
+	target map[string]*buildexe
 }
 
 type buildexe struct {
-	exe string
-	err error
+	once sync.Once
+	exe  string
+	err  error
 }
 
 func runTestProg(t *testing.T, binary, name string, env ...string) string {
@@ -108,13 +110,15 @@ func runBuiltTestProg(t *testing.T, exe, name string, env ...string) string {
 	return b.String()
 }
 
+var serializeBuild = make(chan bool, 2)
+
 func buildTestProg(t *testing.T, binary string, flags ...string) (string, error) {
 	if *flagQuick {
 		t.Skip("-quick")
 	}
+	testenv.MustHaveGoBuild(t)
 
 	testprog.Lock()
-	defer testprog.Unlock()
 	if testprog.dir == "" {
 		dir, err := os.MkdirTemp("", "go-build")
 		if err != nil {
@@ -125,29 +129,48 @@ func buildTestProg(t *testing.T, binary string, flags ...string) (string, error)
 	}
 
 	if testprog.target == nil {
-		testprog.target = make(map[string]buildexe)
+		testprog.target = make(map[string]*buildexe)
 	}
 	name := binary
 	if len(flags) > 0 {
 		name += "_" + strings.Join(flags, "_")
 	}
 	target, ok := testprog.target[name]
-	if ok {
-		return target.exe, target.err
+	if !ok {
+		target = &buildexe{}
+		testprog.target[name] = target
 	}
 
-	exe := filepath.Join(testprog.dir, name+".exe")
-	cmd := exec.Command(testenv.GoToolPath(t), append([]string{"build", "-o", exe}, flags...)...)
-	cmd.Dir = "testdata/" + binary
-	out, err := testenv.CleanCmdEnv(cmd).CombinedOutput()
-	if err != nil {
-		target.err = fmt.Errorf("building %s %v: %v\n%s", binary, flags, err, out)
-		testprog.target[name] = target
-		return "", target.err
-	}
-	target.exe = exe
-	testprog.target[name] = target
-	return exe, nil
+	dir := testprog.dir
+
+	// Unlock testprog while actually building, so that other
+	// tests can look up executables that were already built.
+	testprog.Unlock()
+
+	target.once.Do(func() {
+		// Only do two "go build"'s at a time,
+		// to keep load from getting too high.
+		serializeBuild <- true
+		defer func() { <-serializeBuild }()
+
+		// Don't get confused if testenv.GoToolPath calls t.Skip.
+		target.err = errors.New("building test called t.Skip")
+
+		exe := filepath.Join(dir, name+".exe")
+
+		t.Logf("running go build -o %s %s", exe, strings.Join(flags, " "))
+		cmd := exec.Command(testenv.GoToolPath(t), append([]string{"build", "-o", exe}, flags...)...)
+		cmd.Dir = "testdata/" + binary
+		out, err := testenv.CleanCmdEnv(cmd).CombinedOutput()
+		if err != nil {
+			target.err = fmt.Errorf("building %s %v: %v\n%s", binary, flags, err, out)
+		} else {
+			target.exe = exe
+			target.err = nil
+		}
+	})
+
+	return target.exe, target.err
 }
 
 func TestVDSO(t *testing.T) {

From 17b7604ef62316c7ea69e6a07f90282edcf4c874 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Tue, 16 Nov 2021 19:17:31 -0500
Subject: [PATCH 214/752] go/types: match Go 1.17 compiler error messages more
 closely

Introduce a new constant compilerErrorMessages, which is set to false
for now, so that we can port types2 error handling more precisely. Use
this to (partially) port CL 363436, excluding issue49005.go, which does
not exist in go/types (it was added in a previous CL related to compiler
error messages, that was not ported). I've also included the bugfix from
CL 364034, so that go/types is not broken at this commit.

In subsequent CLs I'll catch up with error handling locations in types2
that use compiler error messages.

Change-Id: I13fd6c43d61b28e0a7a3b0ae8ba785fb8506fbb7
Reviewed-on: https://go-review.googlesource.com/c/go/+/364379
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/assignments.go           | 14 +++++--
 src/go/types/check.go                 |  4 ++
 src/go/types/conversions.go           | 15 +++++--
 src/go/types/lookup.go                | 58 +++++++++++++++++++++++++++
 src/go/types/operand.go               | 42 ++++++++++++++-----
 src/go/types/testdata/check/expr3.src |  2 +-
 6 files changed, 119 insertions(+), 16 deletions(-)

diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index d77cf8f7fa..8645834a6e 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -84,10 +84,18 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 
 	reason := ""
 	if ok, code := x.assignableTo(check, T, &reason); !ok {
-		if reason != "" {
-			check.errorf(x, code, "cannot use %s as %s value in %s: %s", x, T, context, reason)
+		if compilerErrorMessages {
+			if reason != "" {
+				check.errorf(x, code, "cannot use %s as type %s in %s:\n\t%s", x, T, context, reason)
+			} else {
+				check.errorf(x, code, "cannot use %s as type %s in %s", x, T, context)
+			}
 		} else {
-			check.errorf(x, code, "cannot use %s as %s value in %s", x, T, context)
+			if reason != "" {
+				check.errorf(x, code, "cannot use %s as %s value in %s: %s", x, T, context, reason)
+			} else {
+				check.errorf(x, code, "cannot use %s as %s value in %s", x, T, context)
+			}
 		}
 		x.mode = invalid
 	}
diff --git a/src/go/types/check.go b/src/go/types/check.go
index aef53b20de..38508c77a9 100644
--- a/src/go/types/check.go
+++ b/src/go/types/check.go
@@ -18,6 +18,10 @@ import (
 const (
 	debug = false // leave on during development
 	trace = false // turn on for detailed type resolution traces
+
+	// TODO(rfindley): add compiler error message handling from types2, guarded
+	// behind this flag, so that we can keep the code in sync.
+	compilerErrorMessages = false // match compiler error messages
 )
 
 // If forceStrict is set, the type-checker enforces additional
diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index eadc923f5e..530a29c5dd 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -68,10 +68,19 @@ func (check *Checker) conversion(x *operand, T Type) {
 
 	if !ok {
 		// TODO(rfindley): use types2-style error reporting here.
-		if cause != "" {
-			check.errorf(x, _InvalidConversion, "cannot convert %s to %s (%s)", x, T, cause)
+		if compilerErrorMessages {
+			if cause != "" {
+				// Add colon at end of line if we have a following cause.
+				check.errorf(x, _InvalidConversion, "cannot convert %s to type %s:\n\t%s", x, T, cause)
+			} else {
+				check.errorf(x, _InvalidConversion, "cannot convert %s to type %s", x, T)
+			}
 		} else {
-			check.errorf(x, _InvalidConversion, "cannot convert %s to %s", x, T)
+			if cause != "" {
+				check.errorf(x, _InvalidConversion, "cannot convert %s to %s (%s)", x, T, cause)
+			} else {
+				check.errorf(x, _InvalidConversion, "cannot convert %s to %s", x, T)
+			}
 		}
 		x.mode = invalid
 		return
diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index 98af6bfcd7..be91d39f50 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -6,6 +6,11 @@
 
 package types
 
+import (
+	"fmt"
+	"strings"
+)
+
 // Internal use of LookupFieldOrMethod: If the obj result is a method
 // associated with a concrete (non-interface) type, the method's signature
 // may not be fully set up. Call Checker.objDecl(obj, nil) before accessing
@@ -382,6 +387,59 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 	return
 }
 
+// missingMethodReason returns a string giving the detailed reason for a missing method m,
+// where m is missing from V, but required by T. It puts the reason in parentheses,
+// and may include more have/want info after that. If non-nil, wrongType is a relevant
+// method that matches in some way. It may have the correct name, but wrong type, or
+// it may have a pointer receiver.
+func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string {
+	var r string
+	var mname string
+	if compilerErrorMessages {
+		mname = m.Name() + " method"
+	} else {
+		mname = "method " + m.Name()
+	}
+	if wrongType != nil {
+		if Identical(m.typ, wrongType.typ) {
+			if m.Name() == wrongType.Name() {
+				r = fmt.Sprintf("(%s has pointer receiver)", mname)
+			} else {
+				r = fmt.Sprintf("(missing %s)\n\t\thave %s^^%s\n\t\twant %s^^%s",
+					mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ)
+			}
+		} else {
+			if compilerErrorMessages {
+				r = fmt.Sprintf("(wrong type for %s)\n\t\thave %s^^%s\n\t\twant %s^^%s",
+					mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ)
+			} else {
+				r = fmt.Sprintf("(wrong type for %s: have %s, want %s)",
+					mname, wrongType.typ, m.typ)
+			}
+		}
+		// This is a hack to print the function type without the leading
+		// 'func' keyword in the have/want printouts. We could change to have
+		// an extra formatting option for types2.Type that doesn't print out
+		// 'func'.
+		r = strings.Replace(r, "^^func", "", -1)
+	} else if IsInterface(T) {
+		if isInterfacePtr(V) {
+			r = fmt.Sprintf("(%s is pointer to interface, not interface)", V)
+		}
+	} else if isInterfacePtr(T) {
+		r = fmt.Sprintf("(%s is pointer to interface, not interface)", T)
+	}
+	if r == "" {
+		r = fmt.Sprintf("(missing %s)", mname)
+	}
+	return r
+}
+
+func isInterfacePtr(T Type) bool {
+	p, _ := under(T).(*Pointer)
+	return p != nil && IsInterface(p.base)
+}
+
 // assertableTo reports whether a value of type V can be asserted to have type T.
 // It returns (nil, false) as affirmative answer. Otherwise it returns a missing
 // method required by V and whether it is missing or just has the wrong type.
diff --git a/src/go/types/operand.go b/src/go/types/operand.go
index 6f902e9749..e8b5d00de4 100644
--- a/src/go/types/operand.go
+++ b/src/go/types/operand.go
@@ -276,16 +276,20 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 	if Ti, ok := Tu.(*Interface); ok {
 		if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* Implements(V, Ti) */ {
 			if reason != nil {
-				// TODO(gri) the error messages here should follow the style in Checker.typeAssertion (factor!)
-				if wrongType != nil {
-					if Identical(m.typ, wrongType.typ) {
-						*reason = fmt.Sprintf("missing method %s (%s has pointer receiver)", m.name, m.name)
-					} else {
-						*reason = fmt.Sprintf("wrong type for method %s (have %s, want %s)", m.Name(), wrongType.typ, m.typ)
-					}
-
+				if compilerErrorMessages {
+					*reason = check.sprintf("%s does not implement %s %s", x.typ, T,
+						check.missingMethodReason(x.typ, T, m, wrongType))
 				} else {
-					*reason = "missing method " + m.Name()
+					if wrongType != nil {
+						if Identical(m.typ, wrongType.typ) {
+							*reason = fmt.Sprintf("missing method %s (%s has pointer receiver)", m.name, m.name)
+						} else {
+							*reason = fmt.Sprintf("wrong type for method %s (have %s, want %s)", m.Name(), wrongType.typ, m.typ)
+						}
+
+					} else {
+						*reason = "missing method " + m.Name()
+					}
 				}
 			}
 			return false, _InvalidIfaceAssign
@@ -293,6 +297,26 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 		return true, 0
 	}
 
+	// Provide extra detail in compiler error messages in some cases when T is
+	// not an interface.
+	if check != nil && compilerErrorMessages {
+		if isInterfacePtr(Tu) {
+			if reason != nil {
+				*reason = check.sprintf("%s does not implement %s (%s is pointer to interface, not interface)", x.typ, T, T)
+			}
+			return false, _InvalidIfaceAssign
+		}
+		if Vi, _ := Vu.(*Interface); Vi != nil {
+			if m, _ := check.missingMethod(T, Vi, true); m == nil {
+				// T implements Vi, so give hint about type assertion.
+				if reason != nil {
+					*reason = check.sprintf("need type assertion")
+				}
+				return false, _IncompatibleAssign
+			}
+		}
+	}
+
 	// x is a bidirectional channel value, T is a channel
 	// type, x's type V and T have identical element types,
 	// and at least one of V or T is not a named type.
diff --git a/src/go/types/testdata/check/expr3.src b/src/go/types/testdata/check/expr3.src
index 3ab367810f..0f15c15a55 100644
--- a/src/go/types/testdata/check/expr3.src
+++ b/src/go/types/testdata/check/expr3.src
@@ -458,7 +458,7 @@ func type_asserts() {
 
 	var t I
 	_ = t /* ERROR "use of .* outside type switch" */ .(type)
-	_ = t /* ERROR "missing method m" */ .(T)
+	_ = t /* ERROR "m has pointer receiver" */ .(T)
 	_ = t.(*T)
 	_ = t /* ERROR "missing method m" */ .(T1)
 	_ = t /* ERROR "wrong type for method m" */ .(T2)

From 9bdbed1d963a840d8c23640bbd20bd4cb9776859 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 09:35:57 -0500
Subject: [PATCH 215/752] go/types, types2: complete methods on pointer
 receivers in missingMethod

We were not calling objDecl on methods on pointer receivers in
missingMethod. This may not have mattered before, but with lazy
completion of instance methods it is necessary.

Fixes #49579

Change-Id: Icddb1f3b16bef7d8017859734f9879a4f1cc18de
Reviewed-on: https://go-review.googlesource.com/c/go/+/364714
Trust: Robert Findley 
Trust: Dan Scales 
Run-TryBot: Robert Findley 
Reviewed-by: Robert Griesemer 
TryBot-Result: Go Bot 
---
 src/cmd/compile/internal/types2/lookup.go       | 17 +++++++++++------
 .../types2/testdata/fixedbugs/issue49579.go2    | 17 +++++++++++++++++
 src/go/types/lookup.go                          |  7 +++++++
 src/go/types/testdata/fixedbugs/issue49579.go2  | 17 +++++++++++++++++
 4 files changed, 52 insertions(+), 6 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue49579.go2
 create mode 100644 src/go/types/testdata/fixedbugs/issue49579.go2

diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index 4f50ea54b1..ee764c7d14 100644
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -71,6 +71,8 @@ func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 // lookupFieldOrMethod should only be called by LookupFieldOrMethod and missingMethod.
 // If checkFold is true, the lookup for methods will include looking for any method
 // which case-folds to the same as 'name' (used for giving helpful error messages).
+//
+// The resulting object may not be fully type-checked.
 func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name string) (obj Object, index []int, indirect bool) {
 	// WARNING: The code in this function is extremely subtle - do not modify casually!
 
@@ -352,14 +354,17 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 		if obj == nil {
 			ptr := NewPointer(V)
 			obj, _, _ = lookupFieldOrMethod(ptr, false, false, m.pkg, m.name)
-			if obj != nil {
-				return m, obj.(*Func)
+			if obj == nil {
+				// If we didn't find the exact method (even with pointer
+				// receiver), look to see if there is a method that
+				// matches m.name with case-folding.
+				obj, _, _ = lookupFieldOrMethod(V, false, true, m.pkg, m.name)
 			}
-			// If we didn't find the exact method (even with pointer
-			// receiver), look to see if there is a method that
-			// matches m.name with case-folding.
-			obj, _, _ := lookupFieldOrMethod(V, false, true, m.pkg, m.name)
 			if obj != nil {
+				// methods may not have a fully set up signature yet
+				if check != nil {
+					check.objDecl(obj, nil)
+				}
 				return m, obj.(*Func)
 			}
 		}
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49579.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49579.go2
new file mode 100644
index 0000000000..9e20ae5468
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49579.go2
@@ -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 p
+
+type I[F any] interface {
+	Q(*F)
+}
+
+func G[F any]() I[any] {
+	return g /* ERROR "missing method Q \(Q has pointer receiver\)" */ [F]{}
+}
+
+type g[F any] struct{}
+
+func (*g[F]) Q(*any) {}
diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index be91d39f50..6855ccdf27 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -69,6 +69,8 @@ func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 //           indirectly via different packages.)
 
 // lookupFieldOrMethod should only be called by LookupFieldOrMethod and missingMethod.
+//
+// The resulting object may not be fully type-checked.
 func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) {
 	// WARNING: The code in this function is extremely subtle - do not modify casually!
 
@@ -346,7 +348,12 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
 		if obj == nil {
 			ptr := NewPointer(V)
 			obj, _, _ = lookupFieldOrMethod(ptr, false, m.pkg, m.name)
+
 			if obj != nil {
+				// methods may not have a fully set up signature yet
+				if check != nil {
+					check.objDecl(obj, nil)
+				}
 				return m, obj.(*Func)
 			}
 		}
diff --git a/src/go/types/testdata/fixedbugs/issue49579.go2 b/src/go/types/testdata/fixedbugs/issue49579.go2
new file mode 100644
index 0000000000..9e20ae5468
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue49579.go2
@@ -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 p
+
+type I[F any] interface {
+	Q(*F)
+}
+
+func G[F any]() I[any] {
+	return g /* ERROR "missing method Q \(Q has pointer receiver\)" */ [F]{}
+}
+
+type g[F any] struct{}
+
+func (*g[F]) Q(*any) {}

From 0981724eaeb9e3a4553473072c38cf11822bc7fd Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 09:38:16 -0500
Subject: [PATCH 216/752] go/types: check for non-negative index in tparamIndex

There are code paths (particularly error formatting or tracing) that
call tparamIndex before the type parameter is bound. We cannot rely on
the index being non-negative.

Change-Id: Ibad91c691b4f319b0c7b465a750b679a8a7af6a1
Reviewed-on: https://go-review.googlesource.com/c/go/+/364715
Trust: Robert Findley 
Run-TryBot: Robert Findley 
Reviewed-by: Robert Griesemer 
TryBot-Result: Go Bot 
---
 src/cmd/compile/internal/types2/unify.go | 15 +++++++--------
 src/go/types/unify.go                    | 10 ++++++++--
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go
index 651bba1a6b..f663beec38 100644
--- a/src/cmd/compile/internal/types2/unify.go
+++ b/src/cmd/compile/internal/types2/unify.go
@@ -9,7 +9,6 @@ package types2
 import (
 	"bytes"
 	"fmt"
-	"internal/buildcfg"
 )
 
 // The unifier maintains two separate sets of type parameters x and y
@@ -162,13 +161,13 @@ func (d *tparamsList) index(typ Type) int {
 // If tpar is a type parameter in list, tparamIndex returns the type parameter index.
 // Otherwise, the result is < 0. tpar must not be nil.
 func tparamIndex(list []*TypeParam, tpar *TypeParam) int {
-	// Temporary work-around for getting around a crash
-	// with unified build.
-	// TODO(gri) investigate and implement proper fix
-	if buildcfg.Experiment.Unified && tpar.index < 0 {
-		return -1
-	}
-	if i := tpar.index; i < len(list) && list[i] == tpar {
+	// Once a type parameter is bound its index is >= 0. However, there are some
+	// code paths (namely tracing and type hashing) by which it is possible to
+	// arrive here with a type parameter that has not been bound, hence the check
+	// for 0 <= i below.
+	// TODO(rfindley): investigate a better approach for guarding against using
+	// unbound type parameters.
+	if i := tpar.index; 0 <= i && i < len(list) && list[i] == tpar {
 		return i
 	}
 	return -1
diff --git a/src/go/types/unify.go b/src/go/types/unify.go
index d3b86008ef..6cd653aee1 100644
--- a/src/go/types/unify.go
+++ b/src/go/types/unify.go
@@ -159,9 +159,15 @@ func (d *tparamsList) index(typ Type) int {
 }
 
 // If tpar is a type parameter in list, tparamIndex returns the type parameter index.
-// Otherwise, the result is < 0. tpar must not be nil.
+// Otherwise, the result is < 0. tpar must not be nil.j
 func tparamIndex(list []*TypeParam, tpar *TypeParam) int {
-	if i := tpar.index; i < len(list) && list[i] == tpar {
+	// Once a type parameter is bound its index is >= 0. However, there are some
+	// code paths (namely tracing and type hashing) by which it is possible to
+	// arrive here with a type parameter that has not been bound, hence the check
+	// for 0 <= i below.
+	// TODO(rfindley): investigate a better approach for guarding against using
+	// unbound type parameters.
+	if i := tpar.index; 0 <= i && i < len(list) && list[i] == tpar {
 		return i
 	}
 	return -1

From aa34ea2f4c57ea2648286463ef3f891e49b64fa8 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor 
Date: Wed, 17 Nov 2021 09:40:11 -0800
Subject: [PATCH 217/752] runtime: don't run TestCheckPtr/TestCheckPtr2 in
 short mode

Change-Id: I02c9bea1637c2694a76e7747cb8a2e3562301566
Reviewed-on: https://go-review.googlesource.com/c/go/+/364755
Trust: Ian Lance Taylor 
Run-TryBot: Ian Lance Taylor 
TryBot-Result: Go Bot 
Reviewed-by: Matthew Dempsky 
---
 src/runtime/checkptr_test.go | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/runtime/checkptr_test.go b/src/runtime/checkptr_test.go
index b3aea079c6..15011ec494 100644
--- a/src/runtime/checkptr_test.go
+++ b/src/runtime/checkptr_test.go
@@ -12,6 +12,12 @@ import (
 )
 
 func TestCheckPtr(t *testing.T) {
+	// This test requires rebuilding packages with -d=checkptr=1,
+	// so it's somewhat slow.
+	if testing.Short() {
+		t.Skip("skipping test in -short mode")
+	}
+
 	t.Parallel()
 	testenv.MustHaveGoRun(t)
 
@@ -57,6 +63,12 @@ func TestCheckPtr(t *testing.T) {
 }
 
 func TestCheckPtr2(t *testing.T) {
+	// This test requires rebuilding packages with -d=checkptr=2,
+	// so it's somewhat slow.
+	if testing.Short() {
+		t.Skip("skipping test in -short mode")
+	}
+
 	t.Parallel()
 	testenv.MustHaveGoRun(t)
 

From 88474d47ddeb5714a18923048beaa5dafa7196d5 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 10:39:36 -0500
Subject: [PATCH 218/752] go/types: underlying type of a type parameter is its
 constraint interface

This is a port of CL 359016 from types2 to go/types. Some of the code
around untyped nil differed (because we have to treat untyped nil
differently in go/types for historical reasons).

Updates #47916

Change-Id: Ifc428ed977bf2f4f84cc831f1a3527156940d7b8
Reviewed-on: https://go-review.googlesource.com/c/go/+/364716
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/assignments.go |  2 +-
 src/go/types/builtins.go    | 30 +++++++++++--
 src/go/types/call.go        |  2 +-
 src/go/types/conversions.go | 16 ++++---
 src/go/types/expr.go        | 34 +++++++++++++--
 src/go/types/index.go       | 86 +++++++++++++++++++++++++++++++++++++
 src/go/types/lookup.go      |  6 +--
 src/go/types/operand.go     |  9 ++--
 src/go/types/predicates.go  | 27 ++++++++----
 src/go/types/sizes.go       |  1 +
 src/go/types/struct.go      |  9 +++-
 src/go/types/type.go        |  9 +++-
 src/go/types/typeparam.go   | 23 +++++++++-
 src/go/types/typeset.go     |  4 ++
 src/go/types/typexpr.go     | 12 ++++--
 15 files changed, 231 insertions(+), 39 deletions(-)

diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index 8645834a6e..7e6a230b48 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -37,7 +37,7 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
 		// bool, rune, int, float64, complex128 or string respectively, depending
 		// on whether the value is a boolean, rune, integer, floating-point,
 		// complex, or string constant."
-		if T == nil || IsInterface(T) {
+		if T == nil || IsInterface(T) && !isTypeParam(T) {
 			if T == nil && x.typ == Typ[UntypedNil] {
 				check.errorf(x, _UntypedNil, "use of untyped nil in %s", context)
 				x.mode = invalid
diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index 5418d66aeb..5abfe8d35b 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -179,7 +179,28 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 				mode = value
 			}
 
+		case *Interface:
+			if tparamIsIface && isTypeParam(x.typ) {
+				if t.typeSet().underIs(func(t Type) bool {
+					switch t := arrayPtrDeref(t).(type) {
+					case *Basic:
+						if isString(t) && id == _Len {
+							return true
+						}
+					case *Array, *Slice, *Chan:
+						return true
+					case *Map:
+						if id == _Len {
+							return true
+						}
+					}
+					return false
+				}) {
+					mode = value
+				}
+			}
 		case *TypeParam:
+			assert(!tparamIsIface)
 			if t.underIs(func(t Type) bool {
 				switch t := arrayPtrDeref(t).(type) {
 				case *Basic:
@@ -797,16 +818,19 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 
 // hasVarSize reports if the size of type t is variable due to type parameters.
 func hasVarSize(t Type) bool {
-	switch t := under(t).(type) {
+	switch u := under(t).(type) {
 	case *Array:
-		return hasVarSize(t.elem)
+		return hasVarSize(u.elem)
 	case *Struct:
-		for _, f := range t.fields {
+		for _, f := range u.fields {
 			if hasVarSize(f.typ) {
 				return true
 			}
 		}
+	case *Interface:
+		return isTypeParam(t)
 	case *TypeParam:
+		assert(!tparamIsIface)
 		return true
 	case *Named, *Union:
 		unreachable()
diff --git a/src/go/types/call.go b/src/go/types/call.go
index 7cb6027f3b..940c0ff468 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -141,7 +141,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 					check.errorf(call.Args[0], _BadDotDotDotSyntax, "invalid use of ... in conversion to %s", T)
 					break
 				}
-				if t, _ := under(T).(*Interface); t != nil {
+				if t, _ := under(T).(*Interface); t != nil && !isTypeParam(T) {
 					if !t.IsMethodSet() {
 						check.errorf(call, _MisplacedConstraintIface, "cannot use interface %s in conversion (contains specific type constraints or is comparable)", T)
 						break
diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index 530a29c5dd..5995d5920f 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -98,7 +98,7 @@ 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) || x.isNil() {
+		if IsInterface(T) && !isTypeParam(T) || constArg && !isConstType(T) || x.isNil() {
 			final = Default(x.typ) // default type of untyped nil is untyped nil
 		} else if isInteger(x.typ) && allString(T) {
 			final = x.typ
@@ -129,19 +129,23 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 		return true
 	}
 
-	// "V and T have identical underlying types if tags are ignored"
+	// "V and T have identical underlying types if tags are ignored
+	// and V and T are not type parameters"
 	V := x.typ
 	Vu := under(V)
 	Tu := under(T)
-	if IdenticalIgnoreTags(Vu, Tu) {
+	Vp, _ := V.(*TypeParam)
+	Tp, _ := T.(*TypeParam)
+	if IdenticalIgnoreTags(Vu, Tu) && Vp == nil && Tp == nil {
 		return true
 	}
 
 	// "V and T are unnamed pointer types and their pointer base types
-	// have identical underlying types if tags are ignored"
+	// have identical underlying types if tags are ignored
+	// and their pointer base types are not type parameters"
 	if V, ok := V.(*Pointer); ok {
 		if T, ok := T.(*Pointer); ok {
-			if IdenticalIgnoreTags(under(V.base), under(T.base)) {
+			if IdenticalIgnoreTags(under(V.base), under(T.base)) && !isTypeParam(V.base) && !isTypeParam(T.base) {
 				return true
 			}
 		}
@@ -195,8 +199,6 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 	}
 
 	// optimization: if we don't have type parameters, we're done
-	Vp, _ := V.(*TypeParam)
-	Tp, _ := T.(*TypeParam)
 	if Vp == nil && Tp == nil {
 		return false
 	}
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 5e66a4a4b5..84eb59d1d0 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -598,7 +598,11 @@ func (check *Checker) updateExprVal(x ast.Expr, val constant.Value) {
 func (check *Checker) convertUntyped(x *operand, target Type) {
 	newType, val, code := check.implicitTypeAndValue(x, target)
 	if code != 0 {
-		check.invalidConversion(code, x, safeUnderlying(target))
+		t := target
+		if !tparamIsIface || !isTypeParam(target) {
+			t = safeUnderlying(target)
+		}
+		check.invalidConversion(code, x, t)
 		x.mode = invalid
 		return
 	}
@@ -678,6 +682,7 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 		}
 	case *TypeParam:
 		// TODO(gri) review this code - doesn't look quite right
+		assert(!tparamIsIface)
 		ok := u.underIs(func(t Type) bool {
 			if t == nil {
 				return false
@@ -693,6 +698,24 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 			return Typ[UntypedNil], nil, 0
 		}
 	case *Interface:
+		if tparamIsIface && isTypeParam(target) {
+			// TODO(gri) review this code - doesn't look quite right
+			ok := u.typeSet().underIs(func(t Type) bool {
+				if t == nil {
+					return false
+				}
+				target, _, _ := check.implicitTypeAndValue(x, t)
+				return target != nil
+			})
+			if !ok {
+				return nil, nil, _InvalidUntypedConversion
+			}
+			// keep nil untyped (was bug #39755)
+			if x.isNil() {
+				return Typ[UntypedNil], nil, 0
+			}
+			break
+		}
 		// Values must have concrete dynamic types. If the value is nil,
 		// keep it untyped (this is important for tools such as go vet which
 		// need the dynamic type for argument checking of say, print
@@ -961,8 +984,9 @@ func (check *Checker) binary(x *operand, e ast.Expr, lhs, rhs ast.Expr, op token
 		return
 	}
 
+	// TODO(gri) make canMix more efficient - called for each binary operation
 	canMix := func(x, y *operand) bool {
-		if IsInterface(x.typ) || IsInterface(y.typ) {
+		if IsInterface(x.typ) && !isTypeParam(x.typ) || IsInterface(y.typ) && !isTypeParam(y.typ) {
 			return true
 		}
 		if allBoolean(x.typ) != allBoolean(y.typ) {
@@ -1219,7 +1243,11 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
 		case hint != nil:
 			// no composite literal type present - use hint (element type of enclosing type)
 			typ = hint
-			base, _ = deref(under(typ)) // *T implies &T{}
+			base = typ
+			if !isTypeParam(typ) {
+				base = under(typ)
+			}
+			base, _ = deref(base) // *T implies &T{}
 
 		default:
 			// TODO(gri) provide better error messages depending on context
diff --git a/src/go/types/index.go b/src/go/types/index.go
index 0284716277..2ff33814e5 100644
--- a/src/go/types/index.go
+++ b/src/go/types/index.go
@@ -100,8 +100,94 @@ func (check *Checker) indexExpr(x *operand, e *typeparams.IndexExpr) (isFuncInst
 		x.expr = e.Orig
 		return false
 
+	case *Interface:
+		// Note: The body of this 'if' statement is the same as the body
+		//       of the case for type parameters below. If we keep both
+		//       these branches we should factor out the code.
+		if tparamIsIface && isTypeParam(x.typ) {
+			// TODO(gri) report detailed failure cause for better error messages
+			var key, elem Type // key != nil: we must have all maps
+			mode := variable   // non-maps result mode
+			// TODO(gri) factor out closure and use it for non-typeparam cases as well
+			if typ.typeSet().underIs(func(u Type) bool {
+				l := int64(-1) // valid if >= 0
+				var k, e Type  // k is only set for maps
+				switch t := u.(type) {
+				case *Basic:
+					if isString(t) {
+						e = universeByte
+						mode = value
+					}
+				case *Array:
+					l = t.len
+					e = t.elem
+					if x.mode != variable {
+						mode = value
+					}
+				case *Pointer:
+					if t, _ := under(t.base).(*Array); t != nil {
+						l = t.len
+						e = t.elem
+					}
+				case *Slice:
+					e = t.elem
+				case *Map:
+					k = t.key
+					e = t.elem
+				}
+				if e == nil {
+					return false
+				}
+				if elem == nil {
+					// first type
+					length = l
+					key, elem = k, e
+					return true
+				}
+				// all map keys must be identical (incl. all nil)
+				// (that is, we cannot mix maps with other types)
+				if !Identical(key, k) {
+					return false
+				}
+				// all element types must be identical
+				if !Identical(elem, e) {
+					return false
+				}
+				// track the minimal length for arrays, if any
+				if l >= 0 && l < length {
+					length = l
+				}
+				return true
+			}) {
+				// For maps, the index expression must be assignable to the map key type.
+				if key != nil {
+					index := check.singleIndex(e)
+					if index == nil {
+						x.mode = invalid
+						return false
+					}
+					var k operand
+					check.expr(&k, index)
+					check.assignment(&k, key, "map index")
+					// ok to continue even if indexing failed - map element type is known
+					x.mode = mapindex
+					x.typ = elem
+					x.expr = e
+					return false
+				}
+
+				// no maps
+				valid = true
+				x.mode = mode
+				x.typ = elem
+			}
+		}
 	case *TypeParam:
+		// Note: The body of this case is the same as the body of the 'if'
+		//       statement in the interface case above. If we keep both
+		//       these branches we should factor out the code.
 		// TODO(gri) report detailed failure cause for better error messages
+		assert(!tparamIsIface)
 		var key, elem Type // key != nil: we must have all maps
 		mode := variable   // non-maps result mode
 		// TODO(gri) factor out closure and use it for non-typeparam cases as well
diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index 6855ccdf27..16a9890199 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -429,11 +429,11 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string
 		// an extra formatting option for types2.Type that doesn't print out
 		// 'func'.
 		r = strings.Replace(r, "^^func", "", -1)
-	} else if IsInterface(T) {
+	} else if IsInterface(T) && !isTypeParam(T) {
 		if isInterfacePtr(V) {
 			r = fmt.Sprintf("(%s is pointer to interface, not interface)", V)
 		}
-	} else if isInterfacePtr(T) {
+	} else if isInterfacePtr(T) && !isTypeParam(T) {
 		r = fmt.Sprintf("(%s is pointer to interface, not interface)", T)
 	}
 	if r == "" {
@@ -444,7 +444,7 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string
 
 func isInterfacePtr(T Type) bool {
 	p, _ := under(T).(*Pointer)
-	return p != nil && IsInterface(p.base)
+	return p != nil && IsInterface(p.base) && !isTypeParam(T)
 }
 
 // assertableTo reports whether a value of type V can be asserted to have type T.
diff --git a/src/go/types/operand.go b/src/go/types/operand.go
index e8b5d00de4..8cc5eda866 100644
--- a/src/go/types/operand.go
+++ b/src/go/types/operand.go
@@ -267,13 +267,14 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 	// Vu is typed
 
 	// x's type V and T have identical underlying types
-	// and at least one of V or T is not a named type.
-	if Identical(Vu, Tu) && (!hasName(V) || !hasName(T)) {
+	// and at least one of V or T is not a named type
+	// and neither V nor T is a type parameter.
+	if Identical(Vu, Tu) && (!hasName(V) || !hasName(T)) && Vp == nil && Tp == nil {
 		return true, 0
 	}
 
 	// T is an interface type and x implements T and T is not a type parameter
-	if Ti, ok := Tu.(*Interface); ok {
+	if Ti, ok := Tu.(*Interface); ok && Tp == nil {
 		if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* Implements(V, Ti) */ {
 			if reason != nil {
 				if compilerErrorMessages {
@@ -306,7 +307,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er
 			}
 			return false, _InvalidIfaceAssign
 		}
-		if Vi, _ := Vu.(*Interface); Vi != nil {
+		if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil {
 			if m, _ := check.missingMethod(T, Vi, true); m == nil {
 				// T implements Vi, so give hint about type assertion.
 				if reason != nil {
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index 78ad6c4f23..5204eb0c29 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -49,13 +49,10 @@ func allNumericOrString(typ Type) bool { return allBasic(typ, IsNumeric|IsString
 // for all specific types of the type parameter's type set.
 // allBasic(t, info) is an optimized version of isBasic(structuralType(t), info).
 func allBasic(t Type, info BasicInfo) bool {
-	switch u := under(t).(type) {
-	case *Basic:
-		return u.info&info != 0
-	case *TypeParam:
-		return u.is(func(t *term) bool { return t != nil && isBasic(t.typ, info) })
+	if tpar, _ := t.(*TypeParam); tpar != nil {
+		return tpar.is(func(t *term) bool { return t != nil && isBasic(t.typ, info) })
 	}
-	return false
+	return isBasic(t, info)
 }
 
 // hasName reports whether t has a name. This includes
@@ -124,7 +121,7 @@ func comparable(T Type, seen map[Type]bool) bool {
 		// assume invalid types to be comparable
 		// to avoid follow-up errors
 		return t.kind != UntypedNil
-	case *Pointer, *Interface, *Chan:
+	case *Pointer, *Chan:
 		return true
 	case *Struct:
 		for _, f := range t.fields {
@@ -135,7 +132,13 @@ func comparable(T Type, seen map[Type]bool) bool {
 		return true
 	case *Array:
 		return comparable(t.elem, seen)
+	case *Interface:
+		if tparamIsIface && isTypeParam(T) {
+			return t.IsComparable()
+		}
+		return true
 	case *TypeParam:
+		assert(!tparamIsIface)
 		return t.iface().IsComparable()
 	}
 	return false
@@ -146,9 +149,17 @@ func hasNil(t Type) bool {
 	switch u := under(t).(type) {
 	case *Basic:
 		return u.kind == UnsafePointer
-	case *Slice, *Pointer, *Signature, *Interface, *Map, *Chan:
+	case *Slice, *Pointer, *Signature, *Map, *Chan:
+		return true
+	case *Interface:
+		if tparamIsIface && isTypeParam(t) {
+			return u.typeSet().underIs(func(u Type) bool {
+				return u != nil && hasNil(u)
+			})
+		}
 		return true
 	case *TypeParam:
+		assert(!tparamIsIface)
 		return u.underIs(func(u Type) bool {
 			return u != nil && hasNil(u)
 		})
diff --git a/src/go/types/sizes.go b/src/go/types/sizes.go
index 9a119138dd..a921525062 100644
--- a/src/go/types/sizes.go
+++ b/src/go/types/sizes.go
@@ -67,6 +67,7 @@ func (s *StdSizes) Alignof(T Type) int64 {
 	case *Slice, *Interface:
 		// Multiword data structures are effectively structs
 		// in which each element has size WordSize.
+		assert(!tparamIsIface || !isTypeParam(T))
 		return s.WordSize
 	case *Basic:
 		// Strings are like slices and interfaces.
diff --git a/src/go/types/struct.go b/src/go/types/struct.go
index 84af8a3f48..53204dc381 100644
--- a/src/go/types/struct.go
+++ b/src/go/types/struct.go
@@ -143,24 +143,29 @@ func (check *Checker) structType(styp *Struct, e *ast.StructType) {
 
 			check.later(func() {
 				t, isPtr := deref(embeddedTyp)
-				switch t := under(t).(type) {
+				switch u := under(t).(type) {
 				case *Basic:
 					if t == Typ[Invalid] {
 						// error was reported before
 						return
 					}
 					// unsafe.Pointer is treated like a regular pointer
-					if t.kind == UnsafePointer {
+					if u.kind == UnsafePointer {
 						check.error(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be unsafe.Pointer")
 					}
 				case *Pointer:
 					check.error(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer")
 				case *TypeParam:
+					assert(!tparamIsIface)
 					// This error code here is inconsistent with other error codes for
 					// invalid embedding, because this restriction may be relaxed in the
 					// future, and so it did not warrant a new error code.
 					check.error(embeddedPos, _MisplacedTypeParam, "embedded field type cannot be a (pointer to a) type parameter")
 				case *Interface:
+					if tparamIsIface && isTypeParam(t) {
+						check.error(embeddedPos, _MisplacedTypeParam, "embedded field type cannot be a (pointer to a) type parameter")
+						break
+					}
 					if isPtr {
 						check.error(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer to an interface")
 					}
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 756bdcf0a5..dcf678a27a 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -21,8 +21,13 @@ type Type interface {
 // under must only be called when a type is known
 // to be fully set up.
 func under(t Type) Type {
-	if n := asNamed(t); n != nil {
-		return n.under()
+	switch t := t.(type) {
+	case *Named:
+		return t.under()
+	case *TypeParam:
+		if tparamIsIface {
+			return t.iface()
+		}
 	}
 	return t
 }
diff --git a/src/go/types/typeparam.go b/src/go/types/typeparam.go
index 731b746d05..084130fc74 100644
--- a/src/go/types/typeparam.go
+++ b/src/go/types/typeparam.go
@@ -9,6 +9,12 @@ import (
 	"sync/atomic"
 )
 
+// If set, the underlying type of a type parameter is
+// is the underlying type of its type constraint, i.e.,
+// an interface. With that, a type parameter satisfies
+// isInterface.
+const tparamIsIface = false
+
 // Note: This is a uint32 rather than a uint64 because the
 // respective 64 bit atomic instructions are not available
 // on all platforms.
@@ -72,13 +78,21 @@ func (t *TypeParam) SetConstraint(bound Type) {
 	t.bound = bound
 }
 
-func (t *TypeParam) Underlying() Type { return t }
-func (t *TypeParam) String() string   { return TypeString(t, nil) }
+func (t *TypeParam) Underlying() Type {
+	if tparamIsIface {
+		return t.iface()
+	}
+	return t
+}
+
+func (t *TypeParam) String() string { return TypeString(t, nil) }
 
 // ----------------------------------------------------------------------------
 // Implementation
 
 // iface returns the constraint interface of t.
+// TODO(gri) If we make tparamIsIface the default, this should be renamed to under
+//           (similar to Named.under).
 func (t *TypeParam) iface() *Interface {
 	bound := t.bound
 
@@ -91,8 +105,13 @@ func (t *TypeParam) iface() *Interface {
 			return &emptyInterface
 		}
 	case *Interface:
+		if tparamIsIface && isTypeParam(bound) {
+			// error is reported in Checker.collectTypeParams
+			return &emptyInterface
+		}
 		ityp = u
 	case *TypeParam:
+		assert(!tparamIsIface)
 		// error is reported in Checker.collectTypeParams
 		return &emptyInterface
 	}
diff --git a/src/go/types/typeset.go b/src/go/types/typeset.go
index d0464aeaa0..d98080069c 100644
--- a/src/go/types/typeset.go
+++ b/src/go/types/typeset.go
@@ -266,6 +266,8 @@ func computeInterfaceTypeSet(check *Checker, pos token.Pos, ityp *Interface) *_T
 		var terms termlist
 		switch u := under(typ).(type) {
 		case *Interface:
+			// For now we don't permit type parameters as constraints.
+			assert(!isTypeParam(typ))
 			tset := computeInterfaceTypeSet(check, pos, u)
 			// If typ is local, an error was already reported where typ is specified/defined.
 			if check != nil && check.isImportedConstraint(typ) && !check.allowVersion(check.pkg, 1, 18) {
@@ -365,6 +367,8 @@ func computeUnionTypeSet(check *Checker, pos token.Pos, utyp *Union) *_TypeSet {
 		var terms termlist
 		switch u := under(t.typ).(type) {
 		case *Interface:
+			// For now we don't permit type parameters as constraints.
+			assert(!isTypeParam(t.typ))
 			terms = computeInterfaceTypeSet(check, pos, u).terms
 		default:
 			if t.typ == Typ[Invalid] {
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 89264ee9eb..c6ab7cd564 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -141,9 +141,15 @@ func (check *Checker) typ(e ast.Expr) Type {
 // constraint interface.
 func (check *Checker) varType(e ast.Expr) Type {
 	typ := check.definedType(e, nil)
-	// We don't want to call under() (via toInterface) or complete interfaces while we
-	// are in the middle of type-checking parameter declarations that might belong to
-	// interface methods. Delay this check to the end of type-checking.
+
+	// If we have a type parameter there's nothing to do.
+	if isTypeParam(typ) {
+		return typ
+	}
+
+	// We don't want to call under() or complete interfaces while we are in
+	// the middle of type-checking parameter declarations that might belong
+	// to interface methods. Delay this check to the end of type-checking.
 	check.later(func() {
 		if t, _ := under(typ).(*Interface); t != nil {
 			tset := computeInterfaceTypeSet(check, e.Pos(), t) // TODO(gri) is this the correct position?

From 9a33945f2cc4b2108defdcdea80dc0ebe5af3c24 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 10:42:13 -0500
Subject: [PATCH 219/752] go/types: set tparamsIsIface to true

This is a port of CL 363155 from types2 to go/types.

Change-Id: Ic24f8c88513599c8f4685f0b66d3782ac4e6831a
Reviewed-on: https://go-review.googlesource.com/c/go/+/364717
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/typeparam.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/go/types/typeparam.go b/src/go/types/typeparam.go
index 084130fc74..f000d8f108 100644
--- a/src/go/types/typeparam.go
+++ b/src/go/types/typeparam.go
@@ -13,7 +13,7 @@ import (
 // is the underlying type of its type constraint, i.e.,
 // an interface. With that, a type parameter satisfies
 // isInterface.
-const tparamIsIface = false
+const tparamIsIface = true
 
 // Note: This is a uint32 rather than a uint64 because the
 // respective 64 bit atomic instructions are not available

From a218365faeed6d62d3becabf0c8700f0e0b3a734 Mon Sep 17 00:00:00 2001
From: Roland Shoemaker 
Date: Wed, 17 Nov 2021 13:03:13 -0800
Subject: [PATCH 220/752] cmd/go: skip broken fuzz test

For #49047

Change-Id: If06ce033f7bfd23d640311f1be261afab8332028
Reviewed-on: https://go-review.googlesource.com/c/go/+/364758
Trust: Roland Shoemaker 
Run-TryBot: Roland Shoemaker 
Reviewed-by: Bryan C. Mills 
TryBot-Result: Go Bot 
---
 src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt b/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
index 3764dcb915..5b1e26be24 100644
--- a/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
+++ b/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
@@ -1,3 +1,5 @@
+skip  # https://golang.org/issue/49047
+
 # TODO(jayconrod): support shared memory on more platforms.
 [!darwin] [!linux] [!windows] skip
 

From 0440fb833405a5c61ed0269af9c5897b03390bac Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor 
Date: Wed, 17 Nov 2021 11:07:44 -0800
Subject: [PATCH 221/752] runtime: make faketime more robust against GC

When using faketime, only run the scavenger for one loop.
It tries to run for 1 ms, but with faketime that calculation fails.

Prohibit write barriers in the faketime write function, in case
the GC wants to print something (e.g., with GODEBUG=gctrace=1).

Fixes #49614

Change-Id: Iab5097fe78b6e0032ea8b493088264dfb25013c6
Reviewed-on: https://go-review.googlesource.com/c/go/+/364757
Trust: Ian Lance Taylor 
Run-TryBot: Ian Lance Taylor 
Reviewed-by: Michael Knyszek 
TryBot-Result: Go Bot 
---
 src/runtime/mgcscavenge.go | 5 +++++
 src/runtime/time_fake.go   | 4 ++++
 2 files changed, 9 insertions(+)

diff --git a/src/runtime/mgcscavenge.go b/src/runtime/mgcscavenge.go
index 286aa1bbae..0399c2d21c 100644
--- a/src/runtime/mgcscavenge.go
+++ b/src/runtime/mgcscavenge.go
@@ -344,6 +344,11 @@ func bgscavenge(c chan int) {
 				crit += float64(end - start)
 			}
 			released += r
+
+			// When using fake time just do one loop.
+			if faketime != 0 {
+				break
+			}
 		}
 
 		if released == 0 {
diff --git a/src/runtime/time_fake.go b/src/runtime/time_fake.go
index 107f6be335..b5e0463588 100644
--- a/src/runtime/time_fake.go
+++ b/src/runtime/time_fake.go
@@ -41,6 +41,10 @@ func time_now() (sec int64, nsec int32, mono int64) {
 	return faketime / 1e9, int32(faketime % 1e9), faketime
 }
 
+// write is like the Unix write system call.
+// We have to avoid write barriers to avoid potential deadlock
+// on write calls.
+//go:nowritebarrierrec
 func write(fd uintptr, p unsafe.Pointer, n int32) int32 {
 	if !(fd == 1 || fd == 2) {
 		// Do an ordinary write.

From e3b48af57560e730a512d79f9d338aafac61f944 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 18:56:46 -0500
Subject: [PATCH 222/752] go/types: remove a review comment in
 implicitTypeAndValue

This is a clean port of CL 363440 from types2 to go/types.

Change-Id: Ibbef41b5b599d5c88f7122670ab87aa5be512c0a
Reviewed-on: https://go-review.googlesource.com/c/go/+/364894
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/expr.go | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 84eb59d1d0..0a3fa72c97 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -681,16 +681,14 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 			return nil, nil, _InvalidUntypedConversion
 		}
 	case *TypeParam:
-		// TODO(gri) review this code - doesn't look quite right
 		assert(!tparamIsIface)
-		ok := u.underIs(func(t Type) bool {
-			if t == nil {
+		if !u.underIs(func(u Type) bool {
+			if u == nil {
 				return false
 			}
-			target, _, _ := check.implicitTypeAndValue(x, t)
-			return target != nil
-		})
-		if !ok {
+			t, _, _ := check.implicitTypeAndValue(x, u)
+			return t != nil
+		}) {
 			return nil, nil, _InvalidUntypedConversion
 		}
 		// keep nil untyped (was bug #39755)
@@ -699,15 +697,13 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 		}
 	case *Interface:
 		if tparamIsIface && isTypeParam(target) {
-			// TODO(gri) review this code - doesn't look quite right
-			ok := u.typeSet().underIs(func(t Type) bool {
-				if t == nil {
+			if !u.typeSet().underIs(func(u Type) bool {
+				if u == nil {
 					return false
 				}
-				target, _, _ := check.implicitTypeAndValue(x, t)
-				return target != nil
-			})
-			if !ok {
+				t, _, _ := check.implicitTypeAndValue(x, u)
+				return t != nil
+			}) {
 				return nil, nil, _InvalidUntypedConversion
 			}
 			// keep nil untyped (was bug #39755)

From 9115a7ba4a7e198befe26d69b740a34b495e1db5 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 19:04:17 -0500
Subject: [PATCH 223/752] go/types: remove asNamed

This is a port of CL 363441 from types2 to go/types, with an additional
adjustment in methodset.go.

Change-Id: Ia04dcfb70bb9f6af6f45175dee3334dba7b2768e
Reviewed-on: https://go-review.googlesource.com/c/go/+/364895
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/decl.go      |  2 +-
 src/go/types/lookup.go    |  7 ++++---
 src/go/types/methodset.go |  2 +-
 src/go/types/type.go      |  9 ---------
 src/go/types/unify.go     | 14 ++++++--------
 src/go/types/universe.go  |  2 +-
 6 files changed, 13 insertions(+), 23 deletions(-)

diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 4f28553aa6..600467620c 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -795,7 +795,7 @@ func (check *Checker) collectMethods(obj *TypeName) {
 
 	// spec: "If the base type is a struct type, the non-blank method
 	// and field names must be distinct."
-	base := asNamed(obj.typ) // shouldn't fail but be conservative
+	base, _ := obj.typ.(*Named) // shouldn't fail but be conservative
 	if base != nil {
 		u := base.under()
 		if t, _ := u.(*Struct); t != nil {
diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index 16a9890199..1462d30b30 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -50,8 +50,8 @@ func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 	// Thus, if we have a named pointer type, proceed with the underlying
 	// pointer type but discard the result if it is a method since we would
 	// not have found it for T (see also issue 8590).
-	if t := asNamed(T); t != nil {
-		if p, _ := safeUnderlying(t).(*Pointer); p != nil {
+	if t, _ := T.(*Named); t != nil {
+		if p, _ := t.Underlying().(*Pointer); p != nil {
 			obj, index, indirect = lookupFieldOrMethod(p, false, pkg, name)
 			if _, ok := obj.(*Func); ok {
 				return nil, nil, false
@@ -114,7 +114,7 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 
 			// If we have a named type, we may have associated methods.
 			// Look for those first.
-			if named := asNamed(typ); named != nil {
+			if named, _ := typ.(*Named); named != nil {
 				if seen[named] {
 					// We have seen this type before, at a more shallow depth
 					// (note that multiples of this type at the current depth
@@ -129,6 +129,7 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 				seen[named] = true
 
 				// look for a matching attached method
+				named.resolve(nil)
 				if i, m := lookupMethod(named.methods, pkg, name); m != nil {
 					// potential match
 					// caution: method may not have a proper signature yet
diff --git a/src/go/types/methodset.go b/src/go/types/methodset.go
index 89e4b57627..e17be7c41a 100644
--- a/src/go/types/methodset.go
+++ b/src/go/types/methodset.go
@@ -111,7 +111,7 @@ func NewMethodSet(T Type) *MethodSet {
 
 			// If we have a named type, we may have associated methods.
 			// Look for those first.
-			if named := asNamed(typ); named != nil {
+			if named, _ := typ.(*Named); named != nil {
 				if seen[named] {
 					// We have seen this type before, at a more shallow depth
 					// (note that multiples of this type at the current depth
diff --git a/src/go/types/type.go b/src/go/types/type.go
index dcf678a27a..1d672135b8 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -87,12 +87,3 @@ func structuralType(typ Type) Type {
 	}
 	return nil
 }
-
-// If t is a defined type, asNamed returns that type (possibly after resolving it), otherwise it returns nil.
-func asNamed(t Type) *Named {
-	e, _ := t.(*Named)
-	if e != nil {
-		e.resolve(nil)
-	}
-	return e
-}
diff --git a/src/go/types/unify.go b/src/go/types/unify.go
index 6cd653aee1..5dcb35f6ec 100644
--- a/src/go/types/unify.go
+++ b/src/go/types/unify.go
@@ -241,14 +241,12 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool {
 		// If exact unification is known to fail because we attempt to
 		// match a type name against an unnamed type literal, consider
 		// the underlying type of the named type.
-		// (Subtle: We use hasName to include any type with a name (incl.
-		// basic types and type parameters. We use asNamed because we only
-		// want *Named types.)
-		switch {
-		case !hasName(x) && y != nil && asNamed(y) != nil:
-			return u.nify(x, under(y), p)
-		case x != nil && asNamed(x) != nil && !hasName(y):
-			return u.nify(under(x), y, p)
+		// (We use !hasName to exclude any type with a name, including
+		// basic types and type parameters; the rest are unamed types.)
+		if nx, _ := x.(*Named); nx != nil && !hasName(y) {
+			return u.nify(nx.under(), y, p)
+		} else if ny, _ := y.(*Named); ny != nil && !hasName(x) {
+			return u.nify(x, ny.under(), p)
 		}
 	}
 
diff --git a/src/go/types/universe.go b/src/go/types/universe.go
index e30ab12bc3..edda56fc0d 100644
--- a/src/go/types/universe.go
+++ b/src/go/types/universe.go
@@ -244,7 +244,7 @@ func def(obj Object) {
 		return // nothing to do
 	}
 	// fix Obj link for named types
-	if typ := asNamed(obj.Type()); typ != nil {
+	if typ, _ := obj.Type().(*Named); typ != nil {
 		typ.obj = obj.(*TypeName)
 	}
 	// exported identifiers go into package unsafe

From b95bff0318150e0b2869079bf2c0068fb4bcb17c Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 19:14:58 -0500
Subject: [PATCH 224/752] go/types: remove tparamIsIface flag and corresponding
 dead code

This is a port of CL 363654 from types2 to go/types.

Change-Id: I64041615ccc7f11f2e4ae395b063ec5141ccf2cf
Reviewed-on: https://go-review.googlesource.com/c/go/+/364896
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/builtins.go   | 27 ++----------
 src/go/types/decl.go       |  4 ++
 src/go/types/expr.go       | 19 +-------
 src/go/types/index.go      | 89 ++------------------------------------
 src/go/types/predicates.go | 18 +-------
 src/go/types/sizes.go      |  7 ++-
 src/go/types/struct.go     | 11 ++---
 src/go/types/type.go       |  4 +-
 src/go/types/typeparam.go  | 17 +-------
 9 files changed, 27 insertions(+), 169 deletions(-)

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index 5abfe8d35b..b547cddeb1 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -180,28 +180,10 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 			}
 
 		case *Interface:
-			if tparamIsIface && isTypeParam(x.typ) {
-				if t.typeSet().underIs(func(t Type) bool {
-					switch t := arrayPtrDeref(t).(type) {
-					case *Basic:
-						if isString(t) && id == _Len {
-							return true
-						}
-					case *Array, *Slice, *Chan:
-						return true
-					case *Map:
-						if id == _Len {
-							return true
-						}
-					}
-					return false
-				}) {
-					mode = value
-				}
+			if !isTypeParam(x.typ) {
+				break
 			}
-		case *TypeParam:
-			assert(!tparamIsIface)
-			if t.underIs(func(t Type) bool {
+			if t.typeSet().underIs(func(t Type) bool {
 				switch t := arrayPtrDeref(t).(type) {
 				case *Basic:
 					if isString(t) && id == _Len {
@@ -829,9 +811,6 @@ func hasVarSize(t Type) bool {
 		}
 	case *Interface:
 		return isTypeParam(t)
-	case *TypeParam:
-		assert(!tparamIsIface)
-		return true
 	case *Named, *Union:
 		unreachable()
 	}
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index 600467620c..c85087018c 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -725,6 +725,10 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list *ast.FieldList
 	check.later(func() {
 		for i, bound := range bounds {
 			if isTypeParam(bound) {
+				// We may be able to allow this since it is now well-defined what
+				// the underlying type and thus type set of a type parameter is.
+				// But we may need some additional form of cycle detection within
+				// type parameter lists.
 				check.error(posns[i], _MisplacedTypeParam, "cannot use a type parameter as constraint")
 			}
 		}
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 0a3fa72c97..e93a2bc7c8 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -599,7 +599,7 @@ func (check *Checker) convertUntyped(x *operand, target Type) {
 	newType, val, code := check.implicitTypeAndValue(x, target)
 	if code != 0 {
 		t := target
-		if !tparamIsIface || !isTypeParam(target) {
+		if !isTypeParam(target) {
 			t = safeUnderlying(target)
 		}
 		check.invalidConversion(code, x, t)
@@ -680,23 +680,8 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
 		default:
 			return nil, nil, _InvalidUntypedConversion
 		}
-	case *TypeParam:
-		assert(!tparamIsIface)
-		if !u.underIs(func(u Type) bool {
-			if u == nil {
-				return false
-			}
-			t, _, _ := check.implicitTypeAndValue(x, u)
-			return t != nil
-		}) {
-			return nil, nil, _InvalidUntypedConversion
-		}
-		// keep nil untyped (was bug #39755)
-		if x.isNil() {
-			return Typ[UntypedNil], nil, 0
-		}
 	case *Interface:
-		if tparamIsIface && isTypeParam(target) {
+		if isTypeParam(target) {
 			if !u.typeSet().underIs(func(u Type) bool {
 				if u == nil {
 					return false
diff --git a/src/go/types/index.go b/src/go/types/index.go
index 2ff33814e5..54398ad19b 100644
--- a/src/go/types/index.go
+++ b/src/go/types/index.go
@@ -101,97 +101,14 @@ func (check *Checker) indexExpr(x *operand, e *typeparams.IndexExpr) (isFuncInst
 		return false
 
 	case *Interface:
-		// Note: The body of this 'if' statement is the same as the body
-		//       of the case for type parameters below. If we keep both
-		//       these branches we should factor out the code.
-		if tparamIsIface && isTypeParam(x.typ) {
-			// TODO(gri) report detailed failure cause for better error messages
-			var key, elem Type // key != nil: we must have all maps
-			mode := variable   // non-maps result mode
-			// TODO(gri) factor out closure and use it for non-typeparam cases as well
-			if typ.typeSet().underIs(func(u Type) bool {
-				l := int64(-1) // valid if >= 0
-				var k, e Type  // k is only set for maps
-				switch t := u.(type) {
-				case *Basic:
-					if isString(t) {
-						e = universeByte
-						mode = value
-					}
-				case *Array:
-					l = t.len
-					e = t.elem
-					if x.mode != variable {
-						mode = value
-					}
-				case *Pointer:
-					if t, _ := under(t.base).(*Array); t != nil {
-						l = t.len
-						e = t.elem
-					}
-				case *Slice:
-					e = t.elem
-				case *Map:
-					k = t.key
-					e = t.elem
-				}
-				if e == nil {
-					return false
-				}
-				if elem == nil {
-					// first type
-					length = l
-					key, elem = k, e
-					return true
-				}
-				// all map keys must be identical (incl. all nil)
-				// (that is, we cannot mix maps with other types)
-				if !Identical(key, k) {
-					return false
-				}
-				// all element types must be identical
-				if !Identical(elem, e) {
-					return false
-				}
-				// track the minimal length for arrays, if any
-				if l >= 0 && l < length {
-					length = l
-				}
-				return true
-			}) {
-				// For maps, the index expression must be assignable to the map key type.
-				if key != nil {
-					index := check.singleIndex(e)
-					if index == nil {
-						x.mode = invalid
-						return false
-					}
-					var k operand
-					check.expr(&k, index)
-					check.assignment(&k, key, "map index")
-					// ok to continue even if indexing failed - map element type is known
-					x.mode = mapindex
-					x.typ = elem
-					x.expr = e
-					return false
-				}
-
-				// no maps
-				valid = true
-				x.mode = mode
-				x.typ = elem
-			}
+		if !isTypeParam(x.typ) {
+			break
 		}
-	case *TypeParam:
-		// Note: The body of this case is the same as the body of the 'if'
-		//       statement in the interface case above. If we keep both
-		//       these branches we should factor out the code.
 		// TODO(gri) report detailed failure cause for better error messages
-		assert(!tparamIsIface)
 		var key, elem Type // key != nil: we must have all maps
 		mode := variable   // non-maps result mode
 		// TODO(gri) factor out closure and use it for non-typeparam cases as well
-		if typ.underIs(func(u Type) bool {
+		if typ.typeSet().underIs(func(u Type) bool {
 			l := int64(-1) // valid if >= 0
 			var k, e Type  // k is only set for maps
 			switch t := u.(type) {
diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go
index 5204eb0c29..229a616eac 100644
--- a/src/go/types/predicates.go
+++ b/src/go/types/predicates.go
@@ -133,13 +133,7 @@ func comparable(T Type, seen map[Type]bool) bool {
 	case *Array:
 		return comparable(t.elem, seen)
 	case *Interface:
-		if tparamIsIface && isTypeParam(T) {
-			return t.IsComparable()
-		}
-		return true
-	case *TypeParam:
-		assert(!tparamIsIface)
-		return t.iface().IsComparable()
+		return !isTypeParam(T) || t.IsComparable()
 	}
 	return false
 }
@@ -152,15 +146,7 @@ func hasNil(t Type) bool {
 	case *Slice, *Pointer, *Signature, *Map, *Chan:
 		return true
 	case *Interface:
-		if tparamIsIface && isTypeParam(t) {
-			return u.typeSet().underIs(func(u Type) bool {
-				return u != nil && hasNil(u)
-			})
-		}
-		return true
-	case *TypeParam:
-		assert(!tparamIsIface)
-		return u.underIs(func(u Type) bool {
+		return !isTypeParam(t) || u.typeSet().underIs(func(u Type) bool {
 			return u != nil && hasNil(u)
 		})
 	}
diff --git a/src/go/types/sizes.go b/src/go/types/sizes.go
index a921525062..dd4b78969f 100644
--- a/src/go/types/sizes.go
+++ b/src/go/types/sizes.go
@@ -67,7 +67,9 @@ func (s *StdSizes) Alignof(T Type) int64 {
 	case *Slice, *Interface:
 		// Multiword data structures are effectively structs
 		// in which each element has size WordSize.
-		assert(!tparamIsIface || !isTypeParam(T))
+		// Type parameters lead to variable sizes/alignments;
+		// StdSizes.Alignof won't be called for them.
+		assert(!isTypeParam(T))
 		return s.WordSize
 	case *Basic:
 		// Strings are like slices and interfaces.
@@ -152,6 +154,9 @@ func (s *StdSizes) Sizeof(T Type) int64 {
 		offsets := s.Offsetsof(t.fields)
 		return offsets[n-1] + s.Sizeof(t.fields[n-1].typ)
 	case *Interface:
+		// Type parameters lead to variable sizes/alignments;
+		// StdSizes.Sizeof won't be called for them.
+		assert(!isTypeParam(T))
 		return s.WordSize * 2
 	case *TypeParam, *Union:
 		unreachable()
diff --git a/src/go/types/struct.go b/src/go/types/struct.go
index 53204dc381..d6c56341f0 100644
--- a/src/go/types/struct.go
+++ b/src/go/types/struct.go
@@ -155,14 +155,11 @@ func (check *Checker) structType(styp *Struct, e *ast.StructType) {
 					}
 				case *Pointer:
 					check.error(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer")
-				case *TypeParam:
-					assert(!tparamIsIface)
-					// This error code here is inconsistent with other error codes for
-					// invalid embedding, because this restriction may be relaxed in the
-					// future, and so it did not warrant a new error code.
-					check.error(embeddedPos, _MisplacedTypeParam, "embedded field type cannot be a (pointer to a) type parameter")
 				case *Interface:
-					if tparamIsIface && isTypeParam(t) {
+					if isTypeParam(t) {
+						// The error code here is inconsistent with other error codes for
+						// invalid embedding, because this restriction may be relaxed in the
+						// future, and so it did not warrant a new error code.
 						check.error(embeddedPos, _MisplacedTypeParam, "embedded field type cannot be a (pointer to a) type parameter")
 						break
 					}
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 1d672135b8..97de5e49d1 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -25,9 +25,7 @@ func under(t Type) Type {
 	case *Named:
 		return t.under()
 	case *TypeParam:
-		if tparamIsIface {
-			return t.iface()
-		}
+		return t.iface()
 	}
 	return t
 }
diff --git a/src/go/types/typeparam.go b/src/go/types/typeparam.go
index f000d8f108..7cce1f7e35 100644
--- a/src/go/types/typeparam.go
+++ b/src/go/types/typeparam.go
@@ -9,12 +9,6 @@ import (
 	"sync/atomic"
 )
 
-// If set, the underlying type of a type parameter is
-// is the underlying type of its type constraint, i.e.,
-// an interface. With that, a type parameter satisfies
-// isInterface.
-const tparamIsIface = true
-
 // Note: This is a uint32 rather than a uint64 because the
 // respective 64 bit atomic instructions are not available
 // on all platforms.
@@ -79,10 +73,7 @@ func (t *TypeParam) SetConstraint(bound Type) {
 }
 
 func (t *TypeParam) Underlying() Type {
-	if tparamIsIface {
-		return t.iface()
-	}
-	return t
+	return t.iface()
 }
 
 func (t *TypeParam) String() string { return TypeString(t, nil) }
@@ -105,15 +96,11 @@ func (t *TypeParam) iface() *Interface {
 			return &emptyInterface
 		}
 	case *Interface:
-		if tparamIsIface && isTypeParam(bound) {
+		if isTypeParam(bound) {
 			// error is reported in Checker.collectTypeParams
 			return &emptyInterface
 		}
 		ityp = u
-	case *TypeParam:
-		assert(!tparamIsIface)
-		// error is reported in Checker.collectTypeParams
-		return &emptyInterface
 	}
 
 	// If we don't have an interface, wrap constraint into an implicit interface.

From 2463b4fcafbd59998ea4c81b0fd91a697ad02c15 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 19:20:52 -0500
Subject: [PATCH 225/752] go/types: simplify under() and fix a crash

This is a port of CL 363665 from types2 to go/types.

Change-Id: I20c4e20ab97f1e4de66a29095dc4a9b160810fe5
Reviewed-on: https://go-review.googlesource.com/c/go/+/364897
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/lookup.go                 | 7 +++++++
 src/go/types/testdata/check/cycles.src | 1 +
 src/go/types/type.go                   | 7 ++-----
 src/go/types/typexpr.go                | 1 +
 4 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index 1462d30b30..e3c43a94f7 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -469,6 +469,13 @@ func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Fun
 // Otherwise it returns (typ, false).
 func deref(typ Type) (Type, bool) {
 	if p, _ := typ.(*Pointer); p != nil {
+		// p.base should never be nil, but be conservative
+		if p.base == nil {
+			if debug {
+				panic("pointer with nil base type (possibly due to an invalid cyclic declaration)")
+			}
+			return Typ[Invalid], true
+		}
 		return p.base, true
 	}
 	return typ, false
diff --git a/src/go/types/testdata/check/cycles.src b/src/go/types/testdata/check/cycles.src
index 218b4cad6a..27b6111822 100644
--- a/src/go/types/testdata/check/cycles.src
+++ b/src/go/types/testdata/check/cycles.src
@@ -45,6 +45,7 @@ type (
 
 	// pointers
 	P0 *P0
+	PP *struct{ PP.f /* ERROR no field or method f */ }
 
 	// functions
 	F0 func(F0)
diff --git a/src/go/types/type.go b/src/go/types/type.go
index 97de5e49d1..6611c25f25 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -21,13 +21,10 @@ type Type interface {
 // under must only be called when a type is known
 // to be fully set up.
 func under(t Type) Type {
-	switch t := t.(type) {
-	case *Named:
+	if t, _ := t.(*Named); t != nil {
 		return t.under()
-	case *TypeParam:
-		return t.iface()
 	}
-	return t
+	return t.Underlying()
 }
 
 // If x and y are identical, match returns x.
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index c6ab7cd564..5664d8175f 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -308,6 +308,7 @@ func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
 
 	case *ast.StarExpr:
 		typ := new(Pointer)
+		typ.base = Typ[Invalid] // avoid nil base in invalid recursive type declaration
 		def.setUnderlying(typ)
 		typ.base = check.varType(e.X)
 		return typ

From 353cb71ea29e02a41f77b7576d658de4515e264d Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 19:22:22 -0500
Subject: [PATCH 226/752] go/types: optimize common case in structuralType

This is a port of CL 363668 from types2 to go/types.

Change-Id: Ic55acb2e27f57c33467cef2f687cd695e092ba6d
Reviewed-on: https://go-review.googlesource.com/c/go/+/364898
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/type.go | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/go/types/type.go b/src/go/types/type.go
index 6611c25f25..e283c65289 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -56,15 +56,20 @@ func match(x, y Type) Type {
 	return nil
 }
 
-// If typ is a type parameter, structuralType returns the single underlying
-// type of all types in the corresponding type constraint if it exists, or
-// nil otherwise. If the type set contains only unrestricted and restricted
-// channel types (with identical element types), the single underlying type
-// is the restricted channel type if the restrictions are always the same.
-// If typ is not a type parameter, structuralType returns the underlying type.
-func structuralType(typ Type) Type {
+// If t is not a type parameter, structuralType returns the underlying type.
+// If t is a type parameter, structuralType returns the single underlying
+// type of all types in its type set if it exists, or nil otherwise. If the
+// type set contains only unrestricted and restricted channel types (with
+// identical element types), the single underlying type is the restricted
+// channel type if the restrictions are always the same, or nil otherwise.
+func structuralType(t Type) Type {
+	tpar, _ := t.(*TypeParam)
+	if tpar == nil {
+		return under(t)
+	}
+
 	var su Type
-	if underIs(typ, func(u Type) bool {
+	if tpar.underIs(func(u Type) bool {
 		if u == nil {
 			return false
 		}

From ce7e5013a68ef4572b9fa439b1402145ef710631 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 19:26:37 -0500
Subject: [PATCH 227/752] go/types: allow slicing for operands with
 []byte|string type sets

This is a port of CL 363662 from types2 to go/types. An error message
was adjusted to be on the operand in test data.

Change-Id: I4d2d69976f4f05e0d89ba1c6bf8b3e4cf1a82316
Reviewed-on: https://go-review.googlesource.com/c/go/+/364899
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/builtins.go                   | 23 +++-----------
 src/go/types/index.go                      |  4 +--
 src/go/types/testdata/check/typeparams.go2 |  4 +++
 src/go/types/type.go                       | 37 ++++++++++++++++++++++
 4 files changed, 47 insertions(+), 21 deletions(-)

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index b547cddeb1..daeed81ed8 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -342,26 +342,11 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 		if y.mode == invalid {
 			return
 		}
-		// src, _ := structuralType(y.typ).(*Slice); but also accepts strings
-		var src *Slice
-		var elem Type // == src.elem if valid
-		if underIs(y.typ, func(u Type) bool {
-			switch u := u.(type) {
-			case *Basic:
-				if isString(u) && (elem == nil || Identical(elem, universeByte)) {
-					elem = universeByte
-					return true
-				}
-			case *Slice:
-				if elem == nil || Identical(elem, u.elem) {
-					elem = u.elem
-					return true
-				}
-			}
-			return false
-		}) {
-			src = NewSlice(elem)
+		src0 := structuralString(y.typ)
+		if src0 != nil && isString(src0) {
+			src0 = NewSlice(universeByte)
 		}
+		src, _ := src0.(*Slice)
 
 		if dst == nil || src == nil {
 			check.invalidArg(x, _InvalidCopy, "copy expects slice arguments; found %s and %s", x, &y)
diff --git a/src/go/types/index.go b/src/go/types/index.go
index 54398ad19b..ace9ee06ab 100644
--- a/src/go/types/index.go
+++ b/src/go/types/index.go
@@ -214,7 +214,7 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
 
 	valid := false
 	length := int64(-1) // valid if >= 0
-	switch u := structuralType(x.typ).(type) {
+	switch u := structuralString(x.typ).(type) {
 	case nil:
 		check.invalidOp(x, _NonSliceableOperand, "cannot slice %s: %s has no structural type", x, x.typ)
 		x.mode = invalid
@@ -233,7 +233,7 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
 			}
 			// spec: "For untyped string operands the result
 			// is a non-constant value of type string."
-			if u.kind == UntypedString {
+			if isUntyped(x.typ) {
 				x.typ = Typ[String]
 			}
 		}
diff --git a/src/go/types/testdata/check/typeparams.go2 b/src/go/types/testdata/check/typeparams.go2
index fdbb7a2740..0d3b6ea527 100644
--- a/src/go/types/testdata/check/typeparams.go2
+++ b/src/go/types/testdata/check/typeparams.go2
@@ -136,6 +136,10 @@ type myByte2 []byte
 func _[T interface{ []byte | myByte1 | myByte2 }] (x T, i, j, k int) { var _ T = x[i:j:k] }
 func _[T interface{ []byte | myByte1 | []int }] (x T, i, j, k int) { var _ T = x /* ERROR no structural type */ [i:j:k] }
 
+func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x[i:j] }
+func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x /* ERROR 3-index slice of string */ [i:j:k] }
+func _[T interface{ []byte | myByte1 | []int | string }] (x T, i, j, k int) { var _ T = x /* ERROR no structural type */ [i:j] }
+
 // len/cap built-ins
 
 func _[T any](x T) { _ = len(x /* ERROR invalid argument */ ) }
diff --git a/src/go/types/type.go b/src/go/types/type.go
index e283c65289..099449c8b9 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -87,3 +87,40 @@ func structuralType(t Type) Type {
 	}
 	return nil
 }
+
+// structuralString is like structuralType but also considers []byte
+// and strings as identical. In this case, if successful and we saw
+// a string, the result is of type (possibly untyped) string.
+func structuralString(t Type) Type {
+	tpar, _ := t.(*TypeParam)
+	if tpar == nil {
+		return under(t) // string or untyped string
+	}
+
+	var su Type
+	hasString := false
+	if tpar.underIs(func(u Type) bool {
+		if u == nil {
+			return false
+		}
+		if isString(u) {
+			u = NewSlice(universeByte)
+			hasString = true
+		}
+		if su != nil {
+			u = match(su, u)
+			if u == nil {
+				return false
+			}
+		}
+		// su == nil || match(su, u) != nil
+		su = u
+		return true
+	}) {
+		if hasString {
+			return Typ[String]
+		}
+		return su
+	}
+	return nil
+}

From 3404ee3e86b9f4eab55d2451dcd9db5b4cd9ed4a Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 19:29:13 -0500
Subject: [PATCH 228/752] go/types: move match function to end of file
 (cleanup)

This is a port of CL 363669 from types2 to go/types.

Change-Id: Id1f375ff5708dab528144e30ce16d24d6fdf7d00
Reviewed-on: https://go-review.googlesource.com/c/go/+/364900
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/type.go | 58 ++++++++++++++++++++++----------------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/src/go/types/type.go b/src/go/types/type.go
index 099449c8b9..3acb19c412 100644
--- a/src/go/types/type.go
+++ b/src/go/types/type.go
@@ -27,35 +27,6 @@ func under(t Type) Type {
 	return t.Underlying()
 }
 
-// If x and y are identical, match returns x.
-// If x and y are identical channels but for their direction
-// and one of them is unrestricted, match returns the channel
-// with the restricted direction.
-// In all other cases, match returns nil.
-func match(x, y Type) Type {
-	// Common case: we don't have channels.
-	if Identical(x, y) {
-		return x
-	}
-
-	// We may have channels that differ in direction only.
-	if x, _ := x.(*Chan); x != nil {
-		if y, _ := y.(*Chan); y != nil && Identical(x.elem, y.elem) {
-			// We have channels that differ in direction only.
-			// If there's an unrestricted channel, select the restricted one.
-			switch {
-			case x.dir == SendRecv:
-				return y
-			case y.dir == SendRecv:
-				return x
-			}
-		}
-	}
-
-	// types are different
-	return nil
-}
-
 // If t is not a type parameter, structuralType returns the underlying type.
 // If t is a type parameter, structuralType returns the single underlying
 // type of all types in its type set if it exists, or nil otherwise. If the
@@ -124,3 +95,32 @@ func structuralString(t Type) Type {
 	}
 	return nil
 }
+
+// If x and y are identical, match returns x.
+// If x and y are identical channels but for their direction
+// and one of them is unrestricted, match returns the channel
+// with the restricted direction.
+// In all other cases, match returns nil.
+func match(x, y Type) Type {
+	// Common case: we don't have channels.
+	if Identical(x, y) {
+		return x
+	}
+
+	// We may have channels that differ in direction only.
+	if x, _ := x.(*Chan); x != nil {
+		if y, _ := y.(*Chan); y != nil && Identical(x.elem, y.elem) {
+			// We have channels that differ in direction only.
+			// If there's an unrestricted channel, select the restricted one.
+			switch {
+			case x.dir == SendRecv:
+				return y
+			case y.dir == SendRecv:
+				return x
+			}
+		}
+	}
+
+	// types are different
+	return nil
+}

From 72f0976ac45fcb7f3fd6d47a3ac5c96a78edd59d Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 19:37:04 -0500
Subject: [PATCH 229/752] go/types: better position for "3-index slice of
 string" error

This is a port of CL 363670 from types2 to go/types.

Change-Id: I2ac3a5f86bb4eafddd2854e193083b2b737e29b6
Reviewed-on: https://go-review.googlesource.com/c/go/+/364901
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/index.go                      | 6 +++++-
 src/go/types/testdata/check/expr3.src      | 4 ++--
 src/go/types/testdata/check/typeparams.go2 | 4 ++--
 3 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/go/types/index.go b/src/go/types/index.go
index ace9ee06ab..6ea25bc764 100644
--- a/src/go/types/index.go
+++ b/src/go/types/index.go
@@ -223,7 +223,11 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
 	case *Basic:
 		if isString(u) {
 			if e.Slice3 {
-				check.invalidOp(x, _InvalidSliceExpr, "3-index slice of string")
+				at := e.Max
+				if at == nil {
+					at = e // e.Index[2] should be present but be careful
+				}
+				check.invalidOp(at, _InvalidSliceExpr, "3-index slice of string")
 				x.mode = invalid
 				return
 			}
diff --git a/src/go/types/testdata/check/expr3.src b/src/go/types/testdata/check/expr3.src
index 0f15c15a55..a63542b843 100644
--- a/src/go/types/testdata/check/expr3.src
+++ b/src/go/types/testdata/check/expr3.src
@@ -109,8 +109,8 @@ func indexes() {
 	_ = t[- /* ERROR "negative" */ 1]
 	_ = t[- /* ERROR "negative" */ 1 :]
 	_ = t[: - /* ERROR "negative" */ 1]
-	_ = t /* ERROR "3-index slice of string" */ [1:2:3]
-	_ = "foo" /* ERROR "3-index slice of string" */ [1:2:3]
+	_ = t[1:2:3 /* ERROR "3-index slice of string" */ ]
+	_ = "foo"[1:2:3 /* ERROR "3-index slice of string" */ ]
 	var t0 byte
 	t0 = t[0]
 	_ = t0
diff --git a/src/go/types/testdata/check/typeparams.go2 b/src/go/types/testdata/check/typeparams.go2
index 0d3b6ea527..e3aca4ccb0 100644
--- a/src/go/types/testdata/check/typeparams.go2
+++ b/src/go/types/testdata/check/typeparams.go2
@@ -129,7 +129,7 @@ func _[T interface{ ~[10]E }, E any] (x T, i, j, k int) { var _ []E = x[i:j:k] }
 func _[T interface{ ~[]byte }] (x T, i, j, k int) { var _ T = x[i:j] }
 func _[T interface{ ~[]byte }] (x T, i, j, k int) { var _ T = x[i:j:k] }
 func _[T interface{ ~string }] (x T, i, j, k int) { var _ T = x[i:j] }
-func _[T interface{ ~string }] (x T, i, j, k int) { var _ T = x /* ERROR 3-index slice of string */ [i:j:k] }
+func _[T interface{ ~string }] (x T, i, j, k int) { var _ T = x[i:j:k /* ERROR 3-index slice of string */ ] }
 
 type myByte1 []byte
 type myByte2 []byte
@@ -137,7 +137,7 @@ func _[T interface{ []byte | myByte1 | myByte2 }] (x T, i, j, k int) { var _ T =
 func _[T interface{ []byte | myByte1 | []int }] (x T, i, j, k int) { var _ T = x /* ERROR no structural type */ [i:j:k] }
 
 func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x[i:j] }
-func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x /* ERROR 3-index slice of string */ [i:j:k] }
+func _[T interface{ []byte | myByte1 | myByte2 | string }] (x T, i, j, k int) { var _ T = x[i:j:k /* ERROR 3-index slice of string */ ] }
 func _[T interface{ []byte | myByte1 | []int | string }] (x T, i, j, k int) { var _ T = x /* ERROR no structural type */ [i:j] }
 
 // len/cap built-ins

From f1cc5294290b33889d48a3185b3c3711531881e0 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 19:45:49 -0500
Subject: [PATCH 230/752] go/types: better position for invalid slice indices
 error

This is a port of CL 363671 from types2 to go/types. Also adjust the
error message to match types2 ("invalid" vs "swapped").

Change-Id: I662a73c915814fea14bfcb1ebde0fbf39589f022
Reviewed-on: https://go-review.googlesource.com/c/go/+/364902
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/index.go                 | 10 +++++++---
 src/go/types/testdata/check/expr3.src | 20 ++++++++++----------
 2 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/src/go/types/index.go b/src/go/types/index.go
index 6ea25bc764..db4732c8e0 100644
--- a/src/go/types/index.go
+++ b/src/go/types/index.go
@@ -310,9 +310,13 @@ func (check *Checker) sliceExpr(x *operand, e *ast.SliceExpr) {
 L:
 	for i, x := range ind[:len(ind)-1] {
 		if x > 0 {
-			for _, y := range ind[i+1:] {
-				if y >= 0 && x > y {
-					check.errorf(inNode(e, e.Rbrack), _SwappedSliceIndices, "swapped slice indices: %d > %d", x, y)
+			for j, y := range ind[i+1:] {
+				if y >= 0 && y < x {
+					// The value y corresponds to the expression e.Index[i+1+j].
+					// Because y >= 0, it must have been set from the expression
+					// when checking indices and thus e.Index[i+1+j] is not nil.
+					at := []ast.Expr{e.Low, e.High, e.Max}[i+1+j]
+					check.errorf(at, _SwappedSliceIndices, "invalid slice indices: %d < %d", y, x)
 					break L // only report one error, ok to continue
 				}
 			}
diff --git a/src/go/types/testdata/check/expr3.src b/src/go/types/testdata/check/expr3.src
index a63542b843..5117a0373b 100644
--- a/src/go/types/testdata/check/expr3.src
+++ b/src/go/types/testdata/check/expr3.src
@@ -44,9 +44,9 @@ func indexes() {
 	_ = a[:10:10]
 	_ = a[:11 /* ERROR "index .* out of bounds" */ :10]
 	_ = a[:10:11 /* ERROR "index .* out of bounds" */ ]
-	_ = a[10:0:10] /* ERROR swapped slice indices" */
-	_ = a[0:10:0] /* ERROR "swapped slice indices" */
-	_ = a[10:0:0] /* ERROR "swapped slice indices" */
+	_ = a[10:0 /* ERROR "invalid slice indices" */ :10]
+	_ = a[0:10:0 /* ERROR "invalid slice indices" */ ]
+	_ = a[10:0 /* ERROR "invalid slice indices" */:0]
 	_ = &a /* ERROR "cannot take address" */ [:10]
 
 	pa := &a
@@ -62,9 +62,9 @@ func indexes() {
 	_ = pa[:10:10]
 	_ = pa[:11 /* ERROR "index .* out of bounds" */ :10]
 	_ = pa[:10:11 /* ERROR "index .* out of bounds" */ ]
-	_ = pa[10:0:10] /* ERROR "swapped slice indices" */
-	_ = pa[0:10:0] /* ERROR "swapped slice indices" */
-	_ = pa[10:0:0] /* ERROR "swapped slice indices" */
+	_ = pa[10:0 /* ERROR "invalid slice indices" */ :10]
+	_ = pa[0:10:0 /* ERROR "invalid slice indices" */ ]
+	_ = pa[10:0 /* ERROR "invalid slice indices" */ :0]
 	_ = &pa /* ERROR "cannot take address" */ [:10]
 
 	var b [0]int
@@ -82,16 +82,16 @@ func indexes() {
 	_ = s[: - /* ERROR "negative" */ 1]
 	_ = s[0]
 	_ = s[1:2]
-	_ = s[2:1] /* ERROR "swapped slice indices" */
+	_ = s[2:1 /* ERROR "invalid slice indices" */ ]
 	_ = s[2:]
 	_ = s[: 1 /* ERROR "overflows" */ <<100]
 	_ = s[1 /* ERROR "overflows" */ <<100 :]
 	_ = s[1 /* ERROR "overflows" */ <<100 : 1 /* ERROR "overflows" */ <<100]
 	_ = s[: /* ERROR "2nd index required" */ :  /* ERROR "3rd index required" */ ]
 	_ = s[:10:10]
-	_ = s[10:0:10] /* ERROR "swapped slice indices" */
-	_ = s[0:10:0] /* ERROR "swapped slice indices" */
-	_ = s[10:0:0] /* ERROR "swapped slice indices" */
+	_ = s[10:0 /* ERROR "invalid slice indices" */ :10]
+	_ = s[0:10:0 /* ERROR "invalid slice indices" */ ]
+	_ = s[10:0 /* ERROR "invalid slice indices" */ :0]
 	_ = &s /* ERROR "cannot take address" */ [:10]
 
 	var m map[string]int

From d8f7a64519695f037cce8696c5c3b7216fd4a680 Mon Sep 17 00:00:00 2001
From: Keith Randall 
Date: Wed, 17 Nov 2021 16:12:43 -0800
Subject: [PATCH 231/752] test: make issue8606b test more robust

Use actual unmapped memory instead of small integers to make
pointers that will fault when accessed.

Fixes #49562

Change-Id: I2c60c97cf80494dd962a07d10cfeaff6a00f4f8e
Reviewed-on: https://go-review.googlesource.com/c/go/+/364914
Trust: Keith Randall 
Run-TryBot: Keith Randall 
TryBot-Result: Go Bot 
Reviewed-by: Matthew Dempsky 
---
 test/fixedbugs/issue8606b.go | 37 +++++++++++++++++++++---------------
 1 file changed, 22 insertions(+), 15 deletions(-)

diff --git a/test/fixedbugs/issue8606b.go b/test/fixedbugs/issue8606b.go
index 448ea566f0..41b9a3d00e 100644
--- a/test/fixedbugs/issue8606b.go
+++ b/test/fixedbugs/issue8606b.go
@@ -1,4 +1,5 @@
 // run
+// +build linux darwin
 
 // Copyright 2020 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -20,20 +21,10 @@ package main
 import (
 	"fmt"
 	"reflect"
+	"syscall"
 	"unsafe"
 )
 
-func bad1() string {
-	s := "foo"
-	(*reflect.StringHeader)(unsafe.Pointer(&s)).Data = 1 // write bad value to data ptr
-	return s
-}
-func bad2() string {
-	s := "foo"
-	(*reflect.StringHeader)(unsafe.Pointer(&s)).Data = 2 // write bad value to data ptr
-	return s
-}
-
 type SI struct {
 	s string
 	i int
@@ -45,15 +36,31 @@ type SS struct {
 }
 
 func main() {
+	bad1 := "foo"
+	bad2 := "foo"
+
+	p := syscall.Getpagesize()
+	b, err := syscall.Mmap(-1, 0, p, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_ANON|syscall.MAP_PRIVATE)
+	if err != nil {
+		panic(err)
+	}
+	err = syscall.Mprotect(b, syscall.PROT_NONE)
+	if err != nil {
+		panic(err)
+	}
+	// write inaccessible pointers as the data fields of bad1 and bad2.
+	(*reflect.StringHeader)(unsafe.Pointer(&bad1)).Data = uintptr(unsafe.Pointer(&b[0]))
+	(*reflect.StringHeader)(unsafe.Pointer(&bad2)).Data = uintptr(unsafe.Pointer(&b[1]))
+
 	for _, test := range []struct {
 		a, b interface{}
 	}{
-		{SI{s: bad1(), i: 1}, SI{s: bad2(), i: 2}},
-		{SS{s: bad1(), t: "a"}, SS{s: bad2(), t: "aa"}},
-		{SS{s: "a", t: bad1()}, SS{s: "b", t: bad2()}},
+		{SI{s: bad1, i: 1}, SI{s: bad2, i: 2}},
+		{SS{s: bad1, t: "a"}, SS{s: bad2, t: "aa"}},
+		{SS{s: "a", t: bad1}, SS{s: "b", t: bad2}},
 		// This one would panic because the length of both strings match, and we check
 		// the body of the bad strings before the body of the good strings.
-		//{SS{s: bad1(), t: "a"}, SS{s: bad2(), t: "b"}},
+		//{SS{s: bad1, t: "a"}, SS{s: bad2, t: "b"}},
 	} {
 		if test.a == test.b {
 			panic(fmt.Sprintf("values %#v and %#v should not be equal", test.a, test.b))

From f6647f2e3bc0b803a67c97a7d5d8733cefbd5d5b Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Wed, 10 Nov 2021 09:44:58 -0800
Subject: [PATCH 232/752] spec: generalize method sets and interface types to
 type sets

This is the first of several CLs that update the existing
Go 1.17 spec for type parameters.

This CL updates the section on method sets and interface types.
It also adds "any", "comparable" to the list of predeclared
identifiers.

Change-Id: I0ce25dc02791c33150c0d949528512610faf3eab
Reviewed-on: https://go-review.googlesource.com/c/go/+/362999
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
Reviewed-by: Ian Lance Taylor 
---
 doc/go_spec.html | 245 +++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 207 insertions(+), 38 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 0b374e7bfb..63bc6a546e 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,9 +1,18 @@
 
 
+
Draft Go 1.18 Specification - Work in Progress 

+
+

+
+For the pre-Go1.18 spec see
+The Go Programming Language Specification.
+
+

+
 
Introduction

 
 

@@ -266,7 +275,7 @@ The following character sequences represent operators
 *    ^     *=    ^=     <-    >     >=    {    }
 /    <<    /=    <<=    ++    =     :=    ,    ;
 %    >>    %=    >>=    --    !     ...   .    :
-     &^          &^=
+     &^          &^=          ~
 

 
 
Integer literals

@@ -829,27 +838,41 @@ The underlying type of []B1, B3, and B4 i
 

 
 
Method sets

+
 

-A type has a (possibly empty) method set associated with it.
-The method set of an interface type is its interface.
-The method set of any other type T consists of all
+The method set of a type determines the methods that can be
+called on an operand of that type.
+Every type has a (possibly empty) method set associated with it:
+

+
+
    
+
  • The method set of a defined type T consists of all
 methods declared with receiver type T.
-The method set of the corresponding pointer type *T
-is the set of all methods declared with receiver *T or T
-(that is, it also contains the method set of T).
-Further rules apply to structs containing embedded fields, as described
-in the section on struct types.
+
    • 
+
+
  • 
+The method set of a pointer *T
+to a defined type *T
+(where T is neither a pointer nor an interface)
+is the set of all methods declared with receiver *T or T.
+
    • 
+
+
  • The method set of an interface type is the intersection
+of the method sets of each type in the interface's type set
+(the resulting method set is usually just the set of declared methods in the interface).
+
    • 
+

+
+

+Further rules apply to structs (and pointer to structs) containing embedded fields,
+as described in the section on struct types.
 Any other type has an empty method set.
-In a method set, each method must have a
-unique
-non-blank method name.
 

 
 

-The method set of a type determines the interfaces that the
-type implements
-and the methods that can be called
-using a receiver of that type.
+In a method set, each method must have a
+unique
+non-blank method name.
 

 
 
Boolean types

@@ -1236,23 +1259,33 @@ func(n int) func(p *T)
 
Interface types

 
 

-An interface type specifies a method set called its interface.
-A variable of interface type can store a value of any type with a method set
-that is any superset of the interface. Such a type is said to
-implement the interface.
+An interface type defines a type set.
+A variable of interface type can store a value of any type that is in the type
+set of the interface. Such a type is said to implement the interface.
 The value of an uninitialized variable of interface type is nil.
 

 
 
-InterfaceType      = "interface" "{" { ( MethodSpec | InterfaceTypeName ) ";" } "}" .
-MethodSpec         = MethodName Signature .
-MethodName         = identifier .
-InterfaceTypeName  = TypeName .
+InterfaceType  = "interface" "{" { InterfaceElem ";" } "}" .
+InterfaceElem  = MethodElem | TypeElem .
+MethodElem     = MethodName Signature .
+MethodName     = identifier .
+TypeElem       = TypeTerm { "|" TypeTerm } .
+TypeTerm       = [ "~" ] Type .
 

 
 

-An interface type may specify methods explicitly through method specifications,
-or it may embed methods of other interfaces through interface type names.
+An interface type is specified by a list of interface elements.
+An interface element is either a method or a type element,
+where a type element is a union of one or more type terms.
+A type term is either a single type or a single underlying type.
+

+
+

+In its most basic form an interface specifies a (possibly empty) list of methods.
+The type set defined by such an interface is the set of types which implement all of
+those methods, and the corresponding method set consists
+exactly of the methods specified by the interface.
 

 
 
@@ -1297,15 +1330,19 @@ then the File interface is implemented by both S1 and
 

 
 

-A type implements any interface comprising any subset of its methods
-and may therefore implement several distinct interfaces. For
-instance, all types implement the empty interface:
+Every type that is a member of the type set of an interface implements that interface.
+Any given type may implement several distinct interfaces.
+For instance, all types implement the empty interface which stands for the set of all types:
 

 
 
 interface{}
 

 
+

+For convenience, the predeclared type any is an alias for the empty interface.
+

+
 

 Similarly, consider this interface specification,
 which appears within a type declaration
@@ -1334,12 +1371,16 @@ as the File interface.
 

 
 

-An interface T may use a (possibly qualified) interface type
-name E in place of a method specification. This is called
+In a slightly more general form
+an interface T may use a (possibly qualified) interface type
+name E as an interface element. This is called
 embedding interface E in T.
-The method set of T is the union
-of the method sets of T’s explicitly declared methods and of
-T’s embedded interfaces.
+The type set of T is the intersection of the type sets
+defined by T's explicitly declared methods and the type sets
+of T’s embedded interfaces.
+In other words, the type set of T is the set of all types that implement all the
+explicitly declared methods of T and also all the methods of
+E.
 

 
 
@@ -1361,8 +1402,7 @@ type ReadWriter interface {
 

 
 

-A union of method sets contains the (exported and non-exported)
-methods of each method set exactly once, and methods with the
+When embedding interfaces, methods with the
 same names must
 have identical signatures.
 

@@ -1374,6 +1414,134 @@ type ReadCloser interface {
 }
 

 
+

+Finally, in their most general form, an interface element may be an arbitrary type
+T, a type term of the form ~T, or a union of type terms
+T1 | T2 | … Tn.
+Together with method specifications, these elements enable the precise
+definition of an interface's type set as follows:
+

+
+
    
+	
  • The type set of the empty interface is the set of all types.
+	
    • 
+
+	
  • The type set of a non-empty interface is the intersection of the type sets
+		of its interface elements.
+	
    • 
+
+	
  • The type set of a method specification is the set of types
+		whose method sets include that method.
+	
    • 
+
+	
  • The type set of a non-interface type is the set consisting
+		of just that type.
+	
    • 
+
+	
  • The type set of a term of the form ~T
+		is the set of types whose underlying type is T.
+	
    • 
+
+	
  • The type set of a union of terms T1 | T2 | … Tn
+		is the union of the type sets of the terms.
+	
    • 
+

+
+
+// An interface representing only the type int.
+interface {
+	int
+}
+
+// An interface representing all types with underlying type int.
+interface {
+	~int
+}
+
+// An interface representing all types with underlying type int which implement the String method.
+interface {
+	~int
+	String() string
+}
+
+// An interface representing an empty type set: there is no type that is both an int and a string.
+interface {
+	int
+	string
+}
+

+
+

+In a term of the form ~T, the underlying type of T
+must be itself, and T cannot be an interface.
+

+
+
+type MyInt int
+
+interface {
+	~[]byte  // the underlying type of []byte is itself
+	~MyInt   // illegal: the underlying type of MyInt is not MyInt
+	~error   // illegal: error is an interface
+}
+

+
+

+Union expressions denote unions of type sets:
+

+
+
+// The Floats interface represents all floating-point types
+// (including any named types whose underlying types are
+// either float32 or float64).
+type Floats interface {
+	~float32 | ~float64
+}
+

+
+

+In a union expression, a term cannot be a type parameter, and the type sets of all
+non-interface terms must be pairwise disjoint (the pairwise intersection of the type sets must be empty).
+Given a type parameter P:
+

+
+
+interface {
+	P                 // illegal: the term P is a type parameter
+	int | P           // illegal: the term P is a type parameter
+	~int | MyInt      // illegal: the type sets for ~int and MyInt are not disjoint (~int includes MyInt)
+	float32 | Floats  // overlapping type sets but Floats is an interface
+}
+

+
+

+Implementation restriction:
+A union expression with more than one term cannot contain interface types
+with non-empty method sets.
+

+
+

+Interfaces that contain union or tilde terms (not just methods) may only be used
+as type constraints, or as elements of other interfaces used as constraints. They
+cannot be the types of values or variables, or components of other, non-interface types.
+

+
+
+var x Floats                     // illegal: Floats is restricted by float32 and float64
+
+var x interface{} = Floats(nil)  // illegal
+
+type Floatish struct {
+	f Floats                 // illegal
+}
+

+
+
+
 

 An interface type T may not embed itself
 or any interface type that embeds T, recursively.
@@ -1872,7 +2040,8 @@ The following identifiers are implicitly declared in the
 

 
 Types:
-	bool byte complex64 complex128 error float32 float64
+	any bool byte comparable
+	complex64 complex128 error float32 float64
 	int int8 int16 int32 int64 rune string
 	uint uint8 uint16 uint32 uint64 uintptr
 

From 14c3f749bebafe10d60cf5a9b1f4ae6663ff862a Mon Sep 17 00:00:00 2001
From: Than McIntosh 
Date: Fri, 12 Nov 2021 13:20:07 -0500
Subject: [PATCH 233/752] cmd/link: relocate dwarf examiner helper to separate
 package

The linker DWARF test includes an "examiner" helper type (with
associated methods) that is used to help linker DWARF tests read DWARF
info in a higher level and more structured way than just raw
debug/dwarf operations. This patch extracts out "examiner" and
relocates it to a separate package, so that it can be used in other
package tests as well, if need be.

Change-Id: Iec66061e2719ee698c12d8fa17b11698442b336d
Reviewed-on: https://go-review.googlesource.com/c/go/+/364036
Trust: Than McIntosh 
Run-TryBot: Than McIntosh 
TryBot-Result: Go Bot 
Reviewed-by: David Chase 
Reviewed-by: Cherry Mui 
---
 src/cmd/link/internal/dwtest/dwtest.go | 197 ++++++++++++++++++
 src/cmd/link/internal/ld/dwarf_test.go | 266 ++++---------------------
 2 files changed, 241 insertions(+), 222 deletions(-)
 create mode 100644 src/cmd/link/internal/dwtest/dwtest.go

diff --git a/src/cmd/link/internal/dwtest/dwtest.go b/src/cmd/link/internal/dwtest/dwtest.go
new file mode 100644
index 0000000000..c68edf4187
--- /dev/null
+++ b/src/cmd/link/internal/dwtest/dwtest.go
@@ -0,0 +1,197 @@
+// 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 dwtest
+
+import (
+	"debug/dwarf"
+	"errors"
+	"fmt"
+	"os"
+)
+
+// Helper type for supporting queries on DIEs within a DWARF
+// .debug_info section. Invoke the populate() method below passing in
+// a dwarf.Reader, which will read in all DIEs and keep track of
+// parent/child relationships. Queries can then be made to ask for
+// DIEs by name or by offset. This will hopefully reduce boilerplate
+// for future test writing.
+
+type Examiner struct {
+	dies        []*dwarf.Entry
+	idxByOffset map[dwarf.Offset]int
+	kids        map[int][]int
+	parent      map[int]int
+	byname      map[string][]int
+}
+
+// Populate the Examiner using the DIEs read from rdr.
+func (ex *Examiner) Populate(rdr *dwarf.Reader) error {
+	ex.idxByOffset = make(map[dwarf.Offset]int)
+	ex.kids = make(map[int][]int)
+	ex.parent = make(map[int]int)
+	ex.byname = make(map[string][]int)
+	var nesting []int
+	for entry, err := rdr.Next(); entry != nil; entry, err = rdr.Next() {
+		if err != nil {
+			return err
+		}
+		if entry.Tag == 0 {
+			// terminator
+			if len(nesting) == 0 {
+				return errors.New("nesting stack underflow")
+			}
+			nesting = nesting[:len(nesting)-1]
+			continue
+		}
+		idx := len(ex.dies)
+		ex.dies = append(ex.dies, entry)
+		if _, found := ex.idxByOffset[entry.Offset]; found {
+			return errors.New("DIE clash on offset")
+		}
+		ex.idxByOffset[entry.Offset] = idx
+		if name, ok := entry.Val(dwarf.AttrName).(string); ok {
+			ex.byname[name] = append(ex.byname[name], idx)
+		}
+		if len(nesting) > 0 {
+			parent := nesting[len(nesting)-1]
+			ex.kids[parent] = append(ex.kids[parent], idx)
+			ex.parent[idx] = parent
+		}
+		if entry.Children {
+			nesting = append(nesting, idx)
+		}
+	}
+	if len(nesting) > 0 {
+		return errors.New("unterminated child sequence")
+	}
+	return nil
+}
+
+func (e *Examiner) DIEs() []*dwarf.Entry {
+	return e.dies
+}
+
+func indent(ilevel int) {
+	for i := 0; i < ilevel; i++ {
+		fmt.Printf("  ")
+	}
+}
+
+// For debugging new tests
+func (ex *Examiner) DumpEntry(idx int, dumpKids bool, ilevel int) {
+	if idx >= len(ex.dies) {
+		fmt.Fprintf(os.Stderr, "DumpEntry: bad DIE %d: index out of range\n", idx)
+		return
+	}
+	entry := ex.dies[idx]
+	indent(ilevel)
+	fmt.Printf("0x%x: %v\n", idx, entry.Tag)
+	for _, f := range entry.Field {
+		indent(ilevel)
+		fmt.Printf("at=%v val=0x%x\n", f.Attr, f.Val)
+	}
+	if dumpKids {
+		ksl := ex.kids[idx]
+		for _, k := range ksl {
+			ex.DumpEntry(k, true, ilevel+2)
+		}
+	}
+}
+
+// Given a DIE offset, return the previously read dwarf.Entry, or nil
+func (ex *Examiner) EntryFromOffset(off dwarf.Offset) *dwarf.Entry {
+	if idx, found := ex.idxByOffset[off]; found && idx != -1 {
+		return ex.entryFromIdx(idx)
+	}
+	return nil
+}
+
+// Return the ID that Examiner uses to refer to the DIE at offset off
+func (ex *Examiner) IdxFromOffset(off dwarf.Offset) int {
+	if idx, found := ex.idxByOffset[off]; found {
+		return idx
+	}
+	return -1
+}
+
+// Return the dwarf.Entry pointer for the DIE with id 'idx'
+func (ex *Examiner) entryFromIdx(idx int) *dwarf.Entry {
+	if idx >= len(ex.dies) || idx < 0 {
+		return nil
+	}
+	return ex.dies[idx]
+}
+
+// Returns a list of child entries for a die with ID 'idx'
+func (ex *Examiner) Children(idx int) []*dwarf.Entry {
+	sl := ex.kids[idx]
+	ret := make([]*dwarf.Entry, len(sl))
+	for i, k := range sl {
+		ret[i] = ex.entryFromIdx(k)
+	}
+	return ret
+}
+
+// Returns parent DIE for DIE 'idx', or nil if the DIE is top level
+func (ex *Examiner) Parent(idx int) *dwarf.Entry {
+	p, found := ex.parent[idx]
+	if !found {
+		return nil
+	}
+	return ex.entryFromIdx(p)
+}
+
+// ParentCU returns the enclosing compilation unit DIE for the DIE
+// with a given index, or nil if for some reason we can't establish a
+// parent.
+func (ex *Examiner) ParentCU(idx int) *dwarf.Entry {
+	for {
+		parentDie := ex.Parent(idx)
+		if parentDie == nil {
+			return nil
+		}
+		if parentDie.Tag == dwarf.TagCompileUnit {
+			return parentDie
+		}
+		idx = ex.IdxFromOffset(parentDie.Offset)
+	}
+}
+
+// FileRef takes a given DIE by index and a numeric file reference
+// (presumably from a decl_file or call_file attribute), looks up the
+// reference in the .debug_line file table, and returns the proper
+// string for it. We need to know which DIE is making the reference
+// so as to find the right compilation unit.
+func (ex *Examiner) FileRef(dw *dwarf.Data, dieIdx int, fileRef int64) (string, error) {
+
+	// Find the parent compilation unit DIE for the specified DIE.
+	cuDie := ex.ParentCU(dieIdx)
+	if cuDie == nil {
+		return "", fmt.Errorf("no parent CU DIE for DIE with idx %d?", dieIdx)
+	}
+	// Construct a line reader and then use it to get the file string.
+	lr, lrerr := dw.LineReader(cuDie)
+	if lrerr != nil {
+		return "", fmt.Errorf("d.LineReader: %v", lrerr)
+	}
+	files := lr.Files()
+	if fileRef < 0 || int(fileRef) > len(files)-1 {
+		return "", fmt.Errorf("Examiner.FileRef: malformed file reference %d", fileRef)
+	}
+	return files[fileRef].Name, nil
+}
+
+// Return a list of all DIEs with name 'name'. When searching for DIEs
+// by name, keep in mind that the returned results will include child
+// DIEs such as params/variables. For example, asking for all DIEs named
+// "p" for even a small program will give you 400-500 entries.
+func (ex *Examiner) Named(name string) []*dwarf.Entry {
+	sl := ex.byname[name]
+	ret := make([]*dwarf.Entry, len(sl))
+	for i, k := range sl {
+		ret[i] = ex.entryFromIdx(k)
+	}
+	return ret
+}
diff --git a/src/cmd/link/internal/ld/dwarf_test.go b/src/cmd/link/internal/ld/dwarf_test.go
index 9a163488e6..2f9bf25d10 100644
--- a/src/cmd/link/internal/ld/dwarf_test.go
+++ b/src/cmd/link/internal/ld/dwarf_test.go
@@ -7,9 +7,9 @@ package ld
 import (
 	intdwarf "cmd/internal/dwarf"
 	objfilepkg "cmd/internal/objfile" // renamed to avoid conflict with objfile function
+	"cmd/link/internal/dwtest"
 	"debug/dwarf"
 	"debug/pe"
-	"errors"
 	"fmt"
 	"internal/buildcfg"
 	"internal/testenv"
@@ -352,8 +352,8 @@ func varDeclCoordsAndSubrogramDeclFile(t *testing.T, testpoint string, expectFil
 	}
 
 	rdr := d.Reader()
-	ex := examiner{}
-	if err := ex.populate(rdr); err != nil {
+	ex := dwtest.Examiner{}
+	if err := ex.Populate(rdr); err != nil {
 		t.Fatalf("error reading DWARF: %v", err)
 	}
 
@@ -373,7 +373,7 @@ func varDeclCoordsAndSubrogramDeclFile(t *testing.T, testpoint string, expectFil
 	}
 
 	// Walk main's children and select variable "i".
-	mainIdx := ex.idxFromOffset(maindie.Offset)
+	mainIdx := ex.IdxFromOffset(maindie.Offset)
 	childDies := ex.Children(mainIdx)
 	var iEntry *dwarf.Entry
 	for _, child := range childDies {
@@ -396,7 +396,10 @@ func varDeclCoordsAndSubrogramDeclFile(t *testing.T, testpoint string, expectFil
 	if !fileIdxOK {
 		t.Errorf("missing or invalid DW_AT_decl_file for main")
 	}
-	file := ex.FileRef(t, d, mainIdx, fileIdx)
+	file, err := ex.FileRef(d, mainIdx, fileIdx)
+	if err != nil {
+		t.Fatalf("FileRef: %v", err)
+	}
 	base := filepath.Base(file)
 	if base != expectFile {
 		t.Errorf("DW_AT_decl_file for main is %v, want %v", base, expectFile)
@@ -424,191 +427,6 @@ func TestVarDeclCoordsWithLineDirective(t *testing.T) {
 		"foobar.go", 202, "//line /foobar.go:200")
 }
 
-// Helper class for supporting queries on DIEs within a DWARF .debug_info
-// section. Invoke the populate() method below passing in a dwarf.Reader,
-// which will read in all DIEs and keep track of parent/child
-// relationships. Queries can then be made to ask for DIEs by name or
-// by offset. This will hopefully reduce boilerplate for future test
-// writing.
-
-type examiner struct {
-	dies        []*dwarf.Entry
-	idxByOffset map[dwarf.Offset]int
-	kids        map[int][]int
-	parent      map[int]int
-	byname      map[string][]int
-}
-
-// Populate the examiner using the DIEs read from rdr.
-func (ex *examiner) populate(rdr *dwarf.Reader) error {
-	ex.idxByOffset = make(map[dwarf.Offset]int)
-	ex.kids = make(map[int][]int)
-	ex.parent = make(map[int]int)
-	ex.byname = make(map[string][]int)
-	var nesting []int
-	for entry, err := rdr.Next(); entry != nil; entry, err = rdr.Next() {
-		if err != nil {
-			return err
-		}
-		if entry.Tag == 0 {
-			// terminator
-			if len(nesting) == 0 {
-				return errors.New("nesting stack underflow")
-			}
-			nesting = nesting[:len(nesting)-1]
-			continue
-		}
-		idx := len(ex.dies)
-		ex.dies = append(ex.dies, entry)
-		if _, found := ex.idxByOffset[entry.Offset]; found {
-			return errors.New("DIE clash on offset")
-		}
-		ex.idxByOffset[entry.Offset] = idx
-		if name, ok := entry.Val(dwarf.AttrName).(string); ok {
-			ex.byname[name] = append(ex.byname[name], idx)
-		}
-		if len(nesting) > 0 {
-			parent := nesting[len(nesting)-1]
-			ex.kids[parent] = append(ex.kids[parent], idx)
-			ex.parent[idx] = parent
-		}
-		if entry.Children {
-			nesting = append(nesting, idx)
-		}
-	}
-	if len(nesting) > 0 {
-		return errors.New("unterminated child sequence")
-	}
-	return nil
-}
-
-func indent(ilevel int) {
-	for i := 0; i < ilevel; i++ {
-		fmt.Printf("  ")
-	}
-}
-
-// For debugging new tests
-func (ex *examiner) dumpEntry(idx int, dumpKids bool, ilevel int) error {
-	if idx >= len(ex.dies) {
-		msg := fmt.Sprintf("bad DIE %d: index out of range\n", idx)
-		return errors.New(msg)
-	}
-	entry := ex.dies[idx]
-	indent(ilevel)
-	fmt.Printf("0x%x: %v\n", idx, entry.Tag)
-	for _, f := range entry.Field {
-		indent(ilevel)
-		fmt.Printf("at=%v val=0x%x\n", f.Attr, f.Val)
-	}
-	if dumpKids {
-		ksl := ex.kids[idx]
-		for _, k := range ksl {
-			ex.dumpEntry(k, true, ilevel+2)
-		}
-	}
-	return nil
-}
-
-// Given a DIE offset, return the previously read dwarf.Entry, or nil
-func (ex *examiner) entryFromOffset(off dwarf.Offset) *dwarf.Entry {
-	if idx, found := ex.idxByOffset[off]; found && idx != -1 {
-		return ex.entryFromIdx(idx)
-	}
-	return nil
-}
-
-// Return the ID that examiner uses to refer to the DIE at offset off
-func (ex *examiner) idxFromOffset(off dwarf.Offset) int {
-	if idx, found := ex.idxByOffset[off]; found {
-		return idx
-	}
-	return -1
-}
-
-// Return the dwarf.Entry pointer for the DIE with id 'idx'
-func (ex *examiner) entryFromIdx(idx int) *dwarf.Entry {
-	if idx >= len(ex.dies) || idx < 0 {
-		return nil
-	}
-	return ex.dies[idx]
-}
-
-// Returns a list of child entries for a die with ID 'idx'
-func (ex *examiner) Children(idx int) []*dwarf.Entry {
-	sl := ex.kids[idx]
-	ret := make([]*dwarf.Entry, len(sl))
-	for i, k := range sl {
-		ret[i] = ex.entryFromIdx(k)
-	}
-	return ret
-}
-
-// Returns parent DIE for DIE 'idx', or nil if the DIE is top level
-func (ex *examiner) Parent(idx int) *dwarf.Entry {
-	p, found := ex.parent[idx]
-	if !found {
-		return nil
-	}
-	return ex.entryFromIdx(p)
-}
-
-// ParentCU returns the enclosing compilation unit DIE for the DIE
-// with a given index, or nil if for some reason we can't establish a
-// parent.
-func (ex *examiner) ParentCU(idx int) *dwarf.Entry {
-	for {
-		parentDie := ex.Parent(idx)
-		if parentDie == nil {
-			return nil
-		}
-		if parentDie.Tag == dwarf.TagCompileUnit {
-			return parentDie
-		}
-		idx = ex.idxFromOffset(parentDie.Offset)
-	}
-}
-
-// FileRef takes a given DIE by index and a numeric file reference
-// (presumably from a decl_file or call_file attribute), looks up the
-// reference in the .debug_line file table, and returns the proper
-// string for it. We need to know which DIE is making the reference
-// so as find the right compilation unit.
-func (ex *examiner) FileRef(t *testing.T, dw *dwarf.Data, dieIdx int, fileRef int64) string {
-
-	// Find the parent compilation unit DIE for the specified DIE.
-	cuDie := ex.ParentCU(dieIdx)
-	if cuDie == nil {
-		t.Fatalf("no parent CU DIE for DIE with idx %d?", dieIdx)
-		return ""
-	}
-	// Construct a line reader and then use it to get the file string.
-	lr, lrerr := dw.LineReader(cuDie)
-	if lrerr != nil {
-		t.Fatal("d.LineReader: ", lrerr)
-		return ""
-	}
-	files := lr.Files()
-	if fileRef < 0 || int(fileRef) > len(files)-1 {
-		t.Fatalf("examiner.FileRef: malformed file reference %d", fileRef)
-		return ""
-	}
-	return files[fileRef].Name
-}
-
-// Return a list of all DIEs with name 'name'. When searching for DIEs
-// by name, keep in mind that the returned results will include child
-// DIEs such as params/variables. For example, asking for all DIEs named
-// "p" for even a small program will give you 400-500 entries.
-func (ex *examiner) Named(name string) []*dwarf.Entry {
-	sl := ex.byname[name]
-	ret := make([]*dwarf.Entry, len(sl))
-	for i, k := range sl {
-		ret[i] = ex.entryFromIdx(k)
-	}
-	return ret
-}
-
 func TestInlinedRoutineRecords(t *testing.T) {
 	testenv.MustHaveGoBuild(t)
 
@@ -656,8 +474,8 @@ func main() {
 	expectedInl := []string{"main.cand"}
 
 	rdr := d.Reader()
-	ex := examiner{}
-	if err := ex.populate(rdr); err != nil {
+	ex := dwtest.Examiner{}
+	if err := ex.Populate(rdr); err != nil {
 		t.Fatalf("error reading DWARF: %v", err)
 	}
 
@@ -677,7 +495,7 @@ func main() {
 	}
 
 	// Walk main's children and pick out the inlined subroutines
-	mainIdx := ex.idxFromOffset(maindie.Offset)
+	mainIdx := ex.IdxFromOffset(maindie.Offset)
 	childDies := ex.Children(mainIdx)
 	exCount := 0
 	for _, child := range childDies {
@@ -687,7 +505,7 @@ func main() {
 			if !originOK {
 				t.Fatalf("no abstract origin attr for inlined subroutine at offset %v", child.Offset)
 			}
-			originDIE := ex.entryFromOffset(ooff)
+			originDIE := ex.EntryFromOffset(ooff)
 			if originDIE == nil {
 				t.Fatalf("can't locate origin DIE at off %v", ooff)
 			}
@@ -696,7 +514,7 @@ func main() {
 			// to see child variables there, even if (perhaps due to
 			// optimization) there are no references to them from the
 			// inlined subroutine DIE.
-			absFcnIdx := ex.idxFromOffset(ooff)
+			absFcnIdx := ex.IdxFromOffset(ooff)
 			absFcnChildDies := ex.Children(absFcnIdx)
 			if len(absFcnChildDies) != 2 {
 				t.Fatalf("expected abstract function: expected 2 children, got %d children", len(absFcnChildDies))
@@ -735,7 +553,11 @@ func main() {
 			if !cfOK {
 				t.Fatalf("no call_file attr for inlined subroutine at offset %v", child.Offset)
 			}
-			file := ex.FileRef(t, d, mainIdx, cf)
+			file, err := ex.FileRef(d, mainIdx, cf)
+			if err != nil {
+				t.Errorf("FileRef: %v", err)
+				continue
+			}
 			base := filepath.Base(file)
 			if base != "test.go" {
 				t.Errorf("bad call_file attribute, found '%s', want '%s'",
@@ -747,7 +569,7 @@ func main() {
 			// Walk the child variables of the inlined routine. Each
 			// of them should have a distinct abstract origin-- if two
 			// vars point to the same origin things are definitely broken.
-			inlIdx := ex.idxFromOffset(child.Offset)
+			inlIdx := ex.IdxFromOffset(child.Offset)
 			inlChildDies := ex.Children(inlIdx)
 			for _, k := range inlChildDies {
 				ooff, originOK := k.Val(dwarf.AttrAbstractOrigin).(dwarf.Offset)
@@ -780,15 +602,15 @@ func abstractOriginSanity(t *testing.T, pkgDir string, flags string) {
 		t.Fatalf("error reading DWARF: %v", err)
 	}
 	rdr := d.Reader()
-	ex := examiner{}
-	if err := ex.populate(rdr); err != nil {
+	ex := dwtest.Examiner{}
+	if err := ex.Populate(rdr); err != nil {
 		t.Fatalf("error reading DWARF: %v", err)
 	}
 
 	// Make a pass through all DIEs looking for abstract origin
 	// references.
 	abscount := 0
-	for i, die := range ex.dies {
+	for i, die := range ex.DIEs() {
 		// Does it have an abstract origin?
 		ooff, originOK := die.Val(dwarf.AttrAbstractOrigin).(dwarf.Offset)
 		if !originOK {
@@ -797,9 +619,9 @@ func abstractOriginSanity(t *testing.T, pkgDir string, flags string) {
 
 		// All abstract origin references should be resolvable.
 		abscount += 1
-		originDIE := ex.entryFromOffset(ooff)
+		originDIE := ex.EntryFromOffset(ooff)
 		if originDIE == nil {
-			ex.dumpEntry(i, false, 0)
+			ex.DumpEntry(i, false, 0)
 			t.Fatalf("unresolved abstract origin ref in DIE at offset 0x%x\n", die.Offset)
 		}
 
@@ -807,7 +629,7 @@ func abstractOriginSanity(t *testing.T, pkgDir string, flags string) {
 		// K2, ... KN}. If X has an abstract origin of A, then for
 		// each KJ, the abstract origin of KJ should be a child of A.
 		// Note that this same rule doesn't hold for non-variable DIEs.
-		pidx := ex.idxFromOffset(die.Offset)
+		pidx := ex.IdxFromOffset(die.Offset)
 		if pidx < 0 {
 			t.Fatalf("can't locate DIE id")
 		}
@@ -821,15 +643,15 @@ func abstractOriginSanity(t *testing.T, pkgDir string, flags string) {
 			if !originOK {
 				continue
 			}
-			childOriginDIE := ex.entryFromOffset(kooff)
+			childOriginDIE := ex.EntryFromOffset(kooff)
 			if childOriginDIE == nil {
-				ex.dumpEntry(i, false, 0)
+				ex.DumpEntry(i, false, 0)
 				t.Fatalf("unresolved abstract origin ref in DIE at offset %x", kid.Offset)
 			}
-			coidx := ex.idxFromOffset(childOriginDIE.Offset)
+			coidx := ex.IdxFromOffset(childOriginDIE.Offset)
 			childOriginParent := ex.Parent(coidx)
 			if childOriginParent != originDIE {
-				ex.dumpEntry(i, false, 0)
+				ex.DumpEntry(i, false, 0)
 				t.Fatalf("unexpected parent of abstract origin DIE at offset %v", childOriginDIE.Offset)
 			}
 		}
@@ -977,8 +799,8 @@ func main() {
 	}
 
 	rdr := d.Reader()
-	ex := examiner{}
-	if err := ex.populate(rdr); err != nil {
+	ex := dwtest.Examiner{}
+	if err := ex.Populate(rdr); err != nil {
 		t.Fatalf("error reading DWARF: %v", err)
 	}
 	dies := ex.Named("*main.X")
@@ -1501,8 +1323,8 @@ func TestIssue39757(t *testing.T) {
 		t.Fatalf("error parsing DWARF: %v", err)
 	}
 	rdr := dw.Reader()
-	ex := examiner{}
-	if err := ex.populate(rdr); err != nil {
+	ex := dwtest.Examiner{}
+	if err := ex.Populate(rdr); err != nil {
 		t.Fatalf("error reading DWARF: %v", err)
 	}
 
@@ -1521,7 +1343,7 @@ func TestIssue39757(t *testing.T) {
 	highpc := maindie.Val(dwarf.AttrHighpc).(uint64)
 
 	// Now read the line table for the 'main' compilation unit.
-	mainIdx := ex.idxFromOffset(maindie.Offset)
+	mainIdx := ex.IdxFromOffset(maindie.Offset)
 	cuentry := ex.Parent(mainIdx)
 	if cuentry == nil {
 		t.Fatalf("main.main DIE appears orphaned")
@@ -1648,7 +1470,7 @@ func TestIssue42484(t *testing.T) {
 //
 // where each chunk above is of the form NAME:ORDER:INOUTCLASSIFICATION
 //
-func processParams(die *dwarf.Entry, ex *examiner) string {
+func processParams(die *dwarf.Entry, ex *dwtest.Examiner) string {
 	// Values in the returned map are of the form :
 	// where order is the order within the child DIE list of the
 	// param, and  is an integer:
@@ -1659,9 +1481,9 @@ func processParams(die *dwarf.Entry, ex *examiner) string {
 	//
 	foundParams := make(map[string]string)
 
-	// Walk ABCs's children looking for params.
-	abcIdx := ex.idxFromOffset(die.Offset)
-	childDies := ex.Children(abcIdx)
+	// Walk the subprogram DIE's children looking for params.
+	pIdx := ex.IdxFromOffset(die.Offset)
+	childDies := ex.Children(pIdx)
 	idx := 0
 	for _, child := range childDies {
 		if child.Tag == dwarf.TagFormalParameter {
@@ -1734,8 +1556,8 @@ func main() {
 	}
 
 	rdr := d.Reader()
-	ex := examiner{}
-	if err := ex.populate(rdr); err != nil {
+	ex := dwtest.Examiner{}
+	if err := ex.Populate(rdr); err != nil {
 		t.Fatalf("error reading DWARF: %v", err)
 	}
 
@@ -1854,8 +1676,8 @@ func main() {
 	}
 
 	rdr.Seek(0)
-	ex := examiner{}
-	if err := ex.populate(rdr); err != nil {
+	ex := dwtest.Examiner{}
+	if err := ex.Populate(rdr); err != nil {
 		t.Fatalf("error reading DWARF: %v", err)
 	}
 	for _, typeName := range []string{"main.CustomInt", "map[int]main.CustomInt"} {
@@ -1969,8 +1791,8 @@ func main() {
 	}
 
 	rdr := d.Reader()
-	ex := examiner{}
-	if err := ex.populate(rdr); err != nil {
+	ex := dwtest.Examiner{}
+	if err := ex.Populate(rdr); err != nil {
 		t.Fatalf("error reading DWARF: %v", err)
 	}
 

From 9ea939be600df12fe51b201112cc12e741acef00 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 20:01:16 -0500
Subject: [PATCH 234/752] go/types: implement Checker.implements

This is a port of CL 363837 from types2 to go/types. As usual, test
error messages had to be repositioned on the operand.

Change-Id: I2b53fae7aa30f9147f8d05f75b0ab252338320bb
Reviewed-on: https://go-review.googlesource.com/c/go/+/364934
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/instantiate.go                   | 131 ++++++++++--------
 .../types/testdata/fixedbugs/issue45920.go2   |   4 +-
 2 files changed, 72 insertions(+), 63 deletions(-)

diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index c9ce6f6ae1..737340d086 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -133,34 +133,6 @@ func (check *Checker) validateTArgLen(pos token.Pos, ntparams, ntargs int) bool
 }
 
 func (check *Checker) verify(pos token.Pos, tparams []*TypeParam, targs []Type) (int, error) {
-	smap := makeSubstMap(tparams, targs)
-	for i, tpar := range tparams {
-		// stop checking bounds after the first failure
-		if err := check.satisfies(pos, targs[i], tpar, smap); err != nil {
-			return i, err
-		}
-	}
-	return -1, nil
-}
-
-// satisfies reports whether the type argument targ satisfies the constraint of type parameter
-// parameter tpar (after any of its type parameters have been substituted through smap).
-// A suitable error is reported if the result is false.
-// TODO(gri) This should be a method of interfaces or type sets.
-func (check *Checker) satisfies(pos token.Pos, targ Type, tpar *TypeParam, smap substMap) error {
-	iface := tpar.iface()
-
-	// Every type argument satisfies interface{}.
-	if iface.Empty() {
-		return nil
-	}
-
-	// A type argument that is a type parameter with an empty type set satisfies any constraint.
-	// (The empty set is a subset of any set.)
-	if targ, _ := targ.(*TypeParam); targ != nil && targ.iface().typeSet().IsEmpty() {
-		return nil
-	}
-
 	// TODO(rfindley): it would be great if users could pass in a qualifier here,
 	// rather than falling back to verbose qualification. Maybe this can be part
 	// of the shared context.
@@ -168,78 +140,115 @@ func (check *Checker) satisfies(pos token.Pos, targ Type, tpar *TypeParam, smap
 	if check != nil {
 		qf = check.qualifier
 	}
+
+	smap := makeSubstMap(tparams, targs)
+	for i, tpar := range tparams {
+		// The type parameter bound is parameterized with the same type parameters
+		// as the instantiated type; before we can use it for bounds checking we
+		// need to instantiate it with the type arguments with which we instantiated
+		// the parameterized type.
+		bound := check.subst(pos, tpar.bound, smap, nil)
+		if err := check.implements(targs[i], bound, qf); err != nil {
+			return i, err
+		}
+	}
+	return -1, nil
+}
+
+// implements checks if V implements T and reports an error if it doesn't.
+// If a qualifier is provided, it is used in error formatting.
+func (check *Checker) implements(V, T Type, qf Qualifier) error {
+	Vu := under(V)
+	Tu := under(T)
+	if Vu == Typ[Invalid] || Tu == Typ[Invalid] {
+		return nil
+	}
+
 	errorf := func(format string, args ...interface{}) error {
 		return errors.New(sprintf(nil, qf, false, format, args...))
 	}
 
-	// No type argument with non-empty type set satisfies the empty type set.
-	if iface.typeSet().IsEmpty() {
-		return errorf("%s does not satisfy %s (constraint type set is empty)", targ, tpar.bound)
+	Ti, _ := Tu.(*Interface)
+	if Ti == nil {
+		return errorf("%s is not an interface", T)
 	}
 
-	// The type parameter bound is parameterized with the same type parameters
-	// as the instantiated type; before we can use it for bounds checking we
-	// need to instantiate it with the type arguments with which we instantiate
-	// the parameterized type.
-	iface = check.subst(pos, iface, smap, nil).(*Interface)
+	// Every type satisfies the empty interface.
+	if Ti.Empty() {
+		return nil
+	}
+	// T is not the empty interface (i.e., the type set of T is restricted)
 
-	// if iface is comparable, targ must be comparable
+	// An interface V with an empty type set satisfies any interface.
+	// (The empty set is a subset of any set.)
+	Vi, _ := Vu.(*Interface)
+	if Vi != nil && Vi.typeSet().IsEmpty() {
+		return nil
+	}
+	// type set of V is not empty
+
+	// No type with non-empty type set satisfies the empty type set.
+	// TODO(gri) should use "implements" rather than "satisfies" throughout
+	if Ti.typeSet().IsEmpty() {
+		return errorf("%s does not satisfy %s (constraint type set is empty)", V, T)
+	}
+
+	// If T is comparable, V must be comparable.
 	// TODO(gri) the error messages needs to be better, here
-	if iface.IsComparable() && !Comparable(targ) {
-		if tpar, _ := targ.(*TypeParam); tpar != nil && tpar.iface().typeSet().IsAll() {
-			return errorf("%s has no constraints", targ)
+	if Ti.IsComparable() && !Comparable(V) {
+		if Vi != nil && Vi.typeSet().IsAll() {
+			return errorf("%s has no constraints", V)
 		}
-		return errorf("%s does not satisfy comparable", targ)
+		return errorf("%s does not satisfy comparable", V)
 	}
 
-	// targ must implement iface (methods)
+	// V must implement T (methods)
 	// - check only if we have methods
-	if iface.NumMethods() > 0 {
+	if Ti.NumMethods() > 0 {
 		// If the type argument is a pointer to a type parameter, the type argument's
 		// method set is empty.
 		// TODO(gri) is this what we want? (spec question)
-		if base, isPtr := deref(targ); isPtr && isTypeParam(base) {
-			return errorf("%s has no methods", targ)
+		if base, isPtr := deref(V); isPtr && isTypeParam(base) {
+			return errorf("%s has no methods", V)
 		}
-		if m, wrong := check.missingMethod(targ, iface, true); m != nil {
+		if m, wrong := check.missingMethod(V, Ti, true); m != nil {
 			// TODO(gri) needs to print updated name to avoid major confusion in error message!
 			//           (print warning for now)
 			// Old warning:
-			// check.softErrorf(pos, "%s does not satisfy %s (warning: name not updated) = %s (missing method %s)", targ, tpar.bound, iface, m)
+			// check.softErrorf(pos, "%s does not satisfy %s (warning: name not updated) = %s (missing method %s)", V, T, Ti, m)
 			if wrong != nil {
 				// TODO(gri) This can still report uninstantiated types which makes the error message
 				//           more difficult to read then necessary.
 				// TODO(rFindley) should this use parentheses rather than ':' for qualification?
 				return errorf("%s does not satisfy %s: wrong method signature\n\tgot  %s\n\twant %s",
-					targ, tpar.bound, wrong, m,
+					V, T, wrong, m,
 				)
 			}
-			return errorf("%s does not satisfy %s (missing method %s)", targ, tpar.bound, m.name)
+			return errorf("%s does not satisfy %s (missing method %s)", V, T, m.name)
 		}
 	}
 
-	// targ must also be in the set of types of iface, if any.
+	// V must also be in the set of types of T, if any.
 	// Constraints with empty type sets were already excluded above.
-	if !iface.typeSet().hasTerms() {
+	if !Ti.typeSet().hasTerms() {
 		return nil // nothing to do
 	}
 
-	// If targ is itself a type parameter, each of its possible types must be in the set
-	// of iface types (i.e., the targ type set must be a subset of the iface type set).
-	// Type arguments with empty type sets were already excluded above.
-	if targ, _ := targ.(*TypeParam); targ != nil {
-		targBound := targ.iface()
-		if !targBound.typeSet().subsetOf(iface.typeSet()) {
+	// If V is itself an interface, each of its possible types must be in the set
+	// of T types (i.e., the V type set must be a subset of the T type set).
+	// Interfaces V with empty type sets were already excluded above.
+	if Vi != nil {
+		if !Vi.typeSet().subsetOf(Ti.typeSet()) {
 			// TODO(gri) report which type is missing
-			return errorf("%s does not satisfy %s", targ, tpar.bound)
+			return errorf("%s does not satisfy %s", V, T)
 		}
 		return nil
 	}
 
-	// Otherwise, targ's type must be included in the iface type set.
-	if !iface.typeSet().includes(targ) {
+	// Otherwise, V's type must be included in the iface type set.
+	if !Ti.typeSet().includes(V) {
 		// TODO(gri) report which type is missing
-		return errorf("%s does not satisfy %s", targ, tpar.bound)
+		return errorf("%s does not satisfy %s", V, T)
 	}
 
 	return nil
diff --git a/src/go/types/testdata/fixedbugs/issue45920.go2 b/src/go/types/testdata/fixedbugs/issue45920.go2
index f659f3a0db..60a9e83fa9 100644
--- a/src/go/types/testdata/fixedbugs/issue45920.go2
+++ b/src/go/types/testdata/fixedbugs/issue45920.go2
@@ -8,10 +8,10 @@ func f1[T any, C chan T | <-chan T](ch C) {}
 
 func _(ch chan int)   { f1(ch) }
 func _(ch <-chan int) { f1(ch) }
-func _(ch chan<- int) { f1 /* ERROR chan<- int does not satisfy chan T\|<-chan T */ (ch) }
+func _(ch chan<- int) { f1 /* ERROR chan<- int does not satisfy chan int\|<-chan int */ (ch) }
 
 func f2[T any, C chan T | chan<- T](ch C) {}
 
 func _(ch chan int)   { f2(ch) }
-func _(ch <-chan int) { f2 /* ERROR <-chan int does not satisfy chan T\|chan<- T */ (ch)}
+func _(ch <-chan int) { f2 /* ERROR <-chan int does not satisfy chan int\|chan<- int */ (ch) }
 func _(ch chan<- int) { f2(ch) }

From 5d5f2b1e201fe9f3b641109ccd91b3ceae4cf460 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 20:04:14 -0500
Subject: [PATCH 235/752] go/types: remove unneccesary tests in implements and
 lookup

This is a port of CL 363838 from types2 to go/types.

Change-Id: I03f4da86ea38209a73f567cc5d84e7afd08883ac
Reviewed-on: https://go-review.googlesource.com/c/go/+/364935
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/instantiate.go | 6 ------
 src/go/types/lookup.go      | 6 +-----
 2 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index 737340d086..63b4a1ea4a 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -205,12 +205,6 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 	// V must implement T (methods)
 	// - check only if we have methods
 	if Ti.NumMethods() > 0 {
-		// If the type argument is a pointer to a type parameter, the type argument's
-		// method set is empty.
-		// TODO(gri) is this what we want? (spec question)
-		if base, isPtr := deref(V); isPtr && isTypeParam(base) {
-			return errorf("%s has no methods", V)
-		}
 		if m, wrong := check.missingMethod(V, Ti, true); m != nil {
 			// TODO(gri) needs to print updated name to avoid major confusion in error message!
 			//           (print warning for now)
diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go
index e3c43a94f7..c787601a06 100644
--- a/src/go/types/lookup.go
+++ b/src/go/types/lookup.go
@@ -80,12 +80,8 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o
 
 	typ, isPtr := deref(T)
 
-	// *typ where typ is an interface or type parameter has no methods.
+	// *typ where typ is an interface has no methods.
 	if isPtr {
-		// don't look at under(typ) here - was bug (issue #47747)
-		if _, ok := typ.(*TypeParam); ok {
-			return
-		}
 		if _, ok := under(typ).(*Interface); ok {
 			return
 		}

From 8d6c4e07fdd4a81c466450b51cda71a1bfab41fc Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 20:17:55 -0500
Subject: [PATCH 236/752] go/types: use "implements" rather than "satisfies" in
 error messages

This is a port of CL 363839 from types2 to go/types.

Change-Id: I9efe412a6a602fd55170d1ee89c8e1513037c926
Reviewed-on: https://go-review.googlesource.com/c/go/+/364936
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/instantiate.go                   | 21 +++++++-------
 src/go/types/testdata/check/issues.go2        |  6 ++--
 src/go/types/testdata/check/typeinst2.go2     | 28 +++++++++----------
 src/go/types/testdata/examples/inference.go2  |  2 +-
 .../types/testdata/fixedbugs/issue39754.go2   |  4 +--
 .../types/testdata/fixedbugs/issue45920.go2   |  4 +--
 .../types/testdata/fixedbugs/issue47411.go2   | 10 +++----
 7 files changed, 37 insertions(+), 38 deletions(-)

diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index 63b4a1ea4a..011fb8e540 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -188,18 +188,17 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 	// type set of V is not empty
 
 	// No type with non-empty type set satisfies the empty type set.
-	// TODO(gri) should use "implements" rather than "satisfies" throughout
 	if Ti.typeSet().IsEmpty() {
-		return errorf("%s does not satisfy %s (constraint type set is empty)", V, T)
+		return errorf("cannot implement %s (empty type set)", T)
 	}
 
 	// If T is comparable, V must be comparable.
-	// TODO(gri) the error messages needs to be better, here
+	// TODO(gri) the error messages could be better, here
 	if Ti.IsComparable() && !Comparable(V) {
-		if Vi != nil && Vi.typeSet().IsAll() {
-			return errorf("%s has no constraints", V)
+		if Vi != nil && Vi.Empty() {
+			return errorf("empty interface %s does not implement %s", V, T)
 		}
-		return errorf("%s does not satisfy comparable", V)
+		return errorf("%s does not implement comparable", V)
 	}
 
 	// V must implement T (methods)
@@ -209,16 +208,16 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 			// TODO(gri) needs to print updated name to avoid major confusion in error message!
 			//           (print warning for now)
 			// Old warning:
-			// check.softErrorf(pos, "%s does not satisfy %s (warning: name not updated) = %s (missing method %s)", V, T, Ti, m)
+			// check.softErrorf(pos, "%s does not implement %s (warning: name not updated) = %s (missing method %s)", V, T, Ti, m)
 			if wrong != nil {
 				// TODO(gri) This can still report uninstantiated types which makes the error message
 				//           more difficult to read then necessary.
 				// TODO(rFindley) should this use parentheses rather than ':' for qualification?
-				return errorf("%s does not satisfy %s: wrong method signature\n\tgot  %s\n\twant %s",
+				return errorf("%s does not implement %s: wrong method signature\n\tgot  %s\n\twant %s",
 					V, T, wrong, m,
 				)
 			}
-			return errorf("%s does not satisfy %s (missing method %s)", V, T, m.name)
+			return errorf("%s does not implement %s (missing method %s)", V, T, m.name)
 		}
 	}
 
@@ -234,7 +233,7 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 	if Vi != nil {
 		if !Vi.typeSet().subsetOf(Ti.typeSet()) {
 			// TODO(gri) report which type is missing
-			return errorf("%s does not satisfy %s", V, T)
+			return errorf("%s does not implement %s", V, T)
 		}
 		return nil
 	}
@@ -242,7 +241,7 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 	// Otherwise, V's type must be included in the iface type set.
 	if !Ti.typeSet().includes(V) {
 		// TODO(gri) report which type is missing
-		return errorf("%s does not satisfy %s", V, T)
+		return errorf("%s does not implement %s", V, T)
 	}
 
 	return nil
diff --git a/src/go/types/testdata/check/issues.go2 b/src/go/types/testdata/check/issues.go2
index b7bba5d3b1..fdb49d55f2 100644
--- a/src/go/types/testdata/check/issues.go2
+++ b/src/go/types/testdata/check/issues.go2
@@ -59,7 +59,7 @@ func _() {
 type T1[P interface{~uint}] struct{}
 
 func _[P any]() {
-    _ = T1[P /* ERROR P has no constraints */ ]{}
+    _ = T1[P /* ERROR empty interface P does not implement interface{~uint} */ ]{}
 }
 
 // This is the original (simplified) program causing the same issue.
@@ -75,8 +75,8 @@ func (u T2[U]) Add1() U {
     return u.s + 1
 }
 
-func NewT2[U any]() T2[U /* ERROR U has no constraints */ ] {
-    return T2[U /* ERROR U has no constraints */ ]{}
+func NewT2[U any]() T2[U /* ERROR empty interface U does not implement Unsigned */ ] {
+    return T2[U /* ERROR empty interface U does not implement Unsigned */ ]{}
 }
 
 func _() {
diff --git a/src/go/types/testdata/check/typeinst2.go2 b/src/go/types/testdata/check/typeinst2.go2
index f07c42a1da..1c3eb21b22 100644
--- a/src/go/types/testdata/check/typeinst2.go2
+++ b/src/go/types/testdata/check/typeinst2.go2
@@ -208,7 +208,7 @@ func f0[T I0]() {}
 var _ = f0[int]
 var _ = f0[bool]
 var _ = f0[string]
-var _ = f0[float64 /* ERROR does not satisfy I0 */ ]
+var _ = f0[float64 /* ERROR does not implement I0 */ ]
 
 type I01 interface {
 	E0
@@ -217,9 +217,9 @@ type I01 interface {
 
 func f01[T I01]() {}
 var _ = f01[int]
-var _ = f01[bool /* ERROR does not satisfy I0 */ ]
+var _ = f01[bool /* ERROR does not implement I0 */ ]
 var _ = f01[string]
-var _ = f01[float64 /* ERROR does not satisfy I0 */ ]
+var _ = f01[float64 /* ERROR does not implement I0 */ ]
 
 type I012 interface {
 	E0
@@ -228,10 +228,10 @@ type I012 interface {
 }
 
 func f012[T I012]() {}
-var _ = f012[int /* ERROR does not satisfy I012.*type set is empty */ ]
-var _ = f012[bool /* ERROR does not satisfy I012.*type set is empty */ ]
-var _ = f012[string /* ERROR does not satisfy I012.*type set is empty */ ]
-var _ = f012[float64 /* ERROR does not satisfy I012.*type set is empty */ ]
+var _ = f012[int /* ERROR cannot implement I012.*empty type set */ ]
+var _ = f012[bool /* ERROR cannot implement I012.*empty type set */ ]
+var _ = f012[string /* ERROR cannot implement I012.*empty type set */ ]
+var _ = f012[float64 /* ERROR cannot implement I012.*empty type set */ ]
 
 type I12 interface {
 	E1
@@ -239,9 +239,9 @@ type I12 interface {
 }
 
 func f12[T I12]() {}
-var _ = f12[int /* ERROR does not satisfy I12 */ ]
-var _ = f12[bool /* ERROR does not satisfy I12 */ ]
-var _ = f12[string /* ERROR does not satisfy I12 */ ]
+var _ = f12[int /* ERROR does not implement I12 */ ]
+var _ = f12[bool /* ERROR does not implement I12 */ ]
+var _ = f12[string /* ERROR does not implement I12 */ ]
 var _ = f12[float64]
 
 type I0_ interface {
@@ -251,9 +251,9 @@ type I0_ interface {
 
 func f0_[T I0_]() {}
 var _ = f0_[int]
-var _ = f0_[bool /* ERROR does not satisfy I0_ */ ]
-var _ = f0_[string /* ERROR does not satisfy I0_ */ ]
-var _ = f0_[float64 /* ERROR does not satisfy I0_ */ ]
+var _ = f0_[bool /* ERROR does not implement I0_ */ ]
+var _ = f0_[string /* ERROR does not implement I0_ */ ]
+var _ = f0_[float64 /* ERROR does not implement I0_ */ ]
 
 // Using a function instance as a type is an error.
 var _ f0 // ERROR not a type
@@ -271,7 +271,7 @@ func gg[T any]() {}
 func hh[T ~int]() {}
 
 func _[T none]() {
-        _ = ff[int /* ERROR int does not satisfy none \(constraint type set is empty\) */ ]
+        _ = ff[int /* ERROR cannot implement none \(empty type set\) */ ]
         _ = ff[T]  // pathological but ok because T's type set is empty, too
         _ = gg[int]
         _ = gg[T]
diff --git a/src/go/types/testdata/examples/inference.go2 b/src/go/types/testdata/examples/inference.go2
index 73246b0137..ffa30ee2cb 100644
--- a/src/go/types/testdata/examples/inference.go2
+++ b/src/go/types/testdata/examples/inference.go2
@@ -97,7 +97,7 @@ func _() {
 	// last.
 	related2(1.2, []float64{})
 	related2(1.0, []int{})
-	related2 /* ERROR does not satisfy */ (float64(1.0), []int{})
+	related2 /* ERROR does not implement */ (float64(1.0), []int{}) // TODO(gri) fix error position
 }
 
 type List[P any] []P
diff --git a/src/go/types/testdata/fixedbugs/issue39754.go2 b/src/go/types/testdata/fixedbugs/issue39754.go2
index 4b4420d997..cecbc88043 100644
--- a/src/go/types/testdata/fixedbugs/issue39754.go2
+++ b/src/go/types/testdata/fixedbugs/issue39754.go2
@@ -16,9 +16,9 @@ func f[V interface{}, A, B Box[V]]() {}
 
 func _() {
 	f[int, Optional[int], Optional[int]]()
-	_ = f[int, Optional[int], Optional /* ERROR does not satisfy Box */ [string]]
+	_ = f[int, Optional[int], Optional /* ERROR does not implement Box */ [string]]
 	// TODO(gri) Provide better position information here.
 	//           See TODO in call.go, Checker.arguments.
 	// TODO(rFindley) Reconcile this error position with types2.
-	f /* ERROR does not satisfy Box */ [int, Optional[int], Optional[string]]()
+	f /* ERROR does not implement Box */ [int, Optional[int], Optional[string]]()
 }
diff --git a/src/go/types/testdata/fixedbugs/issue45920.go2 b/src/go/types/testdata/fixedbugs/issue45920.go2
index 60a9e83fa9..a0e2d0c970 100644
--- a/src/go/types/testdata/fixedbugs/issue45920.go2
+++ b/src/go/types/testdata/fixedbugs/issue45920.go2
@@ -8,10 +8,10 @@ func f1[T any, C chan T | <-chan T](ch C) {}
 
 func _(ch chan int)   { f1(ch) }
 func _(ch <-chan int) { f1(ch) }
-func _(ch chan<- int) { f1 /* ERROR chan<- int does not satisfy chan int\|<-chan int */ (ch) }
+func _(ch chan<- int) { f1 /* ERROR chan<- int does not implement chan int\|<-chan int */ (ch) }
 
 func f2[T any, C chan T | chan<- T](ch C) {}
 
 func _(ch chan int)   { f2(ch) }
-func _(ch <-chan int) { f2 /* ERROR <-chan int does not satisfy chan int\|chan<- int */ (ch) }
+func _(ch <-chan int) { f2 /* ERROR <-chan int does not implement chan int\|chan<- int */ (ch) }
 func _(ch chan<- int) { f2(ch) }
diff --git a/src/go/types/testdata/fixedbugs/issue47411.go2 b/src/go/types/testdata/fixedbugs/issue47411.go2
index fde704bb41..d6c34be8db 100644
--- a/src/go/types/testdata/fixedbugs/issue47411.go2
+++ b/src/go/types/testdata/fixedbugs/issue47411.go2
@@ -15,12 +15,12 @@ func _[P comparable,
         _ = f[int]
         _ = f[P]
         _ = f[Q]
-        _ = f[func /* ERROR does not satisfy comparable */ ()]
-        _ = f[R /* ERROR R has no constraints */ ]
+        _ = f[func /* ERROR does not implement comparable */ ()]
+        _ = f[R /* ERROR empty interface R does not implement comparable */ ]
 
         _ = g[int]
-	_ = g[P /* ERROR P does not satisfy interface{interface{comparable; ~int\|~string} */ ]
+        _ = g[P /* ERROR P does not implement interface{interface{comparable; ~int\|~string} */ ]
         _ = g[Q]
-        _ = g[func /* ERROR does not satisfy comparable */()]
-        _ = g[R /* ERROR R has no constraints */ ]
+        _ = g[func /* ERROR does not implement comparable */ ()]
+        _ = g[R /* ERROR empty interface R does not implement interface{interface{comparable; ~int\|~string} */ ]
 }

From feb330dcdd86146f5c9b4e09d30e19fc920f78f4 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Wed, 17 Nov 2021 20:22:32 -0500
Subject: [PATCH 237/752] go/types: add test for imported constraints pre-1.18

This is a port of CL 363834 from types2 to go/types.

Change-Id: I32583ead4bce626e0761f4c327678050404a15c9
Reviewed-on: https://go-review.googlesource.com/c/go/+/364937
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/go/types/check_test.go                     | 17 +++++++++++++++++
 src/go/types/testdata/fixedbugs/issue47818.go2 |  4 +++-
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index 75b26e34bd..2f80d9b7b6 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -31,6 +31,7 @@ import (
 	"go/parser"
 	"go/scanner"
 	"go/token"
+	"internal/buildcfg"
 	"internal/testenv"
 	"os"
 	"path/filepath"
@@ -199,11 +200,27 @@ func asGoVersion(s string) string {
 	return ""
 }
 
+// excludedForUnifiedBuild lists files that cannot be tested
+// when using the unified build's export data.
+// TODO(gri) enable as soon as the unified build supports this.
+var excludedForUnifiedBuild = map[string]bool{
+	"issue47818.go2": true,
+}
+
 func testFiles(t *testing.T, sizes Sizes, filenames []string, srcs [][]byte, manual bool, imp Importer) {
 	if len(filenames) == 0 {
 		t.Fatal("no source files")
 	}
 
+	if buildcfg.Experiment.Unified {
+		for _, f := range filenames {
+			if excludedForUnifiedBuild[filepath.Base(f)] {
+				t.Logf("%s cannot be tested with unified build - skipped", f)
+				return
+			}
+		}
+	}
+
 	if strings.HasSuffix(filenames[0], ".go1") {
 		// TODO(rfindley): re-enable this test by using GoVersion.
 		t.Skip("type params are enabled")
diff --git a/src/go/types/testdata/fixedbugs/issue47818.go2 b/src/go/types/testdata/fixedbugs/issue47818.go2
index e3e5a99637..2631118bae 100644
--- a/src/go/types/testdata/fixedbugs/issue47818.go2
+++ b/src/go/types/testdata/fixedbugs/issue47818.go2
@@ -8,6 +8,8 @@
 
 package go1_17
 
+import "constraints"
+
 type T[P /* ERROR type parameters require go1\.18 or later */ any /* ERROR undeclared name: any \(requires version go1\.18 or later\) */ ] struct{}
 
 // for init (and main, but we're not in package main) we should only get one error
@@ -56,4 +58,4 @@ type (
 	_ = C2
 )
 
-// TODO(gri) need test cases for imported constraint types (see also issue #47967)
+type Ordered constraints /* ERROR using type constraint constraints\.Ordered requires go1\.18 or later */ .Ordered

From c4aae23d6426442402b3de0e5f7de1ef8da3842a Mon Sep 17 00:00:00 2001
From: Mikhail Faraponov <11322032+moredure@users.noreply.github.com>
Date: Tue, 16 Nov 2021 19:41:43 +0000
Subject: [PATCH 238/752] net: optimize ctxDone usage

Change-Id: I6db6fcf0ebe36da77af062114b5264405f15fee8
GitHub-Last-Rev: 80a97262bb220bb3958c94016eadf385cdf915e8
GitHub-Pull-Request: golang/go#49620
Reviewed-on: https://go-review.googlesource.com/c/go/+/364514
Run-TryBot: Ian Lance Taylor 
TryBot-Result: Go Bot 
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Damien Neil 
Trust: Damien Neil 
---
 src/net/fd_unix.go | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/net/fd_unix.go b/src/net/fd_unix.go
index 4ded833bbf..aaa7a1c185 100644
--- a/src/net/fd_unix.go
+++ b/src/net/fd_unix.go
@@ -95,7 +95,8 @@ func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa sysc
 	// The interrupter goroutine waits for the context to be done and
 	// interrupts the dial (by altering the fd's write deadline, which
 	// wakes up waitWrite).
-	if ctxDone := ctx.Done(); ctxDone != nil {
+	ctxDone := ctx.Done()
+	if ctxDone != nil {
 		// Wait for the interrupter goroutine to exit before returning
 		// from connect.
 		done := make(chan struct{})
@@ -139,7 +140,7 @@ func (fd *netFD) connect(ctx context.Context, la, ra syscall.Sockaddr) (rsa sysc
 		// details.
 		if err := fd.pfd.WaitWrite(); err != nil {
 			select {
-			case <-ctx.Done():
+			case <-ctxDone:
 				return nil, mapErr(ctx.Err())
 			default:
 			}

From 24898d6948e1651aab909a5abccbfde64dc359cd Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Thu, 18 Nov 2021 10:02:08 -0800
Subject: [PATCH 239/752] spec: various clarifications/fixes for method sets
 and interfaces

- fixed a typo in the method set section
- express in the syntax that ~T denotes an underlying type
- be more precise when talking about types vs type terms
- refer to "unions" rather than "union expressions"
- make it clear in the spec title that this is WIP

Change-Id: I9b2c4b1f77bc50dd574ed6893bedd40529c320fc
Reviewed-on: https://go-review.googlesource.com/c/go/+/365154
Trust: Robert Griesemer 
Reviewed-by: Ian Lance Taylor 
---
 doc/go_spec.html | 39 ++++++++++++++++++++-------------------
 1 file changed, 20 insertions(+), 19 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 63bc6a546e..7c53a1eb91 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,16 +1,14 @@
 
 
-
Draft Go 1.18 Specification - Work in Progress 

+
Earlier version

 
 

-
-For the pre-Go1.18 spec see
+For the pre-Go1.18 specification without generics support see
 The Go Programming Language Specification.
-
 

 
 
Introduction

@@ -852,7 +850,7 @@ Every type has a (possibly empty) method set associated with it:
 
 
  • 
 The method set of a pointer *T
-to a defined type *T
+to a defined type T
 (where T is neither a pointer nor an interface)
 is the set of all methods declared with receiver *T or T.
 
    • 
@@ -1271,7 +1269,8 @@ InterfaceElem  = MethodElem | TypeElem .
 MethodElem     = MethodName Signature .
 MethodName     = identifier .
 TypeElem       = TypeTerm { "|" TypeTerm } .
-TypeTerm       = [ "~" ] Type .
+TypeTerm       = Type | UnderlyingType .
+UnderlyingType = "~" Type .
 
    
 
 
    
@@ -1415,9 +1414,9 @@ type ReadCloser interface {

    -Finally, in their most general form, an interface element may be an arbitrary type -T, a type term of the form ~T, or a union of type terms -T1 | T2 | … Tn. +Finally, in their most general form, an interface element may also be an arbitrary type term +T, or a term of the form ~T specifying the underlying type T, +or a union of terms t1|t2|…|tn. Together with method specifications, these elements enable the precise definition of an interface's type set as follows:

    @@ -1434,7 +1433,7 @@ definition of an interface's type set as follows: whose method sets include that method. -
  • The type set of a non-interface type is the set consisting +
  • The type set of a non-interface type term is the set consisting of just that type.
    • @@ -1442,7 +1441,8 @@ definition of an interface's type set as follows: is the set of types whose underlying type is T. -
  • The type set of a union of terms T1 | T2 | … Tn +
  • The type set of a union of terms + t1|t2|…|tn is the union of the type sets of the terms.
    • @@ -1487,7 +1487,7 @@ interface {

    -Union expressions denote unions of type sets: +Union elements denote unions of type sets: 

    @@ -1500,7 +1500,7 @@ type Floats interface {

    -In a union expression, a term cannot be a type parameter, and the type sets of all +In a union, a term cannot be a type parameter, and the type sets of all non-interface terms must be pairwise disjoint (the pairwise intersection of the type sets must be empty). Given a type parameter P:

    @@ -1516,14 +1516,15 @@ interface {

    Implementation restriction: -A union expression with more than one term cannot contain interface types +A union with more than one term cannot contain interface types with non-empty method sets.

    -Interfaces that contain union or tilde terms (not just methods) may only be used -as type constraints, or as elements of other interfaces used as constraints. They -cannot be the types of values or variables, or components of other, non-interface types. +Interfaces that contain non-interface types, terms of the form ~T, +or unions may only be used as type constraints, or as elements of other interfaces used +as constraints. They cannot be the types of values or variables, or components of other, +non-interface types. 

    
From 2375b6edf376f97d0d8e3978fa3211788bc9b4dd Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor 
Date: Thu, 18 Nov 2021 12:14:24 -0800
Subject: [PATCH 240/752] cmd/go/internal/test: add dep from test pkg build to
 real pkg build

If we have to build a test package, and if the full set of packages
being tested imports the regular package somewhere, then make building
the test package depend on building the regular package.  That way if
the regular package fails to build we only report the error once.

Fixes #44624

Change-Id: Ic7d66d8fec9c4688d369153a4b21194989f8def3
Reviewed-on: https://go-review.googlesource.com/c/go/+/365215
Trust: Ian Lance Taylor 
Run-TryBot: Ian Lance Taylor 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
---
 src/cmd/go/internal/test/test.go              | 25 +++++++++++++++++--
 .../go/testdata/script/build_single_error.txt | 18 +++++++++++++
 2 files changed, 41 insertions(+), 2 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/build_single_error.txt

diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go
index 73abca8927..b7bbcb4513 100644
--- a/src/cmd/go/internal/test/test.go
+++ b/src/cmd/go/internal/test/test.go
@@ -890,6 +890,17 @@ func runTest(ctx context.Context, cmd *base.Command, args []string) {
 		}
 	}
 
+	// Collect all the packages imported by the packages being tested.
+	allImports := make(map[*load.Package]bool)
+	for _, p := range pkgs {
+		if p.Error != nil && p.Error.IsImportCycle {
+			continue
+		}
+		for _, p1 := range p.Internal.Imports {
+			allImports[p1] = true
+		}
+	}
+
 	// Prepare build + run + print actions for all packages being tested.
 	for _, p := range pkgs {
 		// sync/atomic import is inserted by the cover tool. See #18486
@@ -897,7 +908,7 @@ func runTest(ctx context.Context, cmd *base.Command, args []string) {
 			ensureImport(p, "sync/atomic")
 		}
 
-		buildTest, runTest, printTest, err := builderTest(&b, ctx, pkgOpts, p)
+		buildTest, runTest, printTest, err := builderTest(&b, ctx, pkgOpts, p, allImports[p])
 		if err != nil {
 			str := err.Error()
 			str = strings.TrimPrefix(str, "\n")
@@ -964,7 +975,7 @@ var windowsBadWords = []string{
 	"update",
 }
 
-func builderTest(b *work.Builder, ctx context.Context, pkgOpts load.PackageOpts, p *load.Package) (buildAction, runAction, printAction *work.Action, err error) {
+func builderTest(b *work.Builder, ctx context.Context, pkgOpts load.PackageOpts, p *load.Package, imported bool) (buildAction, runAction, printAction *work.Action, err error) {
 	if len(p.TestGoFiles)+len(p.XTestGoFiles) == 0 {
 		build := b.CompileAction(work.ModeBuild, work.ModeBuild, p)
 		run := &work.Action{Mode: "test run", Package: p, Deps: []*work.Action{build}}
@@ -992,6 +1003,16 @@ func builderTest(b *work.Builder, ctx context.Context, pkgOpts load.PackageOpts,
 		return nil, nil, nil, err
 	}
 
+	// If imported is true then this package is imported by some
+	// package being tested. Make building the test version of the
+	// package depend on building the non-test version, so that we
+	// only report build errors once. Issue #44624.
+	if imported && ptest != p {
+		buildTest := b.CompileAction(work.ModeBuild, work.ModeBuild, ptest)
+		buildP := b.CompileAction(work.ModeBuild, work.ModeBuild, p)
+		buildTest.Deps = append(buildTest.Deps, buildP)
+	}
+
 	// Use last element of import path, not package name.
 	// They differ when package name is "main".
 	// But if the import path is "command-line-arguments",
diff --git a/src/cmd/go/testdata/script/build_single_error.txt b/src/cmd/go/testdata/script/build_single_error.txt
new file mode 100644
index 0000000000..241cdb954b
--- /dev/null
+++ b/src/cmd/go/testdata/script/build_single_error.txt
@@ -0,0 +1,18 @@
+# go test ./... with a bad package should report the error once (#44624).
+! go test ./...
+stderr -count=1 undefined
+
+-- go.mod --
+module example.com
+
+go 1.18
+-- a/a.go --
+package a
+
+import "example.com/b"
+-- b/b.go --
+package b
+
+var X = Y
+-- b/b_test.go --
+package b

From e8cda0a6c925668972ada40602ada08468fa90dc Mon Sep 17 00:00:00 2001
From: Dan Scales 
Date: Thu, 18 Nov 2021 10:52:35 -0800
Subject: [PATCH 241/752] cmd/compile: don't run ComputeAddrTaken on imported
 generic functions

It causes a crash because of the unexpected XDOT operation. It's not
needed, since we will run ComputeAddrTaken() on function instantiations
after stenciling. And it's not always correct, since we may not be able
to distinguish between a array and a slice, if a type is dependent on a
type param.

However, we do need to call ComputeAddrTaken on instantiations created
during inlining, since that is after the main ComputeAddrTaken pass.

Fixes #49659

Change-Id: I0bb610cf11f14e4aa9068f6ca2a012337b069c79
Reviewed-on: https://go-review.googlesource.com/c/go/+/365214
Trust: Dan Scales 
Run-TryBot: Dan Scales 
TryBot-Result: Go Bot 
Reviewed-by: Keith Randall 
---
 src/cmd/compile/internal/ir/node.go        |  2 +-
 src/cmd/compile/internal/noder/stencil.go  |  7 ++++++
 src/cmd/compile/internal/typecheck/func.go |  7 +++++-
 test/typeparam/issue49659.dir/a.go         | 13 ++++++++++
 test/typeparam/issue49659.dir/b.go         | 15 ++++++++++++
 test/typeparam/issue49659.go               |  7 ++++++
 test/typeparam/issue49659b.go              | 28 ++++++++++++++++++++++
 7 files changed, 77 insertions(+), 2 deletions(-)
 create mode 100644 test/typeparam/issue49659.dir/a.go
 create mode 100644 test/typeparam/issue49659.dir/b.go
 create mode 100644 test/typeparam/issue49659.go
 create mode 100644 test/typeparam/issue49659b.go

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 8784f9ef99..4fdee5010b 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -584,7 +584,7 @@ func OuterValue(n Node) Node {
 	for {
 		switch nn := n; nn.Op() {
 		case OXDOT:
-			base.FatalfAt(n.Pos(), "OXDOT in walk: %v", n)
+			base.FatalfAt(n.Pos(), "OXDOT in OuterValue: %v", n)
 		case ODOT:
 			nn := nn.(*SelectorExpr)
 			n = nn.X
diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go
index 174006ab5e..004db54c3b 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -109,6 +109,13 @@ func (g *genInst) buildInstantiations(preinliningMainScan bool) {
 		// main round of inlining)
 		for _, fun := range g.newInsts {
 			inline.InlineCalls(fun.(*ir.Func))
+			// New instantiations created during inlining should run
+			// ComputeAddrTaken directly, since we are past the main pass
+			// that did ComputeAddrTaken(). We could instead do this
+			// incrementally during stenciling (for all instantiations,
+			// including main ones before inlining), since we have the
+			// type information.
+			typecheck.ComputeAddrtaken(fun.(*ir.Func).Body)
 		}
 	}
 	assert(l == len(g.newInsts))
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 7dec65c1d6..57b15b7a2b 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -160,7 +160,12 @@ func ImportedBody(fn *ir.Func) {
 	IncrementalAddrtaken = false
 	defer func() {
 		if DirtyAddrtaken {
-			ComputeAddrtaken(fn.Inl.Body) // compute addrtaken marks once types are available
+			// We do ComputeAddrTaken on function instantiations, but not
+			// generic functions (since we may not yet know if x in &x[i]
+			// is an array or a slice).
+			if !fn.Type().HasTParam() {
+				ComputeAddrtaken(fn.Inl.Body) // compute addrtaken marks once types are available
+			}
 			DirtyAddrtaken = false
 		}
 		IncrementalAddrtaken = true
diff --git a/test/typeparam/issue49659.dir/a.go b/test/typeparam/issue49659.dir/a.go
new file mode 100644
index 0000000000..718bc0c5fc
--- /dev/null
+++ b/test/typeparam/issue49659.dir/a.go
@@ -0,0 +1,13 @@
+// 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 A[T any] struct {
+	a int
+}
+
+func (a A[T]) F() {
+	_ = &a.a
+}
diff --git a/test/typeparam/issue49659.dir/b.go b/test/typeparam/issue49659.dir/b.go
new file mode 100644
index 0000000000..1f37153769
--- /dev/null
+++ b/test/typeparam/issue49659.dir/b.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.
+
+package b
+
+import "a"
+
+type B[T any] struct {
+	v a.A[T]
+}
+
+func (b B[T]) F() {
+	b.v.F()
+}
diff --git a/test/typeparam/issue49659.go b/test/typeparam/issue49659.go
new file mode 100644
index 0000000000..87b4ff46c1
--- /dev/null
+++ b/test/typeparam/issue49659.go
@@ -0,0 +1,7 @@
+// compiledir -G=3
+
+// 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/typeparam/issue49659b.go b/test/typeparam/issue49659b.go
new file mode 100644
index 0000000000..a9a14af77d
--- /dev/null
+++ b/test/typeparam/issue49659b.go
@@ -0,0 +1,28 @@
+// run -gcflags=-G=3
+
+// 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.
+
+// Testing that AddrTaken logic doesn't cause problems for function instantiations
+
+package main
+
+type A[T interface{ []int | [5]int }] struct {
+	val T
+}
+
+//go:noinline
+func (a A[T]) F() {
+	_ = &a.val[2]
+}
+
+func main() {
+	var x A[[]int]
+	x.val = make([]int, 4)
+	_ = &x.val[3]
+	x.F()
+	var y A[[5]int]
+	_ = &y.val[3]
+	y.F()
+}

From a94409660dbf05c1cdc2013aa2c7aa2489fe5c1c Mon Sep 17 00:00:00 2001
From: Roland Shoemaker 
Date: Thu, 18 Nov 2021 13:30:55 -0800
Subject: [PATCH 242/752] internal/fuzz: compute correct number of mutations

When reconstructing inputs, we miscalculated the number of mutations
that needed to be applied. If the count%chainedMutation == 0 we would
apply 0 mutations, when we should actually be applying chainedMutation
mutations, due to how count is incremented.

Fixes #49047

Change-Id: I76773bff0afd6dfd40deafc317be095da995ecc5
Reviewed-on: https://go-review.googlesource.com/c/go/+/365294
Trust: Roland Shoemaker 
Trust: Katie Hockman 
Run-TryBot: Roland Shoemaker 
Run-TryBot: Katie Hockman 
Reviewed-by: Bryan C. Mills 
Reviewed-by: Katie Hockman 
TryBot-Result: Go Bot 
---
 src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt | 2 --
 src/internal/fuzz/worker.go                             | 3 ++-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt b/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
index 5b1e26be24..3764dcb915 100644
--- a/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
+++ b/src/cmd/go/testdata/script/test_fuzz_mutator_repeat.txt
@@ -1,5 +1,3 @@
-skip  # https://golang.org/issue/49047
-
 # TODO(jayconrod): support shared memory on more platforms.
 [!darwin] [!linux] [!windows] skip
 
diff --git a/src/internal/fuzz/worker.go b/src/internal/fuzz/worker.go
index e7d824bea1..5be49d28f9 100644
--- a/src/internal/fuzz/worker.go
+++ b/src/internal/fuzz/worker.go
@@ -1111,7 +1111,8 @@ func (wc *workerClient) fuzz(ctx context.Context, entryIn CorpusEntry, args fuzz
 		wc.m.r.restore(mem.header().randState, mem.header().randInc)
 		if !args.Warmup {
 			// Only mutate the valuesOut if fuzzing actually occurred.
-			for i := int64(0); i < resp.Count%chainedMutations; i++ {
+			numMutations := ((resp.Count - 1) % chainedMutations) + 1
+			for i := int64(0); i < numMutations; i++ {
 				wc.m.mutate(valuesOut, cap(mem.valueRef()))
 			}
 		}

From 80cb59c0c15d2391f7b8d2571121f8213df70f7b Mon Sep 17 00:00:00 2001
From: Roland Shoemaker 
Date: Thu, 18 Nov 2021 11:40:48 -0800
Subject: [PATCH 243/752] internal/fuzz: fix chunk swap mutator

When swapping two chunks of bytes in a slice, don't pick chunks which
extend beyond the end of the slice. Also don't pick chunks which
intersect with each other.

Fixes #49047

Change-Id: I070eb1888d05ae849ec6122d01c40c45e602019f
Reviewed-on: https://go-review.googlesource.com/c/go/+/365175
Trust: Roland Shoemaker 
Trust: Bryan C. Mills 
Trust: Katie Hockman 
Run-TryBot: Roland Shoemaker 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
Reviewed-by: Katie Hockman 
---
 src/internal/fuzz/mutators_byteslice.go      | 14 +++++++++++++-
 src/internal/fuzz/mutators_byteslice_test.go | 19 +++++++++++++------
 2 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/src/internal/fuzz/mutators_byteslice.go b/src/internal/fuzz/mutators_byteslice.go
index 7c96b5920e..d9dab1df9f 100644
--- a/src/internal/fuzz/mutators_byteslice.go
+++ b/src/internal/fuzz/mutators_byteslice.go
@@ -284,7 +284,19 @@ func byteSliceSwapBytes(m *mutator, b []byte) []byte {
 	for dst == src {
 		dst = m.rand(len(b))
 	}
-	n := m.chooseLen(len(b) - src - 1)
+	// Choose the random length as len(b) - max(src, dst)
+	// so that we don't attempt to swap a chunk that extends
+	// beyond the end of the slice
+	max := dst
+	if src > max {
+		max = src
+	}
+	n := m.chooseLen(len(b) - max - 1)
+	// Check that neither chunk intersect, so that we don't end up
+	// duplicating parts of the input, rather than swapping them
+	if src > dst && dst+n >= src || dst > src && src+n >= dst {
+		return nil
+	}
 	// Use the end of the slice as scratch space to avoid doing an
 	// allocation. If the slice is too small abort and try something
 	// else.
diff --git a/src/internal/fuzz/mutators_byteslice_test.go b/src/internal/fuzz/mutators_byteslice_test.go
index 50a39a9a5b..7886967881 100644
--- a/src/internal/fuzz/mutators_byteslice_test.go
+++ b/src/internal/fuzz/mutators_byteslice_test.go
@@ -10,30 +10,31 @@ import (
 )
 
 type mockRand struct {
+	values  []int
 	counter int
 	b       bool
 }
 
 func (mr *mockRand) uint32() uint32 {
-	c := mr.counter
+	c := mr.values[mr.counter]
 	mr.counter++
 	return uint32(c)
 }
 
 func (mr *mockRand) intn(n int) int {
-	c := mr.counter
+	c := mr.values[mr.counter]
 	mr.counter++
 	return c % n
 }
 
 func (mr *mockRand) uint32n(n uint32) uint32 {
-	c := mr.counter
+	c := mr.values[mr.counter]
 	mr.counter++
 	return uint32(c) % n
 }
 
 func (mr *mockRand) exp2() int {
-	c := mr.counter
+	c := mr.values[mr.counter]
 	mr.counter++
 	return c
 }
@@ -56,6 +57,7 @@ func TestByteSliceMutators(t *testing.T) {
 	for _, tc := range []struct {
 		name     string
 		mutator  func(*mutator, []byte) []byte
+		randVals []int
 		input    []byte
 		expected []byte
 	}{
@@ -164,12 +166,17 @@ func TestByteSliceMutators(t *testing.T) {
 		{
 			name:     "byteSliceSwapBytes",
 			mutator:  byteSliceSwapBytes,
+			randVals: []int{0, 2, 0, 2},
 			input:    append(make([]byte, 0, 9), []byte{1, 2, 3, 4}...),
-			expected: []byte{2, 1, 3, 4},
+			expected: []byte{3, 2, 1, 4},
 		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
-			m := &mutator{r: &mockRand{}}
+			r := &mockRand{values: []int{0, 1, 2, 3, 4, 5}}
+			if tc.randVals != nil {
+				r.values = tc.randVals
+			}
+			m := &mutator{r: r}
 			b := tc.mutator(m, tc.input)
 			if !bytes.Equal(b, tc.expected) {
 				t.Errorf("got %x, want %x", b, tc.expected)

From ac0da79a676c852fee4939b79baf97224cd0b334 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" 
Date: Fri, 19 Nov 2021 12:51:25 -0500
Subject: [PATCH 244/752] cmd/go: temporarily skip
 TestScript/test_fuzz_minimize

This test is failing on the longtest builders.
Adding a skip temporarily until it can be diagnosed and fixed.

For #49685

Change-Id: I0ceaf009f5029d1ad6f667f7cfee1f1605737bf3
Reviewed-on: https://go-review.googlesource.com/c/go/+/365315
Trust: Bryan C. Mills 
Run-TryBot: Bryan C. Mills 
TryBot-Result: Go Bot 
Reviewed-by: Roland Shoemaker 
---
 src/cmd/go/testdata/script/test_fuzz_minimize.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/cmd/go/testdata/script/test_fuzz_minimize.txt b/src/cmd/go/testdata/script/test_fuzz_minimize.txt
index a6dc3f1953..b591e90d16 100644
--- a/src/cmd/go/testdata/script/test_fuzz_minimize.txt
+++ b/src/cmd/go/testdata/script/test_fuzz_minimize.txt
@@ -1,3 +1,5 @@
+skip # flaky: https://golang.org/issue/49685
+
 [!fuzz] skip
 [short] skip
 

From 0f75a9ecdf3f320a22e52d9493b879c4a6ddc536 Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Fri, 19 Nov 2021 13:56:24 -0500
Subject: [PATCH 245/752] [go] doc: add new bufio functionality

cl/345570
cl/345569

Updates: #47694
Change-Id: I170af16d5fc9f022d3d29ed0772cfc3d02b8bbcf
Reviewed-on: https://go-review.googlesource.com/c/go/+/365317
Trust: Jeremy Faller 
Run-TryBot: Jeremy Faller 
Reviewed-by: Joe Tsai 
---
 doc/go1.18.html | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 1ad651ffe8..3018ed1b4a 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -236,11 +236,17 @@ proposal.
 
    bufio
    
   
    
     
    
-      TODO: https://golang.org/cl/345569: add Writer.AvailableBuffer
+      The new Writer.AvailableBuffer
+      method returns an empty buffer with a possibly non-empty capacity for use
+      with append-like APIs. After appending, the buffer can be provided to a
+			succeeding Write call and possibly avoid any copying.
     
    
 
     
    
-      TODO: https://golang.org/cl/345570: make Reader.Reset and Writer.Reset work on the zero value
+      The methods Reader.Reset and
+      Writer.Reset
+      now use the default buffer size when called on objects with a
+      nil buffer.
     
    
   
    
 
    

From aec5c2eed6e4342270ca778a29b50487f7922f83 Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Fri, 19 Nov 2021 15:11:22 -0500
Subject: [PATCH 246/752] [go] doc: document speedups to Trim[|Left|Right]

CL: #332771

Updates: #47694
Change-Id: I8c729084b7a8745ec73f87ef3c469edbd596ddb4
Reviewed-on: https://go-review.googlesource.com/c/go/+/365318
Trust: Jeremy Faller 
Run-TryBot: Jeremy Faller 
Reviewed-by: Joe Tsai 
---
 doc/go1.18.html | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 3018ed1b4a..cc5c542746 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -254,7 +254,8 @@ proposal.
 
    bytes
    
   
    
     
    
-      TODO: https://golang.org/cl/332771: avoid allocations in Trim/TrimLeft/TrimRight
+      bytes.Trim and related
+      functions, have had their most common use cases optimized.
     
    
 
     
    
@@ -394,7 +395,8 @@ proposal.
     
    
 
     
    
-      TODO: https://golang.org/cl/332771: avoid allocations in Trim/TrimLeft/TrimRight
+      strings.Trim and related functions
+      functions, have had their most common use cases optimized.
     
    
 
     
    

From ba9f0f6665273ab5202d829ae4aa0c5fa2cebb32 Mon Sep 17 00:00:00 2001
From: Cherry Mui 
Date: Fri, 12 Nov 2021 13:10:30 -0500
Subject: [PATCH 247/752] doc/go1.18: mention register ABI on ARM64 and PPC64

For #47694.

Change-Id: Ide378f4a34587027c3d84fed2126c5b9bd8f7287
Reviewed-on: https://go-review.googlesource.com/c/go/+/363694
Trust: Cherry Mui 
Reviewed-by: Jeremy Faller 
---
 doc/go1.18.html | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index cc5c542746..61bb8dbbcb 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -71,12 +71,6 @@ proposal.
   The GOAMD64 environment variable defaults to v1.
 
    
 
-
    PPC64
    
-
-
    
-  TODO: https://golang.org/cl/353969: internal/buildcfg: enable register ABI for PPC64
-
    
-
 
    RISC-V
    
 
 
    
@@ -170,6 +164,25 @@ proposal.
 
 
    Compiler
    
 
+
    
+  Go 1.17 implemented a new way of passing
+  function arguments and results using registers instead of the stack
+  on 64-bit x86 architecture on selected operating systems.
+  Go 1.18 expands the supported platforms to include 64-bit ARM (GOARCH=arm64),
+  big- and little-endian 64-bit PowerPC (GOARCH=ppc64, ppc64le),
+  as well as 64-bit x86 architecture (GOARCH=amd64)
+  on all operating systems.
+  On 64-bit ARM and 64-bit PowerPC systems, benchmarking shows
+  performance improvements of 10% or more.
+
    
+
+
    
+  As mentioned in the Go 1.17 release notes,
+  this change does not affect the functionality of any safe Go code and
+  is designed to have no impact on most assembly code. See the
+  Go 1.17 release notes for more details.
+
    
+
 
    
   TODO: https://golang.org/cl/298611: cmd/compile: add -asan option
 
    

From 6027b2183d9a63a11f92d392fd2296e7b88402fc Mon Sep 17 00:00:00 2001
From: Roland Shoemaker 
Date: Tue, 16 Nov 2021 12:33:03 -0800
Subject: [PATCH 248/752] crypto/x509/internal/macos: use APIs available on ios

Use SecCertificateCopyData instead of SecItemExport, which is only
available on macOS.

Updates #49616

Change-Id: Ieda33894930d23c6dab6112ee18120f8a440083b
Reviewed-on: https://go-review.googlesource.com/c/go/+/364554
Trust: Roland Shoemaker 
Run-TryBot: Roland Shoemaker 
Reviewed-by: Bryan C. Mills 
Reviewed-by: Filippo Valsorda 
---
 src/crypto/x509/internal/macos/security.go | 27 +++++++++++-----------
 src/crypto/x509/internal/macos/security.s  |  4 ++--
 src/crypto/x509/root_darwin.go             |  7 ++----
 3 files changed, 17 insertions(+), 21 deletions(-)

diff --git a/src/crypto/x509/internal/macos/security.go b/src/crypto/x509/internal/macos/security.go
index 661844a805..ef64bda49f 100644
--- a/src/crypto/x509/internal/macos/security.go
+++ b/src/crypto/x509/internal/macos/security.go
@@ -92,20 +92,6 @@ func SecTrustSettingsCopyCertificates(domain SecTrustSettingsDomain) (certArray
 }
 func x509_SecTrustSettingsCopyCertificates_trampoline()
 
-const kSecFormatX509Cert int32 = 9
-
-//go:cgo_import_dynamic x509_SecItemExport SecItemExport "/System/Library/Frameworks/Security.framework/Versions/A/Security"
-
-func SecItemExport(cert CFRef) (data CFRef, err error) {
-	ret := syscall(abi.FuncPCABI0(x509_SecItemExport_trampoline), uintptr(cert), uintptr(kSecFormatX509Cert),
-		0 /* flags */, 0 /* keyParams */, uintptr(unsafe.Pointer(&data)), 0)
-	if ret != 0 {
-		return 0, OSStatus{"SecItemExport", int32(ret)}
-	}
-	return data, nil
-}
-func x509_SecItemExport_trampoline()
-
 const errSecItemNotFound = -25300
 
 //go:cgo_import_dynamic x509_SecTrustSettingsCopyTrustSettings SecTrustSettingsCopyTrustSettings "/System/Library/Frameworks/Security.framework/Versions/A/Security"
@@ -233,3 +219,16 @@ func SecTrustGetCertificateAtIndex(trustObj CFRef, i int) CFRef {
 	return CFRef(ret)
 }
 func x509_SecTrustGetCertificateAtIndex_trampoline()
+
+//go:cgo_import_dynamic x509_SecCertificateCopyData SecCertificateCopyData "/System/Library/Frameworks/Security.framework/Versions/A/Security"
+
+func SecCertificateCopyData(cert CFRef) ([]byte, error) {
+	ret := syscall(abi.FuncPCABI0(x509_SecCertificateCopyData_trampoline), uintptr(cert), 0, 0, 0, 0, 0)
+	if ret == 0 {
+		return nil, errors.New("x509: invalid certificate object")
+	}
+	b := CFDataToSlice(CFRef(ret))
+	CFRelease(CFRef(ret))
+	return b, nil
+}
+func x509_SecCertificateCopyData_trampoline()
diff --git a/src/crypto/x509/internal/macos/security.s b/src/crypto/x509/internal/macos/security.s
index cdef63f9f9..36f814f3cd 100644
--- a/src/crypto/x509/internal/macos/security.s
+++ b/src/crypto/x509/internal/macos/security.s
@@ -11,8 +11,6 @@
 
 TEXT ·x509_SecTrustSettingsCopyCertificates_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_SecTrustSettingsCopyCertificates(SB)
-TEXT ·x509_SecItemExport_trampoline(SB),NOSPLIT,$0-0
-	JMP	x509_SecItemExport(SB)
 TEXT ·x509_SecTrustSettingsCopyTrustSettings_trampoline(SB),NOSPLIT,$0-0
 	JMP	x509_SecTrustSettingsCopyTrustSettings(SB)
 TEXT ·x509_SecPolicyCopyProperties_trampoline(SB),NOSPLIT,$0-0
@@ -35,3 +33,5 @@ TEXT ·x509_SecTrustGetCertificateCount_trampoline(SB),NOSPLIT,$0-0
 	JMP x509_SecTrustGetCertificateCount(SB)
 TEXT ·x509_SecTrustGetCertificateAtIndex_trampoline(SB),NOSPLIT,$0-0
 	JMP x509_SecTrustGetCertificateAtIndex(SB)
+TEXT ·x509_SecCertificateCopyData_trampoline(SB),NOSPLIT,$0-0
+	JMP x509_SecCertificateCopyData(SB)
diff --git a/src/crypto/x509/root_darwin.go b/src/crypto/x509/root_darwin.go
index a7ff1e78bb..1ef9c0f71e 100644
--- a/src/crypto/x509/root_darwin.go
+++ b/src/crypto/x509/root_darwin.go
@@ -96,14 +96,11 @@ func (c *Certificate) systemVerify(opts *VerifyOptions) (chains [][]*Certificate
 
 // exportCertificate returns a *Certificate for a SecCertificateRef.
 func exportCertificate(cert macOS.CFRef) (*Certificate, error) {
-	data, err := macOS.SecItemExport(cert)
+	data, err := macOS.SecCertificateCopyData(cert)
 	if err != nil {
 		return nil, err
 	}
-	defer macOS.CFRelease(data)
-	der := macOS.CFDataToSlice(data)
-
-	return ParseCertificate(der)
+	return ParseCertificate(data)
 }
 
 func loadSystemRoots() (*CertPool, error) {

From 5e774b0f5c9e9d5a0dab94620d2e0030226148c2 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" 
Date: Thu, 18 Nov 2021 16:07:13 -0500
Subject: [PATCH 249/752] net: simplify deadline fluctuation tests

These tests were checking for fairly narrow timing windows, but were
running in parallel and heavily dependent on timer and goroutine
scheduling. This change eliminates unnecessary goroutines, runs the
tests sequentially (dramatically shortening the timeouts to reduce the
penalty of doing so), and uses timestamp comparison instead of
background timers to hopefully gain some robustness from monotonic
timestamps.

Many of the other tests from this package would benefit from similar
simplifications, which we can apply if and when we notice flaky
failures or want to improve the latency of running the test.

Fixes #36108

Change-Id: I17d8af7d2eefb1ec14fe0d9d891142a39599a562
Reviewed-on: https://go-review.googlesource.com/c/go/+/365334
Trust: Bryan C. Mills 
Run-TryBot: Bryan C. Mills 
Reviewed-by: Ian Lance Taylor 
TryBot-Result: Go Bot 
---
 src/net/mockserver_test.go |  71 ---------------
 src/net/timeout_test.go    | 178 +++++++++++++++++++++++++++++--------
 2 files changed, 141 insertions(+), 108 deletions(-)

diff --git a/src/net/mockserver_test.go b/src/net/mockserver_test.go
index 43b11a7218..70ecc69f66 100644
--- a/src/net/mockserver_test.go
+++ b/src/net/mockserver_test.go
@@ -11,7 +11,6 @@ import (
 	"fmt"
 	"os"
 	"sync"
-	"testing"
 	"time"
 )
 
@@ -287,54 +286,6 @@ func transceiver(c Conn, wb []byte, ch chan<- error) {
 	}
 }
 
-func timeoutReceiver(c Conn, d, min, max time.Duration, ch chan<- error) {
-	var err error
-	defer func() { ch <- err }()
-
-	t0 := time.Now()
-	if err = c.SetReadDeadline(time.Now().Add(d)); err != nil {
-		return
-	}
-	b := make([]byte, 256)
-	var n int
-	n, err = c.Read(b)
-	t1 := time.Now()
-	if n != 0 || err == nil || !err.(Error).Timeout() {
-		err = fmt.Errorf("Read did not return (0, timeout): (%d, %v)", n, err)
-		return
-	}
-	if dt := t1.Sub(t0); min > dt || dt > max && !testing.Short() {
-		err = fmt.Errorf("Read took %s; expected %s", dt, d)
-		return
-	}
-}
-
-func timeoutTransmitter(c Conn, d, min, max time.Duration, ch chan<- error) {
-	var err error
-	defer func() { ch <- err }()
-
-	t0 := time.Now()
-	if err = c.SetWriteDeadline(time.Now().Add(d)); err != nil {
-		return
-	}
-	var n int
-	for {
-		n, err = c.Write([]byte("TIMEOUT TRANSMITTER"))
-		if err != nil {
-			break
-		}
-	}
-	t1 := time.Now()
-	if err == nil || !err.(Error).Timeout() {
-		err = fmt.Errorf("Write did not return (any, timeout): (%d, %v)", n, err)
-		return
-	}
-	if dt := t1.Sub(t0); min > dt || dt > max && !testing.Short() {
-		err = fmt.Errorf("Write took %s; expected %s", dt, d)
-		return
-	}
-}
-
 func newLocalPacketListener(network string) (PacketConn, error) {
 	switch network {
 	case "udp":
@@ -504,25 +455,3 @@ func packetTransceiver(c PacketConn, wb []byte, dst Addr, ch chan<- error) {
 		ch <- fmt.Errorf("read %d; want %d", n, len(wb))
 	}
 }
-
-func timeoutPacketReceiver(c PacketConn, d, min, max time.Duration, ch chan<- error) {
-	var err error
-	defer func() { ch <- err }()
-
-	t0 := time.Now()
-	if err = c.SetReadDeadline(time.Now().Add(d)); err != nil {
-		return
-	}
-	b := make([]byte, 256)
-	var n int
-	n, _, err = c.ReadFrom(b)
-	t1 := time.Now()
-	if n != 0 || err == nil || !err.(Error).Timeout() {
-		err = fmt.Errorf("ReadFrom did not return (0, timeout): (%d, %v)", n, err)
-		return
-	}
-	if dt := t1.Sub(t0); min > dt || dt > max && !testing.Short() {
-		err = fmt.Errorf("ReadFrom took %s; expected %s", dt, d)
-		return
-	}
-}
diff --git a/src/net/timeout_test.go b/src/net/timeout_test.go
index 82069b347a..d345bf85ac 100644
--- a/src/net/timeout_test.go
+++ b/src/net/timeout_test.go
@@ -643,9 +643,24 @@ func TestWriteToTimeout(t *testing.T) {
 	}
 }
 
-func TestReadTimeoutFluctuation(t *testing.T) {
-	t.Parallel()
+const (
+	// minDynamicTimeout is the minimum timeout to attempt for
+	// tests that automatically increase timeouts until success.
+	//
+	// Lower values may allow tests to succeed more quickly if the value is close
+	// to the true minimum, but may require more iterations (and waste more time
+	// and CPU power on failed attempts) if the timeout is too low.
+	minDynamicTimeout = 1 * time.Millisecond
 
+	// maxDynamicTimeout is the maximum timeout to attempt for
+	// tests that automatically increase timeouts until succeess.
+	//
+	// This should be a strict upper bound on the latency of the timeout: if a
+	// test would increase the timeout beyond this value, the test fails.
+	maxDynamicTimeout = 1 * time.Second
+)
+
+func TestReadTimeoutFluctuation(t *testing.T) {
 	ln, err := newLocalListener("tcp")
 	if err != nil {
 		t.Fatal(err)
@@ -658,27 +673,52 @@ func TestReadTimeoutFluctuation(t *testing.T) {
 	}
 	defer c.Close()
 
-	max := time.NewTimer(time.Second)
-	defer max.Stop()
-	ch := make(chan error)
-	go timeoutReceiver(c, 100*time.Millisecond, 50*time.Millisecond, 250*time.Millisecond, ch)
+	d := minDynamicTimeout
+	b := make([]byte, 256)
+	for {
+		t.Logf("SetReadDeadline(+%v)", d)
+		t0 := time.Now()
+		deadline := t0.Add(d)
+		if err = c.SetReadDeadline(deadline); err != nil {
+			t.Fatalf("SetReadDeadline(%v): %v", deadline, err)
+		}
+		var n int
+		n, err = c.Read(b)
+		t1 := time.Now()
 
-	select {
-	case <-max.C:
-		t.Fatal("Read took over 1s; expected 0.1s")
-	case err := <-ch:
+		if n != 0 || err == nil || !err.(Error).Timeout() {
+			t.Errorf("Read did not return (0, timeout): (%d, %v)", n, err)
+		}
 		if perr := parseReadError(err); perr != nil {
 			t.Error(perr)
 		}
 		if !isDeadlineExceeded(err) {
-			t.Fatal(err)
+			t.Errorf("Read error is not DeadlineExceeded: %v", err)
 		}
+
+		actual := t1.Sub(t0)
+		if t1.Before(deadline) {
+			t.Errorf("Read took %s; expected at least %s", actual, d)
+		}
+		if t.Failed() {
+			return
+		}
+		if actual > d*11/10 {
+			if actual > maxDynamicTimeout || d > maxDynamicTimeout/2 {
+				t.Fatalf("Read took %s; expected %v", actual, d)
+			}
+			// Maybe this machine is too slow to reliably schedule goroutines within
+			// the requested duration. Increase the timeout and try again.
+			t.Logf("Read took %s (expected %s); trying with longer timeout", actual, d)
+			d *= 2
+			continue
+		}
+
+		break
 	}
 }
 
 func TestReadFromTimeoutFluctuation(t *testing.T) {
-	t.Parallel()
-
 	c1, err := newLocalPacketListener("udp")
 	if err != nil {
 		t.Fatal(err)
@@ -691,27 +731,52 @@ func TestReadFromTimeoutFluctuation(t *testing.T) {
 	}
 	defer c2.Close()
 
-	max := time.NewTimer(time.Second)
-	defer max.Stop()
-	ch := make(chan error)
-	go timeoutPacketReceiver(c2.(PacketConn), 100*time.Millisecond, 50*time.Millisecond, 250*time.Millisecond, ch)
+	d := minDynamicTimeout
+	b := make([]byte, 256)
+	for {
+		t.Logf("SetReadDeadline(+%v)", d)
+		t0 := time.Now()
+		deadline := t0.Add(d)
+		if err = c2.SetReadDeadline(deadline); err != nil {
+			t.Fatalf("SetReadDeadline(%v): %v", deadline, err)
+		}
+		var n int
+		n, _, err = c2.(PacketConn).ReadFrom(b)
+		t1 := time.Now()
 
-	select {
-	case <-max.C:
-		t.Fatal("ReadFrom took over 1s; expected 0.1s")
-	case err := <-ch:
+		if n != 0 || err == nil || !err.(Error).Timeout() {
+			t.Errorf("ReadFrom did not return (0, timeout): (%d, %v)", n, err)
+		}
 		if perr := parseReadError(err); perr != nil {
 			t.Error(perr)
 		}
 		if !isDeadlineExceeded(err) {
-			t.Fatal(err)
+			t.Errorf("ReadFrom error is not DeadlineExceeded: %v", err)
 		}
+
+		actual := t1.Sub(t0)
+		if t1.Before(deadline) {
+			t.Errorf("ReadFrom took %s; expected at least %s", actual, d)
+		}
+		if t.Failed() {
+			return
+		}
+		if actual > d*11/10 {
+			if actual > maxDynamicTimeout || d > maxDynamicTimeout/2 {
+				t.Fatalf("ReadFrom took %s; expected %s", actual, d)
+			}
+			// Maybe this machine is too slow to reliably schedule goroutines within
+			// the requested duration. Increase the timeout and try again.
+			t.Logf("ReadFrom took %s (expected %s); trying with longer timeout", actual, d)
+			d *= 2
+			continue
+		}
+
+		break
 	}
 }
 
 func TestWriteTimeoutFluctuation(t *testing.T) {
-	t.Parallel()
-
 	switch runtime.GOOS {
 	case "plan9":
 		t.Skipf("not supported on %s", runtime.GOOS)
@@ -729,25 +794,64 @@ func TestWriteTimeoutFluctuation(t *testing.T) {
 	}
 	defer c.Close()
 
-	d := time.Second
-	if iOS() {
-		d = 3 * time.Second // see golang.org/issue/10775
-	}
-	max := time.NewTimer(d)
-	defer max.Stop()
-	ch := make(chan error)
-	go timeoutTransmitter(c, 100*time.Millisecond, 50*time.Millisecond, 250*time.Millisecond, ch)
+	d := minDynamicTimeout
+	for {
+		t.Logf("SetWriteDeadline(+%v)", d)
+		t0 := time.Now()
+		deadline := t0.Add(d)
+		if err = c.SetWriteDeadline(deadline); err != nil {
+			t.Fatalf("SetWriteDeadline(%v): %v", deadline, err)
+		}
+		var n int64
+		for {
+			var dn int
+			dn, err = c.Write([]byte("TIMEOUT TRANSMITTER"))
+			n += int64(dn)
+			if err != nil {
+				break
+			}
+		}
+		t1 := time.Now()
 
-	select {
-	case <-max.C:
-		t.Fatalf("Write took over %v; expected 0.1s", d)
-	case err := <-ch:
+		if err == nil || !err.(Error).Timeout() {
+			t.Fatalf("Write did not return (any, timeout): (%d, %v)", n, err)
+		}
 		if perr := parseWriteError(err); perr != nil {
 			t.Error(perr)
 		}
 		if !isDeadlineExceeded(err) {
-			t.Fatal(err)
+			t.Errorf("Write error is not DeadlineExceeded: %v", err)
 		}
+
+		actual := t1.Sub(t0)
+		if t1.Before(deadline) {
+			t.Errorf("Write took %s; expected at least %s", actual, d)
+		}
+		if t.Failed() {
+			return
+		}
+		if actual > d*11/10 {
+			if n > 0 {
+				// SetWriteDeadline specifies a time “after which I/O operations fail
+				// instead of blocking”. However, the kernel's send buffer is not yet
+				// full, we may be able to write some arbitrary (but finite) number of
+				// bytes to it without blocking.
+				t.Logf("Wrote %d bytes into send buffer; retrying until buffer is full", n)
+				if d <= maxDynamicTimeout/2 {
+					d *= 2
+				}
+			} else if actual > maxDynamicTimeout || d > maxDynamicTimeout/2 {
+				t.Fatalf("Write took %s; expected %s", actual, d)
+			} else {
+				// Maybe this machine is too slow to reliably schedule goroutines within
+				// the requested duration. Increase the timeout and try again.
+				t.Logf("Write took %s (expected %s); trying with longer timeout", actual, d)
+				d *= 2
+			}
+			continue
+		}
+
+		break
 	}
 }
 

From b31dda8a2ad833ea5ec3c807119372b27cc0e782 Mon Sep 17 00:00:00 2001
From: Matthew Dempsky 
Date: Thu, 18 Nov 2021 13:43:04 -0800
Subject: [PATCH 250/752] cmd/compile: handle `any` as alias like `byte` and
 `rune`

`types.Types[types.TINTER]` is already used for `interface{}`, so we
can conveniently just extend the existing logic that substitutes
`byte` and `rune` with `uint8` and `int32` to also substitute `any`.

Fixes #49665.

Change-Id: I1ab1954699934150aab899b35037d5611c8ca47e
Reviewed-on: https://go-review.googlesource.com/c/go/+/365354
Trust: Matthew Dempsky 
Trust: Dan Scales 
Run-TryBot: Matthew Dempsky 
TryBot-Result: Go Bot 
Reviewed-by: Dan Scales 
---
 .../compile/internal/reflectdata/reflect.go    |  5 +++--
 src/cmd/compile/internal/types/fmt.go          |  4 ++--
 src/cmd/compile/internal/types/identity.go     |  2 ++
 src/cmd/compile/internal/types/type.go         | 13 ++++++++++---
 src/cmd/compile/internal/types/universe.go     | 14 +++++++++-----
 test/fixedbugs/issue49665.go                   | 18 ++++++++++++++++++
 test/fixedbugs/issue49665.out                  |  2 ++
 7 files changed, 46 insertions(+), 12 deletions(-)
 create mode 100644 test/fixedbugs/issue49665.go
 create mode 100644 test/fixedbugs/issue49665.out

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index f35baabbf9..142b289dae 100644
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -924,11 +924,12 @@ func hashMightPanic(t *types.Type) bool {
 	}
 }
 
-// formalType replaces byte and rune aliases with real types.
+// formalType replaces predeclared aliases with real types.
 // 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 {
+	switch t {
+	case types.AnyType, types.ByteType, types.RuneType:
 		return types.Types[t.Kind()]
 	}
 	return t
diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index b20d2e2908..3198a1f53c 100644
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -328,8 +328,8 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
 		return
 	}
 
-	if t == ByteType || t == RuneType {
-		// in %-T mode collapse rune and byte with their originals.
+	if t == AnyType || t == ByteType || t == RuneType {
+		// in %-T mode collapse predeclared aliases with their originals.
 		switch mode {
 		case fmtTypeIDName, fmtTypeID:
 			t = Types[t.Kind()]
diff --git a/src/cmd/compile/internal/types/identity.go b/src/cmd/compile/internal/types/identity.go
index dce7d29143..89343b8419 100644
--- a/src/cmd/compile/internal/types/identity.go
+++ b/src/cmd/compile/internal/types/identity.go
@@ -58,6 +58,8 @@ func identical(t1, t2 *Type, flags int, assumedEqual map[typePair]struct{}) bool
 			return (t1 == Types[TUINT8] || t1 == ByteType) && (t2 == Types[TUINT8] || t2 == ByteType)
 		case TINT32:
 			return (t1 == Types[TINT32] || t1 == RuneType) && (t2 == Types[TINT32] || t2 == RuneType)
+		case TINTER:
+			return (t1 == Types[TINTER] || t1 == AnyType) && (t2 == Types[TINTER] || t2 == AnyType)
 		default:
 			return false
 		}
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 6288df30d6..b1194fa196 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -106,12 +106,16 @@ const (
 // It also stores pointers to several special types:
 //   - Types[TANY] is the placeholder "any" type recognized by SubstArgTypes.
 //   - Types[TBLANK] represents the blank variable's type.
+//   - Types[TINTER] is the canonical "interface{}" type.
 //   - Types[TNIL] represents the predeclared "nil" value's type.
 //   - Types[TUNSAFEPTR] is package unsafe's Pointer type.
 var Types [NTYPE]*Type
 
 var (
-	// Predeclared alias types. Kept separate for better error messages.
+	// Predeclared alias types. These are actually created as distinct
+	// defined types for better error messages, but are then specially
+	// treated as identical to their respective underlying types.
+	AnyType  *Type
 	ByteType *Type
 	RuneType *Type
 
@@ -119,8 +123,6 @@ var (
 	ErrorType *Type
 	// Predeclared comparable interface type.
 	ComparableType *Type
-	// Predeclared any interface type.
-	AnyType *Type
 
 	// Types to represent untyped string and boolean constants.
 	UntypedString = newType(TSTRING)
@@ -1207,6 +1209,11 @@ func (t *Type) cmp(x *Type) Cmp {
 			if (t == Types[RuneType.kind] || t == RuneType) && (x == Types[RuneType.kind] || x == RuneType) {
 				return CMPeq
 			}
+
+		case TINTER:
+			if (t == Types[AnyType.kind] || t == AnyType) && (x == Types[AnyType.kind] || x == AnyType) {
+				return CMPeq
+			}
 		}
 	}
 
diff --git a/src/cmd/compile/internal/types/universe.go b/src/cmd/compile/internal/types/universe.go
index 13f62a3ab2..f845614e13 100644
--- a/src/cmd/compile/internal/types/universe.go
+++ b/src/cmd/compile/internal/types/universe.go
@@ -59,6 +59,7 @@ func InitTypes(defTypeName func(sym *Sym, typ *Type) Object) {
 
 	Types[TANY] = newType(TANY)
 	Types[TINTER] = NewInterface(LocalPkg, nil, false)
+	CheckSize(Types[TINTER])
 
 	defBasic := func(kind Kind, pkg *Pkg, name string) *Type {
 		typ := newType(kind)
@@ -108,11 +109,14 @@ func InitTypes(defTypeName func(sym *Sym, typ *Type) Object) {
 	ResumeCheckSize()
 
 	// any type (interface)
-	if base.Flag.G > 0 {
-		DeferCheckSize()
-		AnyType = defBasic(TFORW, BuiltinPkg, "any")
-		AnyType.SetUnderlying(NewInterface(NoPkg, []*Field{}, false))
-		ResumeCheckSize()
+	DeferCheckSize()
+	AnyType = defBasic(TFORW, BuiltinPkg, "any")
+	AnyType.SetUnderlying(NewInterface(NoPkg, []*Field{}, false))
+	ResumeCheckSize()
+
+	if base.Flag.G == 0 {
+		ComparableType.Sym().Def = nil
+		AnyType.Sym().Def = nil
 	}
 
 	Types[TUNSAFEPTR] = defBasic(TUNSAFEPTR, UnsafePkg, "Pointer")
diff --git a/test/fixedbugs/issue49665.go b/test/fixedbugs/issue49665.go
new file mode 100644
index 0000000000..c6c22a1b4e
--- /dev/null
+++ b/test/fixedbugs/issue49665.go
@@ -0,0 +1,18 @@
+// 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"
+
+var x any
+var y interface{}
+
+var _ = &x == &y // assert x and y have identical types
+
+func main() {
+	fmt.Printf("%T\n%T\n", &x, &y)
+}
diff --git a/test/fixedbugs/issue49665.out b/test/fixedbugs/issue49665.out
new file mode 100644
index 0000000000..bd06d717cf
--- /dev/null
+++ b/test/fixedbugs/issue49665.out
@@ -0,0 +1,2 @@
+*interface {}
+*interface {}

From 57aba325c8c34f3354abc24fca7bc9627949a1c8 Mon Sep 17 00:00:00 2001
From: Cherry Mui 
Date: Fri, 19 Nov 2021 16:36:03 -0500
Subject: [PATCH 251/752] cmd/link: exit early when -d is used on libc
 platforms

On platforms where we use libc for syscalls, we dynamically link
with libc and therefore dynamic linking cannot be disabled. Exit
early when -d is specified.

Update #42459.

Change-Id: I05abfe111df723b5ee512ceafef734e3804dd0a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/365658
Trust: Cherry Mui 
Run-TryBot: Cherry Mui 
TryBot-Result: Go Bot 
Reviewed-by: Than McIntosh 
---
 src/cmd/link/internal/ld/main.go   |  4 ++++
 src/cmd/link/internal/ld/target.go | 10 ++++++++++
 src/cmd/link/internal/ld/xcoff.go  |  4 ----
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index a1d86965e4..26f9db8ec4 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -172,6 +172,10 @@ func Main(arch *sys.Arch, theArch Arch) {
 		usage()
 	}
 
+	if *FlagD && ctxt.UsesLibc() {
+		Exitf("dynamic linking required on %s; -d flag cannot be used", buildcfg.GOOS)
+	}
+
 	checkStrictDups = *FlagStrictDups
 
 	if !buildcfg.Experiment.RegabiWrappers {
diff --git a/src/cmd/link/internal/ld/target.go b/src/cmd/link/internal/ld/target.go
index f68de8fff1..58d45d1504 100644
--- a/src/cmd/link/internal/ld/target.go
+++ b/src/cmd/link/internal/ld/target.go
@@ -185,3 +185,13 @@ func (t *Target) mustSetHeadType() {
 func (t *Target) IsBigEndian() bool {
 	return t.Arch.ByteOrder == binary.BigEndian
 }
+
+func (t *Target) UsesLibc() bool {
+	t.mustSetHeadType()
+	switch t.HeadType {
+	case objabi.Haix, objabi.Hdarwin, objabi.Hopenbsd, objabi.Hsolaris, objabi.Hwindows:
+		// platforms where we use libc for syscalls.
+		return true
+	}
+	return false
+}
diff --git a/src/cmd/link/internal/ld/xcoff.go b/src/cmd/link/internal/ld/xcoff.go
index aba6138c83..aaddf19d16 100644
--- a/src/cmd/link/internal/ld/xcoff.go
+++ b/src/cmd/link/internal/ld/xcoff.go
@@ -1290,10 +1290,6 @@ func Xcoffadddynrel(target *Target, ldr *loader.Loader, syms *ArchSyms, s loader
 }
 
 func (ctxt *Link) doxcoff() {
-	if *FlagD {
-		// All XCOFF files have dynamic symbols because of the syscalls.
-		Exitf("-d is not available on AIX")
-	}
 	ldr := ctxt.loader
 
 	// TOC

From d2f4c935f2e247dd9949094c8a4f3ab8df2ba3a0 Mon Sep 17 00:00:00 2001
From: Alan Donovan 
Date: Wed, 17 Nov 2021 12:54:22 -0500
Subject: [PATCH 252/752] runtime/cgo: add example of Handle with void*
 parameter

Fixes #49633

Change-Id: I12ca350f7dd6bfc8753a4a169f29b89ef219b035
Reviewed-on: https://go-review.googlesource.com/c/go/+/364774
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Bryan C. Mills 
Run-TryBot: Ian Lance Taylor 
TryBot-Result: Go Bot 
Trust: Bryan C. Mills 
---
 misc/cgo/test/cgo_test.go |  1 +
 misc/cgo/test/test.go     |  5 +++++
 misc/cgo/test/testx.go    | 25 +++++++++++++++++++++++++
 src/runtime/cgo/handle.go | 35 +++++++++++++++++++++++++++++++++++
 4 files changed, 66 insertions(+)

diff --git a/misc/cgo/test/cgo_test.go b/misc/cgo/test/cgo_test.go
index fe99e251e9..774277e10d 100644
--- a/misc/cgo/test/cgo_test.go
+++ b/misc/cgo/test/cgo_test.go
@@ -61,6 +61,7 @@ func Test32579(t *testing.T)                 { test32579(t) }
 func Test31891(t *testing.T)                 { test31891(t) }
 func Test42018(t *testing.T)                 { test42018(t) }
 func Test45451(t *testing.T)                 { test45451(t) }
+func Test49633(t *testing.T)                 { test49633(t) }
 func TestAlign(t *testing.T)                 { testAlign(t) }
 func TestAtol(t *testing.T)                  { testAtol(t) }
 func TestBlocking(t *testing.T)              { testBlocking(t) }
diff --git a/misc/cgo/test/test.go b/misc/cgo/test/test.go
index 3b8f548b13..dd81f770a2 100644
--- a/misc/cgo/test/test.go
+++ b/misc/cgo/test/test.go
@@ -915,6 +915,11 @@ void issue40494(enum Enum40494 e, union Union40494* up) {}
 
 // Issue 45451, bad handling of go:notinheap types.
 typedef struct issue45451Undefined issue45451;
+
+// Issue 49633, example of cgo.Handle with void*.
+extern void GoFunc49633(void*);
+void cfunc49633(void *context) { GoFunc49633(context); }
+
 */
 import "C"
 
diff --git a/misc/cgo/test/testx.go b/misc/cgo/test/testx.go
index 823c3e13d2..a61b47c41d 100644
--- a/misc/cgo/test/testx.go
+++ b/misc/cgo/test/testx.go
@@ -113,6 +113,8 @@ typedef struct {
 	int i;
 } Issue38408, *PIssue38408;
 
+extern void GoFunc49633(void *context);
+extern void cfunc49633(void*); // definition is in test.go
 */
 import "C"
 
@@ -554,3 +556,26 @@ func GoFunc37033(handle C.uintptr_t) {
 // A typedef pointer can be used as the element type.
 // No runtime test; just make sure it compiles.
 var _ C.PIssue38408 = &C.Issue38408{i: 1}
+
+// issue 49633, example use of cgo.Handle with void*
+
+type data49633 struct {
+	msg string
+}
+
+//export GoFunc49633
+func GoFunc49633(context unsafe.Pointer) {
+	h := *(*cgo.Handle)(context)
+	v := h.Value().(*data49633)
+	v.msg = "hello"
+}
+
+func test49633(t *testing.T) {
+	v := &data49633{}
+	h := cgo.NewHandle(v)
+	defer h.Delete()
+	C.cfunc49633(unsafe.Pointer(&h))
+	if v.msg != "hello" {
+		t.Errorf("msg = %q, want 'hello'", v.msg)
+	}
+}
diff --git a/src/runtime/cgo/handle.go b/src/runtime/cgo/handle.go
index 720acca802..726f0a396d 100644
--- a/src/runtime/cgo/handle.go
+++ b/src/runtime/cgo/handle.go
@@ -59,6 +59,41 @@ import (
 //	void myprint(uintptr_t handle) {
 //	    MyGoPrint(handle);
 //	}
+//
+// Some C functions accept a void* argument that points to an arbitrary
+// data value supplied by the caller. It is not safe to coerce a cgo.Handle
+// (an integer) to a Go unsafe.Pointer, but instead we can pass the address
+// of the cgo.Handle to the void* parameter, as in this variant of the
+// previous example:
+//
+//	package main
+//
+//	/*
+//	extern void MyGoPrint(void *context);
+//	static inline void myprint(void *context) {
+//	    MyGoPrint(context);
+//	}
+//	*/
+//	import "C"
+//	import (
+//		"runtime/cgo"
+//		"unsafe"
+//	)
+//
+//	//export MyGoPrint
+//	func MyGoPrint(context unsafe.Pointer) {
+//		h := *(*cgo.Handle)(context)
+//		val := h.Value().(string)
+//		println(val)
+//		h.Delete()
+//	}
+//
+//	func main() {
+//		val := "hello Go"
+//		h := cgo.NewHandle(val)
+//		C.myprint(unsafe.Pointer(&h))
+//		// Output: hello Go
+//	}
 type Handle uintptr
 
 // NewHandle returns a handle for a given value.

From be18cd51dec6ac460949e96231dd05becc2cbcf7 Mon Sep 17 00:00:00 2001
From: Dan Scales 
Date: Fri, 19 Nov 2021 12:13:04 -0800
Subject: [PATCH 253/752] cmd/compile: ensure generic function is loaded when
 it needs to be re-exported

In the case where we need to re-export a generic function/method from
another package in the export data of the current package, make sure it
is loaded before trying to write it out.

Fixed #49667

Change-Id: I177754bb762689f34cf5c8ad246d43f1cdbbf195
Reviewed-on: https://go-review.googlesource.com/c/go/+/365837
Trust: Dan Scales 
Run-TryBot: Dan Scales 
TryBot-Result: Go Bot 
Reviewed-by: Matthew Dempsky 
---
 src/cmd/compile/internal/typecheck/iexport.go |  6 ++++++
 test/typeparam/issue49667.dir/a.go            | 12 ++++++++++++
 test/typeparam/issue49667.dir/b.go            | 11 +++++++++++
 test/typeparam/issue49667.dir/main.go         | 11 +++++++++++
 test/typeparam/issue49667.go                  |  7 +++++++
 5 files changed, 47 insertions(+)
 create mode 100644 test/typeparam/issue49667.dir/a.go
 create mode 100644 test/typeparam/issue49667.dir/b.go
 create mode 100644 test/typeparam/issue49667.dir/main.go
 create mode 100644 test/typeparam/issue49667.go

diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index bf12ba803b..9bd1f626fe 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -1418,6 +1418,12 @@ func (w *exportWriter) funcExt(n *ir.Name) {
 		w.uint64(1 + uint64(n.Func.Inl.Cost))
 		w.bool(n.Func.Inl.CanDelayResults)
 		if n.Func.ExportInline() || n.Type().HasTParam() {
+			if n.Type().HasTParam() {
+				// If this generic function/method is from another
+				// package, but we didn't use for instantiation in
+				// this package, we may not yet have imported it.
+				ImportedBody(n.Func)
+			}
 			w.p.doInline(n)
 		}
 
diff --git a/test/typeparam/issue49667.dir/a.go b/test/typeparam/issue49667.dir/a.go
new file mode 100644
index 0000000000..3b1889f699
--- /dev/null
+++ b/test/typeparam/issue49667.dir/a.go
@@ -0,0 +1,12 @@
+// 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 A[T any] struct {
+}
+
+func (a A[T]) F() {
+	_ = a
+}
diff --git a/test/typeparam/issue49667.dir/b.go b/test/typeparam/issue49667.dir/b.go
new file mode 100644
index 0000000000..e7f781e4af
--- /dev/null
+++ b/test/typeparam/issue49667.dir/b.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.
+
+package b
+
+import "a"
+
+type B[T any] struct {
+	_ a.A[T]
+}
diff --git a/test/typeparam/issue49667.dir/main.go b/test/typeparam/issue49667.dir/main.go
new file mode 100644
index 0000000000..fccefe023f
--- /dev/null
+++ b/test/typeparam/issue49667.dir/main.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.
+
+package main
+
+import "b"
+
+func main() {
+	var _ b.B[int]
+}
diff --git a/test/typeparam/issue49667.go b/test/typeparam/issue49667.go
new file mode 100644
index 0000000000..76930e5e4f
--- /dev/null
+++ b/test/typeparam/issue49667.go
@@ -0,0 +1,7 @@
+// rundir -G=3
+
+// 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

From 91abe4be0e8f3329bd891838fc047d83a5762c61 Mon Sep 17 00:00:00 2001
From: Dan Scales 
Date: Fri, 19 Nov 2021 17:52:41 -0800
Subject: [PATCH 254/752] test: fix -G=0 mode for longtest builder

For -G=3 for test using 'any'.

Change-Id: Ia37ee944a38be4f4330e62ad187f10f2d42e41bd
Reviewed-on: https://go-review.googlesource.com/c/go/+/365839
Trust: Dan Scales 
Run-TryBot: Dan Scales 
Reviewed-by: Cuong Manh Le 
---
 test/fixedbugs/issue49665.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/fixedbugs/issue49665.go b/test/fixedbugs/issue49665.go
index c6c22a1b4e..4a6593c454 100644
--- a/test/fixedbugs/issue49665.go
+++ b/test/fixedbugs/issue49665.go
@@ -1,4 +1,4 @@
-// run
+// run -gcflags=-G=3
 
 // Copyright 2021 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style

From 0c3b4a358ad6813d6aad111d0d0c45dce84cbeec Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Thu, 18 Nov 2021 12:16:39 -0800
Subject: [PATCH 255/752] spec: add type parameter lists

Change-Id: I29e9188a0fa1326c2755a9b86aeb47feaa8019be
Reviewed-on: https://go-review.googlesource.com/c/go/+/365274
Trust: Robert Griesemer 
Reviewed-by: Ian Lance Taylor 
---
 doc/go_spec.html | 197 ++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 176 insertions(+), 21 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 7c53a1eb91..0ce6a3ca18 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 
 
@@ -849,8 +849,7 @@ Every type has a (possibly empty) method set associated with it:
 
 
 
  • 
-The method set of a pointer *T
-to a defined type T
+The method set of a pointer to a defined type T
 (where T is neither a pointer nor an interface)
 is the set of all methods declared with receiver *T or T.
 
    • 
@@ -2246,12 +2245,12 @@ type (
 
 
    
 A type definition creates a new, distinct type with the same
-underlying type and operations as the given type,
-and binds an identifier to it.
+underlying type and operations as the given type
+and binds an identifier, the type name, to it.
 
    
 
 
    -TypeDef = identifier Type .
+TypeDef = identifier [ TypeParameters ] Type .
 
    
 
 
    
@@ -2328,6 +2327,130 @@ func (tz TimeZone) String() string {
 }
    +

    +If the type definition specifies type parameters, +the type name denotes a parameterized type. +Parameterized types must be instantiated when they +are used. +

    + +
    +type List[T any] struct {
+	next  *List[T]
+	value T
+}
+
+type Tree[T constraints.Ordered] struct {
+	left, right *Tree[T]
+	value       T
+}
+
    + +

    +The given type cannot be a type parameter in a type definition. +

    + +
    +type T[P any] P    // illegal: P is a type parameter
+
+func f[T any]() {
+	type L T   // illegal: T is a type parameter declared by the enclosing function
+}
+
    + +

    +A parameterized type may also have methods associated with it. In this case, +the method receivers must declare the same number of type parameters as +present in the parameterized type definition. +

    + +
    +// The method Len returns the number of elements in the linked list l.
+func (l *List[T]) Len() int  { … }
+
    + +

    Type parameter lists

    + +

    +A type parameter list declares the type parameters +in a type-parameterized function or type declaration. +The type parameter list looks like an ordinary function parameter list +except that the type parameter names must all be present and the list is enclosed +in square brackets rather than parentheses. +

    + +
    +TypeParameters  = "[" TypeParamList [ "," ] "]" .
+TypeParamList   = TypeParamDecl { "," TypeParamDecl } .
+TypeParamDecl   = IdentifierList TypeConstraint .
+
    + +

    +Each identifier declares a type parameter. +All non-blank names in the list must be unique. +Each type parameter is a new and different named type. +

    + +
    +[P any]
+[S interface{ ~[]byte|string }]
+[S ~[]E, E any]
+[P Constraint[int]]
+[_ any]
+
    + +

    +Just as each ordinary function parameter has a parameter type, each type parameter +has a corresponding (meta-)type which is called its +type constraint. +

    + +

    +A parsing ambiguity arises when the type parameter list for a parameterized type +declares a single type parameter with a type constraint of the form *C +or (C): +

    + +
    +type T[P *C] …
+type T[P (C)] …
+
    + +

    +In these rare cases, the type parameter declaration is indistinguishable from +the expressions P*C or P(C) and the type declaration +is parsed as an array type declaration. +To resolve the ambiguity, embed the constraint in an interface: +

    + +
    +type T[P interface{*C}] …
+
    + +

    Type constraints

    + +

    +A type constraint is an interface that determines the +set of permissible type arguments for the respective type parameter and controls the +operations supported by values of that type parameter. +

    + +
    +TypeConstraint = TypeElem .
+
    + +

    +If the constraint is an interface literal containing exactly one embedded type element +interface{E}, in a type parameter list the enclosing interface{ … } +may be omitted for convenience: +

    + +
    +[T *P]                             // = [T interface{*P}]
+[T ~int]                           // = [T interface{~int}]
+[T int|string]                     // = [T interface{int|string}]
+type Constraint ~int               // illegal: ~int is not inside a type parameter list
+

    Variable declarations

    @@ -2437,13 +2560,19 @@ they can be used to declare local temporary variables.

    Function declarations

    + +

    A function declaration binds an identifier, the function name, to a function. 

    -FunctionDecl = "func" FunctionName Signature [ FunctionBody ] .
+FunctionDecl = "func" FunctionName [ TypeParameters ] Signature [ FunctionBody ] .
 FunctionName = identifier .
 FunctionBody = Block .
    @@ -2466,18 +2595,28 @@ func IndexRune(s string, r rune) int {

    -A function declaration may omit the body. Such a declaration provides the -signature for a function implemented outside Go, such as an assembly routine. +If the function declaration specifies type parameters, +the function name denotes a type-parameterized function. +Type-parameterized functions must be instantiated when they +are used. 

    -func min(x int, y int) int {
+func min[T constraints.Ordered](x, y T) T {
 	if x < y {
 		return x
 	}
 	return y
 }
+
    +

    +A function declaration without type parameters may omit the body. +Such a declaration provides the signature for a function implemented outside Go, +such as an assembly routine. +

    + +
     func flushICache(begin, end uintptr)  // implemented externally
    @@ -2498,9 +2637,10 @@ Receiver = Parameters . The receiver is specified via an extra parameter section preceding the method name. That parameter section must declare a single non-variadic parameter, the receiver. Its type must be a defined type T or a -pointer to a defined type T. T is called the receiver -base type. A receiver base type cannot be a pointer or interface type and -it must be defined in the same package as the method. +pointer to a defined type T, possibly followed by a list of type parameter +names [P1, P2, …] enclosed in square brackets. +T is called the receiver base type. A receiver base type cannot be +a pointer or interface type and it must be defined in the same package as the method. The method is said to be bound to its receiver base type and the method name is visible only within selectors for type T or *T. @@ -2542,19 +2682,33 @@ to the base type Point.

    -The type of a method is the type of a function with the receiver as first -argument. For instance, the method Scale has type +If the receiver base type is a parameterized type, the +receiver specification must declare corresponding type parameters for the method +to use. This makes the receiver type parameters available to the method. +

    + +

    +Syntactically, this type parameter declaration looks like an +instantiation of the receiver base type, except that +the type arguments are the type parameters being declared, one for each type parameter +of the receiver base type. +The type parameter names do not need to match their corresponding parameter names in the +receiver base type definition, and all non-blank parameter names must be unique in the +receiver parameter section and the method signature. +The receiver type parameter constraints are implied by the receiver base type definition: +corresponding type parameters have corresponding constraints. 

    -func(p *Point, factor float64)
+type Pair[A, B any] struct {
+	a A
+	b B
+}
+
+func (p Pair[A, B]) Swap() Pair[A, B]  { return Pair[A, B]{p.b, p.a} }
+func (p Pair[First, _]) First() First  { return p.a }
    -

    -However, a function declared this way is not a method. -

    - -

    Expressions

    @@ -2823,6 +2977,7 @@ noteFrequency := map[string]float32{

    A function literal represents an anonymous function. +Function literals cannot declare type parameters. 

    
From a287c4aa38c9c71f823a0c366871f7f4452a602c Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Thu, 18 Nov 2021 15:33:19 -0800
Subject: [PATCH 256/752] spec: add type parameter types

- add section on type parameters
- added two sections on the scope of type parameters
- expanded general section on types accordingly
- introduced the notion of a named type which will
  help in simplifying various rules (subsequent CLs)

Change-Id: I49c1ed7d6d4f951d751f0a3ca5dfb637e49829f2
Reviewed-on: https://go-review.googlesource.com/c/go/+/365414
Trust: Robert Griesemer 
Reviewed-by: Ian Lance Taylor 
---
 doc/go_spec.html | 62 +++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 53 insertions(+), 9 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 0ce6a3ca18..2120985b3b 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -787,32 +787,46 @@ If a variable has not yet been assigned a value, its value is the
 
 
    
 A type determines a set of values together with operations and methods specific
-to those values. A type may be denoted by a type name, if it has one,
-or specified using a type literal, which composes a type from existing types.
+to those values. A type may be denoted by a type name, if it has one, which must be
+followed by type arguments if the type is parameterized.
+A type may also be specified using a type literal, which composes a type
+from existing types.
 
    
 
 
    -Type      = TypeName | TypeLit | "(" Type ")" .
+Type      = TypeName [ TypeArgs ] | TypeLit | "(" Type ")" .
 TypeName  = identifier | QualifiedIdent .
+TypeArgs  = "[" TypeList [ "," ] "]" .
+TypeList  = Type { "," Type } .
 TypeLit   = ArrayType | StructType | PointerType | FunctionType | InterfaceType |
 	    SliceType | MapType | ChannelType .
 
    
 
 
    
 The language predeclares certain type names.
-Others are introduced with type declarations.
+Others are introduced with type declarations
+or type parameter lists.
 Composite types—array, struct, pointer, function,
 interface, slice, map, and channel types—may be constructed using
 type literals.
 
    
 
+
    
+Predeclared types, defined types, and type parameters are called named types.
+An alias denotes a named type if the type given in the alias declaration is a named type.
+
    
+
+
    Underlying types
    
+
 
    
 Each type T has an underlying type: If T
 is one of the predeclared boolean, numeric, or string types, or a type literal,
-the corresponding underlying
-type is T itself. Otherwise, T's underlying type
-is the underlying type of the type to which T refers in its
-type declaration.
+the corresponding underlying type is T itself.
+Otherwise, T's underlying type is the underlying type of the
+type to which T refers in its type
+declaration. Accordingly, the underlying type of a type parameter is the
+underlying type of its type constraint, which
+is always an interface.
 
    
 
 
    @@ -827,12 +841,15 @@ type (
 	B3 []B1
 	B4 B3
 )
+
+func f[P any](x P) { … }
 
    
 
 
    
 The underlying type of string, A1, A2, B1,
 and B2 is string.
 The underlying type of []B1, B3, and B4 is []B1.
+The underlying type of P is interface{}.
 
    
 
 
    Method sets
    
@@ -1706,6 +1723,25 @@ and a second goroutine receives them, the values are
 received in the order sent.
 
    
 
+
    Type parameters
    
+
+
    
+A type parameter is an (unqualified) type name declared in the
+type parameter list of a
+function declaration or
+type definition; or in the receiver specification
+of a method declaration that is associated
+with a parameterized type.
+A type parameter acts as a place holder for an (as of yet) unknown type in the declaration;
+the type parameter is replaced with a type argument upon
+instantiation of the parameterized function or type.
+
    
+
+
    
+The properties of a type parameter are determined by its
+type constraint.
+
    
+
 
    Properties of types and values
    
 
 
    Type identity
    
@@ -1983,6 +2019,15 @@ Go is lexically scoped using blocks:
 	
  • The scope of an identifier denoting a method receiver, function parameter,
 	    or result variable is the function body.
    • 
 
+	
  • The scope of an identifier denoting a type parameter of a type-parameterized function
+	    or declared by a method receiver is the function body and all parameter lists of the
+	    function.
+	
    • 
+
+	
  • The scope of an identifier denoting a type parameter of a parameterized type
+	    begins after the name of the parameterized type and ends at the end
+	    of the TypeSpec.
    • 
+
 	
  • The scope of a constant or variable identifier declared
 	    inside a function begins at the end of the ConstSpec or VarSpec
 	    (ShortVarDecl for short variable declarations)
@@ -5384,7 +5429,6 @@ TypeSwitchStmt  = "switch" [ SimpleStmt ";" ] TypeSwitchGuard "{" { TypeCaseClau
 TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" .
 TypeCaseClause  = TypeSwitchCase ":" StatementList .
 TypeSwitchCase  = "case" TypeList | "default" .
-TypeList        = Type { "," Type } .

    • From e30ebaab0bd5d95178f77cf40998ab14a0341d17 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 18 Nov 2021 17:52:24 -0800 Subject: [PATCH 257/752] spec: add section on the structure of interfaces This change introduces the notion of a structural interface and its corresponding structural type. Change-Id: Ib5442dfd04cb5950b4467428cae51849f8922272 Reviewed-on: https://go-review.googlesource.com/c/go/+/365474 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 66 +++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 62 insertions(+), 4 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index 2120985b3b..bf589f0ae6 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1269,7 +1269,6 @@ func(int, int, float64) (float64, *[]int) func(n int) func(p *T) -

    Interface types

    @@ -1655,8 +1654,8 @@ ChannelType = ( "chan" | "chan" "<-" | "<-" "chan" ) ElementType .

    The optional <- operator specifies the channel direction, -send or receive. If no direction is given, the channel is -bidirectional. +send or receive. If a direction is given, the channel is directional, +otherwise it is bidirectional. A channel may be constrained only to send or only to receive by assignment or explicit conversion. @@ -1836,7 +1835,6 @@ created by distinct type definitions; are different because B0 is different from []string.

    -

    Assignability

    @@ -1928,6 +1926,66 @@ x T x is not representable by a value of T because 1e1000 float64 1e1000 overflows to IEEE +Inf after rounding +

    Structural interfaces

    + +

    +An interface T is called structural if one of the following +conditions is satisfied: +

    + +
      +
    1. +There is a single type U which is the underlying type +of all types in the type set of T; or +
      2. +
    2. +the type set of T contains only channel types +with identical element type E, and all directional channels have the same +direction. +
      3. +
    + +

    +A structural interface has a structural type which is, depending on the +condition that is satisfied, either: +

    + +
      +
    1. +the type U; or +
      2. +
    2. +the type chan E if T contains only bidirectional +channels, or the type chan<- E or <-chan E +depending on the direction of the directional channels present. +
      3. +
    + +

    +Examples of structural interfaces with their structural types: +

    + +
    +type Celsius float32
+type Kelvin  float32
+
+interface{ int }                          // int
+interface{ Celsius|Kelvin }               // float32
+interface{ ~chan int }                    // chan int
+interface{ ~chan int|~chan<- int }        // chan<- int
+interface{ ~[]*data; String() string }    // []*data
+
    + +

    +Examples of non-structural interfaces: +

    + +
    +interface{}                               // no single underlying type
+interface{ Celsius|float64 }              // no single underlying type
+interface{ chan int | chan<- string }     // channels have different element types
+interface{ <-chan int | chan<- int }      // directional channels have different directions
+

    Blocks

    From ffb6c798281f1a3ec54421a11573cec7d517d117 Mon Sep 17 00:00:00 2001 From: zhouguangyuan Date: Sun, 21 Nov 2021 21:06:27 +0800 Subject: [PATCH 258/752] go/types,types2: use allInteger to check type for shifted operand Fixes: #49705 Change-Id: I35a1c5f29b57f3facc5e89d33a8dec88e0ff4afa Reviewed-on: https://go-review.googlesource.com/c/go/+/365895 Run-TryBot: Robert Griesemer TryBot-Result: Go Bot Reviewed-by: Robert Griesemer Trust: Emmanuel Odeke --- src/cmd/compile/internal/types2/check_test.go | 1 + src/cmd/compile/internal/types2/expr.go | 2 +- .../internal/types2/testdata/fixedbugs/issue49705.go2 | 11 +++++++++++ src/go/types/check_test.go | 1 + src/go/types/expr.go | 2 +- src/go/types/testdata/fixedbugs/issue49705.go2 | 11 +++++++++++ 6 files changed, 26 insertions(+), 2 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue49705.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue49705.go2 diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go index a5ecdf8b81..f13679d1e3 100644 --- a/src/cmd/compile/internal/types2/check_test.go +++ b/src/cmd/compile/internal/types2/check_test.go @@ -99,6 +99,7 @@ func asGoVersion(s string) string { // TODO(gri) enable as soon as the unified build supports this. var excludedForUnifiedBuild = map[string]bool{ "issue47818.go2": true, + "issue49705.go2": true, } func testFiles(t *testing.T, filenames []string, colDelta uint, manual bool) { diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index b700716b0c..5961f32f37 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -625,7 +625,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) { // If x is the lhs of a shift, its final type must be integer. // We already know from the shift check that it is representable // as an integer if it is a constant. - if !isInteger(typ) { + if !allInteger(typ) { check.errorf(x, invalidOp+"shifted operand %s (type %s) must be integer", x, typ) return } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49705.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49705.go2 new file mode 100644 index 0000000000..2b991b8722 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49705.go2 @@ -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. + +package p + +import "constraints" + +func shl[I constraints.Integer](n int) I { + return 1 << n +} diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go index 2f80d9b7b6..a3be47e371 100644 --- a/src/go/types/check_test.go +++ b/src/go/types/check_test.go @@ -205,6 +205,7 @@ func asGoVersion(s string) string { // TODO(gri) enable as soon as the unified build supports this. var excludedForUnifiedBuild = map[string]bool{ "issue47818.go2": true, + "issue49705.go2": true, } func testFiles(t *testing.T, sizes Sizes, filenames []string, srcs [][]byte, manual bool, imp Importer) { diff --git a/src/go/types/expr.go b/src/go/types/expr.go index e93a2bc7c8..c49865aec6 100644 --- a/src/go/types/expr.go +++ b/src/go/types/expr.go @@ -565,7 +565,7 @@ func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) { // If x is the lhs of a shift, its final type must be integer. // We already know from the shift check that it is representable // as an integer if it is a constant. - if !isInteger(typ) { + if !allInteger(typ) { check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s (type %s) must be integer", x, typ) return } diff --git a/src/go/types/testdata/fixedbugs/issue49705.go2 b/src/go/types/testdata/fixedbugs/issue49705.go2 new file mode 100644 index 0000000000..2b991b8722 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue49705.go2 @@ -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. + +package p + +import "constraints" + +func shl[I constraints.Integer](n int) I { + return 1 << n +} From b2aa1380d9ad9a46eb98cd2e1ad71fcbccdc2bd1 Mon Sep 17 00:00:00 2001 From: zhouguangyuan Date: Sat, 20 Nov 2021 01:49:32 +0800 Subject: [PATCH 259/752] A+C: add Zhou Guangyuan (individual CLA) Change-Id: I34b966b2f3de93a1d086be3dea5ebc6c60cf1eec Reviewed-on: https://go-review.googlesource.com/c/go/+/365754 Reviewed-by: Ian Lance Taylor Reviewed-by: Emmanuel Odeke --- AUTHORS | 1 + CONTRIBUTORS | 1 + 2 files changed, 2 insertions(+) diff --git a/AUTHORS b/AUTHORS index 8d7e196732..6f304f3672 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1479,6 +1479,7 @@ Zemanta d.o.o. Zev Goldstein Zheng Dayu Zhongtao Chen +Zhou Guangyuan Zhou Peng Ziad Hatahet Zizhao Zhang diff --git a/CONTRIBUTORS b/CONTRIBUTORS index a548cb0e2f..7f74b0ce5b 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -2746,6 +2746,7 @@ Zhengyu He Zhongpeng Lin Zhongtao Chen Zhongwei Yao +Zhou Guangyuan Zhou Peng Ziad Hatahet Ziheng Liu From e73c6c8808da281186a4d8f7107e34e9f7a4a9ee Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Thu, 18 Nov 2021 14:48:26 -0500 Subject: [PATCH 260/752] cmd/go: fix go work sync when there are zero workspace modules go work sync panics when there are no workspace modules. This is because the code that set the pruning mode only did so with modules present. This change changes pruningForGoVersion to properly return workspace pruning in workspace mode to prevent that. Another weird scenario can happen when there are no workspace modules, but the command-line-arguments module is created by default. Check for that when iterating over the workspace modules to avoid trying to find the nonexistant go.mod file for that modules. Fixes #49591 Change-Id: Iee8bc92a8aaf9c440f88fe4f9ca908a8d461cd36 Reviewed-on: https://go-review.googlesource.com/c/go/+/365234 Trust: Michael Matloob Trust: Bryan C. Mills Run-TryBot: Michael Matloob TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/cmd/go/internal/modload/modfile.go | 3 +++ src/cmd/go/internal/workcmd/sync.go | 7 +++++++ .../go/testdata/script/work_sync_missing_module.txt | 12 ++++++++++++ 3 files changed, 22 insertions(+) create mode 100644 src/cmd/go/testdata/script/work_sync_missing_module.txt diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go index 40e6ed787d..7cc2272ea0 100644 --- a/src/cmd/go/internal/modload/modfile.go +++ b/src/cmd/go/internal/modload/modfile.go @@ -124,6 +124,9 @@ const ( ) func pruningForGoVersion(goVersion string) modPruning { + if inWorkspaceMode() { + return workspace + } if semver.Compare("v"+goVersion, ExplicitIndirectVersionV) < 0 { // The go.mod file does not duplicate relevant information about transitive // dependencies, so they cannot be pruned out. diff --git a/src/cmd/go/internal/workcmd/sync.go b/src/cmd/go/internal/workcmd/sync.go index 6f35dc4ff3..5f33e057f6 100644 --- a/src/cmd/go/internal/workcmd/sync.go +++ b/src/cmd/go/internal/workcmd/sync.go @@ -74,6 +74,13 @@ func runSync(ctx context.Context, cmd *base.Command, args []string) { workFilePath := modload.WorkFilePath() // save go.work path because EnterModule clobbers it. for _, m := range mms.Versions() { + if mms.ModRoot(m) == "" && m.Path == "command-line-arguments" { + // This is not a real module. + // TODO(#49228): Remove this special case once the special + // command-line-arguments module is gone. + continue + } + // Use EnterModule to reset the global state in modload to be in // single-module mode using the modroot of m. modload.EnterModule(ctx, mms.ModRoot(m)) diff --git a/src/cmd/go/testdata/script/work_sync_missing_module.txt b/src/cmd/go/testdata/script/work_sync_missing_module.txt new file mode 100644 index 0000000000..0018c733ee --- /dev/null +++ b/src/cmd/go/testdata/script/work_sync_missing_module.txt @@ -0,0 +1,12 @@ +# Ensure go work sync works without any modules in go.work. +go work sync + +# Ensure go work sync works even without a go.mod file. +rm go.mod +go work sync + +-- go.work -- +go 1.18 +-- go.mod -- +go 1.18 +module foo From 6275b54a2a58a1a1bed7f2cc3bc92eca5affb8ff Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 22 Nov 2021 14:37:19 +0000 Subject: [PATCH 261/752] Revert "cmd/go: temporarily skip TestScript/test_fuzz_minimize" This reverts CL 365315. Reason for revert: test may have been fixed by intervening changes. Change-Id: I110948d53a789527edf471f1637eadbd98a1fc5a Reviewed-on: https://go-review.googlesource.com/c/go/+/366074 Trust: Bryan C. Mills Trust: Katie Hockman Run-TryBot: Bryan C. Mills TryBot-Result: Go Bot Reviewed-by: Katie Hockman --- src/cmd/go/testdata/script/test_fuzz_minimize.txt | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/cmd/go/testdata/script/test_fuzz_minimize.txt b/src/cmd/go/testdata/script/test_fuzz_minimize.txt index b591e90d16..a6dc3f1953 100644 --- a/src/cmd/go/testdata/script/test_fuzz_minimize.txt +++ b/src/cmd/go/testdata/script/test_fuzz_minimize.txt @@ -1,5 +1,3 @@ -skip # flaky: https://golang.org/issue/49685 - [!fuzz] skip [short] skip From cd0bf3896677583074d33af0b9e538f237db5394 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Fri, 19 Nov 2021 16:09:52 -0500 Subject: [PATCH 262/752] cmd/go: report a helpful error when there are no modules in workspace The current error message that no go.mod files were found is not helpful, especially when a go.mod file exists in the current directory. Fixes #49594 Change-Id: I750475ce8654eeb3e0a2857d5a2de1a9c6ede415 Reviewed-on: https://go-review.googlesource.com/c/go/+/365319 Trust: Michael Matloob Run-TryBot: Michael Matloob TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/cmd/go/alldocs.go | 12 +++++++++++- src/cmd/go/internal/modload/init.go | 3 +++ src/cmd/go/internal/workcmd/work.go | 12 +++++++++++- .../go/testdata/script/work_build_no_modules.txt | 13 +++++++++++++ 4 files changed, 38 insertions(+), 2 deletions(-) create mode 100644 src/cmd/go/testdata/script/work_build_no_modules.txt diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index 6805d56e2c..296f8f8c6a 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -1371,7 +1371,7 @@ // // Workspace maintenance // -// Go workspace provides access to operations on worskpaces. +// Go workspace provides access to operations on workspaces. // // Note that support for workspaces is built into many other commands, // not just 'go work'. @@ -1379,6 +1379,16 @@ // See 'go help modules' for information about Go's module system of // which workspaces are a part. // +// A workspace is specified by a go.work file that specifies a set of +// module directories with the "use" directive. These modules are used +// as root modules by the go command for builds and related operations. +// A workspace that does not specify modules to be used cannot be used +// to do builds from local code. +// +// To determine whether the go command is operating in workspace mode, +// use the "go env GOWORK" command. This will specify the workspace +// file being used. +// // Usage: // // go work [arguments] diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go index 8bb3875e37..30fe446e43 100644 --- a/src/cmd/go/internal/modload/init.go +++ b/src/cmd/go/internal/modload/init.go @@ -525,6 +525,9 @@ func die() { if cfg.Getenv("GO111MODULE") == "off" { base.Fatalf("go: modules disabled by GO111MODULE=off; see 'go help modules'") } + if inWorkspaceMode() { + base.Fatalf("go: no modules were found in the current workspace; see 'go help work'") + } if dir, name := findAltConfig(base.Cwd()); dir != "" { rel, err := filepath.Rel(base.Cwd(), dir) if err != nil { diff --git a/src/cmd/go/internal/workcmd/work.go b/src/cmd/go/internal/workcmd/work.go index 98d5a01de6..a79eebe649 100644 --- a/src/cmd/go/internal/workcmd/work.go +++ b/src/cmd/go/internal/workcmd/work.go @@ -12,13 +12,23 @@ import ( var CmdWork = &base.Command{ UsageLine: "go work", Short: "workspace maintenance", - Long: `Go workspace provides access to operations on worskpaces. + Long: `Go workspace provides access to operations on workspaces. Note that support for workspaces is built into many other commands, not just 'go work'. See 'go help modules' for information about Go's module system of which workspaces are a part. + +A workspace is specified by a go.work file that specifies a set of +module directories with the "use" directive. These modules are used +as root modules by the go command for builds and related operations. +A workspace that does not specify modules to be used cannot be used +to do builds from local code. + +To determine whether the go command is operating in workspace mode, +use the "go env GOWORK" command. This will specify the workspace +file being used. `, Commands: []*base.Command{ diff --git a/src/cmd/go/testdata/script/work_build_no_modules.txt b/src/cmd/go/testdata/script/work_build_no_modules.txt new file mode 100644 index 0000000000..c9859b437e --- /dev/null +++ b/src/cmd/go/testdata/script/work_build_no_modules.txt @@ -0,0 +1,13 @@ +! go build . +stderr 'go: no modules were found in the current workspace; see ''go help work''' + +-- go.work -- +go 1.18 +-- go.mod -- +go 1.18 + +module foo +-- foo.go -- +package main + +func main() {} \ No newline at end of file From 9e94cc3666cc5ff6ecf5930fb5da48ba62ad8080 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 22 Nov 2021 09:50:47 -0500 Subject: [PATCH 263/752] misc/cgo/test: remove unnecessary forward declaration This test otherwise fails to build on windows/arm64 as of CL 364774 due to a warning (promoted to an error) about a mismatched dllexport attribute. Fortunately, it seems not to need the forward-declared function in this file anyway. Updates #49633 Updates #49721 Change-Id: Ia4698b85077d0718a55d2cc667a7950f1d8e50ab Reviewed-on: https://go-review.googlesource.com/c/go/+/366075 Trust: Bryan C. Mills Run-TryBot: Bryan C. Mills TryBot-Result: Go Bot Reviewed-by: Ian Lance Taylor --- misc/cgo/test/testx.go | 1 - 1 file changed, 1 deletion(-) diff --git a/misc/cgo/test/testx.go b/misc/cgo/test/testx.go index a61b47c41d..8ec84a8b22 100644 --- a/misc/cgo/test/testx.go +++ b/misc/cgo/test/testx.go @@ -113,7 +113,6 @@ typedef struct { int i; } Issue38408, *PIssue38408; -extern void GoFunc49633(void *context); extern void cfunc49633(void*); // definition is in test.go */ import "C" From 2d7ae3fbd86d4b5471ac4044ece208b29cd0ef74 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 22 Nov 2021 10:21:19 -0500 Subject: [PATCH 264/752] net: diagnose unexpected nils in TestUnixAndUnixpacketServer For #34611 Change-Id: I31894d58498b2c290ecceccfc004bc817f8969c9 Reviewed-on: https://go-review.googlesource.com/c/go/+/366114 Trust: Bryan C. Mills Run-TryBot: Bryan C. Mills Reviewed-by: Ian Lance Taylor --- src/net/server_test.go | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/src/net/server_test.go b/src/net/server_test.go index 5192c1e0af..33d33b0337 100644 --- a/src/net/server_test.go +++ b/src/net/server_test.go @@ -7,7 +7,9 @@ package net import ( + "fmt" "os" + "reflect" "testing" ) @@ -187,7 +189,34 @@ func TestUnixAndUnixpacketServer(t *testing.T) { } t.Fatal(err) } - defer os.Remove(c.LocalAddr().String()) + + // We really just want to defer os.Remove(c.LocalAddr().String()) here, + // but sometimes that panics due to a nil dereference on the + // solaris-amd64-oraclerel builder (https://golang.org/issue/34611). + // The source of the nil panic is not obvious because there are many + // nillable types involved, so we will temporarily inspect all of them to + // try to get a better idea of what is happening on that platform. + checkNils := func() { + if c == nil { + panic("Dial returned a nil Conn") + } + if rc := reflect.ValueOf(c); rc.Kind() == reflect.Pointer && rc.IsNil() { + panic(fmt.Sprintf("Dial returned a nil %T", c)) + } + addr := c.LocalAddr() + if addr == nil { + panic(fmt.Sprintf("(%T).LocalAddr returned a nil Addr", c)) + } + if raddr := reflect.ValueOf(addr); raddr.Kind() == reflect.Pointer && raddr.IsNil() { + panic(fmt.Sprintf("(%T).LocalAddr returned a nil %T", c, addr)) + } + } + defer func() { + checkNils() + os.Remove(c.LocalAddr().String()) + }() + checkNils() + defer c.Close() trchs = append(trchs, make(chan error, 1)) go transceiver(c, []byte("UNIX AND UNIXPACKET SERVER TEST"), trchs[i]) From 5a3d871831c9febebe513863a26ecc6da1c9c4f3 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 22 Nov 2021 12:20:26 -0500 Subject: [PATCH 265/752] net: allow more generous slop in Fluctuation tests It appears that at least the OpenBSD kernel gets sloppier the longer the timeout we give it, up to an observed overhead of around 25%. Let's give it a little more than that (33%) in the comparison, and also increase the growth curve to match the actual observed times instead of exponential initial growth. Fixes #36108 Change-Id: Id3e54559b7c45b7c8bc0ca07dce74ca60e77e7ed Reviewed-on: https://go-review.googlesource.com/c/go/+/366176 Trust: Bryan C. Mills Run-TryBot: Bryan C. Mills TryBot-Result: Go Bot Reviewed-by: Ian Lance Taylor --- src/net/timeout_test.go | 61 +++++++++++++++++++++++++++++++---------- 1 file changed, 46 insertions(+), 15 deletions(-) diff --git a/src/net/timeout_test.go b/src/net/timeout_test.go index d345bf85ac..515aa07ec3 100644 --- a/src/net/timeout_test.go +++ b/src/net/timeout_test.go @@ -655,11 +655,37 @@ const ( // maxDynamicTimeout is the maximum timeout to attempt for // tests that automatically increase timeouts until succeess. // - // This should be a strict upper bound on the latency of the timeout: if a - // test would increase the timeout beyond this value, the test fails. - maxDynamicTimeout = 1 * time.Second + // This should be a strict upper bound on the latency required to hit a + // timeout accurately, even on a slow or heavily-loaded machine. If a test + // would increase the timeout beyond this value, the test fails. + maxDynamicTimeout = 4 * time.Second ) +// timeoutUpperBound returns the maximum time that we expect a timeout of +// duration d to take to return the caller. +func timeoutUpperBound(d time.Duration) time.Duration { + // In https://storage.googleapis.com/go-build-log/1e637cd3/openbsd-amd64-68_3585d3e7.log, + // we observed that an openbsd-amd64-68 builder took 636ms for a 512ms timeout + // (24.2% overhead). + return d * 4 / 3 +} + +// nextTimeout returns the next timeout to try after an operation took the given +// actual duration with a timeout shorter than that duration. +func nextTimeout(actual time.Duration) (next time.Duration, ok bool) { + if actual >= maxDynamicTimeout { + return maxDynamicTimeout, false + } + // Since the previous attempt took actual, we can't expect to beat that + // duration by any significant margin. Try the next attempt with an arbitrary + // factor above that, so that our growth curve is at least exponential. + next = actual * 5 / 4 + if next > maxDynamicTimeout { + return maxDynamicTimeout, true + } + return next, true +} + func TestReadTimeoutFluctuation(t *testing.T) { ln, err := newLocalListener("tcp") if err != nil { @@ -703,14 +729,15 @@ func TestReadTimeoutFluctuation(t *testing.T) { if t.Failed() { return } - if actual > d*11/10 { - if actual > maxDynamicTimeout || d > maxDynamicTimeout/2 { - t.Fatalf("Read took %s; expected %v", actual, d) + if want := timeoutUpperBound(d); actual > want { + next, ok := nextTimeout(actual) + if !ok { + t.Fatalf("Read took %s; expected at most %v", actual, want) } // Maybe this machine is too slow to reliably schedule goroutines within // the requested duration. Increase the timeout and try again. t.Logf("Read took %s (expected %s); trying with longer timeout", actual, d) - d *= 2 + d = next continue } @@ -761,14 +788,15 @@ func TestReadFromTimeoutFluctuation(t *testing.T) { if t.Failed() { return } - if actual > d*11/10 { - if actual > maxDynamicTimeout || d > maxDynamicTimeout/2 { - t.Fatalf("ReadFrom took %s; expected %s", actual, d) + if want := timeoutUpperBound(d); actual > want { + next, ok := nextTimeout(actual) + if !ok { + t.Fatalf("ReadFrom took %s; expected at most %s", actual, want) } // Maybe this machine is too slow to reliably schedule goroutines within // the requested duration. Increase the timeout and try again. t.Logf("ReadFrom took %s (expected %s); trying with longer timeout", actual, d) - d *= 2 + d = next continue } @@ -830,7 +858,7 @@ func TestWriteTimeoutFluctuation(t *testing.T) { if t.Failed() { return } - if actual > d*11/10 { + if want := timeoutUpperBound(d); actual > want { if n > 0 { // SetWriteDeadline specifies a time “after which I/O operations fail // instead of blocking”. However, the kernel's send buffer is not yet @@ -838,15 +866,18 @@ func TestWriteTimeoutFluctuation(t *testing.T) { // bytes to it without blocking. t.Logf("Wrote %d bytes into send buffer; retrying until buffer is full", n) if d <= maxDynamicTimeout/2 { + // We don't know how long the actual write loop would have taken if + // the buffer were full, so just guess and double the duration so that + // the next attempt can make twice as much progress toward filling it. d *= 2 } - } else if actual > maxDynamicTimeout || d > maxDynamicTimeout/2 { - t.Fatalf("Write took %s; expected %s", actual, d) + } else if next, ok := nextTimeout(actual); !ok { + t.Fatalf("Write took %s; expected at most %s", actual, want) } else { // Maybe this machine is too slow to reliably schedule goroutines within // the requested duration. Increase the timeout and try again. t.Logf("Write took %s (expected %s); trying with longer timeout", actual, d) - d *= 2 + d = next } continue } From 81031300a7139cfb59f704bcbb97e333590aacd0 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Sun, 21 Nov 2021 16:19:26 -0800 Subject: [PATCH 266/752] misc/cgo/testcshared: skip TestGo2C2Go on Windows For #27019 Fixes #49457 Change-Id: I398abb7b555196ced34a6dd04b68195bf8bbdd38 Reviewed-on: https://go-review.googlesource.com/c/go/+/365994 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Go Bot Reviewed-by: Emmanuel Odeke Reviewed-by: Cherry Mui Reviewed-by: Patrik Nyblom --- misc/cgo/testcshared/cshared_test.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/misc/cgo/testcshared/cshared_test.go b/misc/cgo/testcshared/cshared_test.go index 84b92d502f..13ec8761e8 100644 --- a/misc/cgo/testcshared/cshared_test.go +++ b/misc/cgo/testcshared/cshared_test.go @@ -781,10 +781,10 @@ func copyFile(t *testing.T, dst, src string) { func TestGo2C2Go(t *testing.T) { switch GOOS { - case "darwin", "ios": - // Darwin shared libraries don't support the multiple + case "darwin", "ios", "windows": + // Non-ELF shared libraries don't support the multiple // copies of the runtime package implied by this test. - t.Skip("linking c-shared into Go programs not supported on Darwin; issue 29061") + t.Skipf("linking c-shared into Go programs not supported on %s; issue 29061, 49457", GOOS) case "android": t.Skip("test fails on android; issue 29087") } From 8f559bcb4666b2358c227aa1bd3a82f3b806d45a Mon Sep 17 00:00:00 2001 From: Bharath Kumar Uppala Date: Sun, 21 Nov 2021 02:15:39 +0530 Subject: [PATCH 267/752] testing: mention that TB also covers the new type F Fixes #48146 Change-Id: I7c667a7915db81558514bc9fada6898c565eb0fd Reviewed-on: https://go-review.googlesource.com/c/go/+/365894 Reviewed-by: Emmanuel Odeke Reviewed-by: Katie Hockman Run-TryBot: Emmanuel Odeke TryBot-Result: Go Bot Trust: Katie Hockman Trust: Ian Lance Taylor --- src/testing/testing.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/testing/testing.go b/src/testing/testing.go index 3458b46d97..e4b7aa30e5 100644 --- a/src/testing/testing.go +++ b/src/testing/testing.go @@ -740,7 +740,7 @@ func fmtDuration(d time.Duration) string { return fmt.Sprintf("%.2fs", d.Seconds()) } -// TB is the interface common to T and B. +// TB is the interface common to T, B, and F. type TB interface { Cleanup(func()) Error(args ...interface{}) From 189b4a2f428be7264db76e5275c96d98b847383b Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 22 Nov 2021 14:01:26 -0500 Subject: [PATCH 268/752] cmd/go: forward the MallocNanoZone variable to script tests For #49138 Fixes #49723 Change-Id: Ia93130fdc042a1e2107be95cccd7e7eeaa909a87 Reviewed-on: https://go-review.googlesource.com/c/go/+/366254 Trust: Bryan C. Mills Run-TryBot: Bryan C. Mills Reviewed-by: Ian Lance Taylor --- src/cmd/go/script_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go index 98c1b68ed9..101195fc9d 100644 --- a/src/cmd/go/script_test.go +++ b/src/cmd/go/script_test.go @@ -146,6 +146,7 @@ var extraEnvKeys = []string{ "GO_TESTING_GOTOOLS", // for gccgo testing "GCCGO", // for gccgo testing "GCCGOTOOLDIR", // for gccgo testing + "MallocNanoZone", // Needed to work around an apparent kernel bug in macOS 12; see https://golang.org/issue/49138. } // setup sets up the test execution temporary directory and environment. From 773f43b35638092f9c0dc56f4a468dce2eb3a8ef Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Mon, 22 Nov 2021 12:47:53 -0500 Subject: [PATCH 269/752] go/types, types2: substitute for type parameters in signatures when comparing type identity Generic signatures should be considered identical modulo type parameter renaming. Update Identical to reflect this, by substituting type parameters. Fixes #49722 Change-Id: I33743768c72d8aa59c29bf72fcbabc5974f0b805 Reviewed-on: https://go-review.googlesource.com/c/go/+/366178 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Go Bot --- src/cmd/compile/internal/types2/api_test.go | 50 +++++++++++++ src/cmd/compile/internal/types2/predicates.go | 72 ++++++++++++------- src/go/types/api_test.go | 50 +++++++++++++ src/go/types/predicates.go | 72 ++++++++++++------- 4 files changed, 196 insertions(+), 48 deletions(-) diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go index ca90e6b97d..9436a4ed97 100644 --- a/src/cmd/compile/internal/types2/api_test.go +++ b/src/cmd/compile/internal/types2/api_test.go @@ -1675,6 +1675,56 @@ func TestAssignableTo(t *testing.T) { } } +func TestIdentical(t *testing.T) { + // For each test, we compare the types of objects X and Y in the source. + tests := []struct { + src string + want bool + }{ + // Basic types. + {"var X int; var Y int", true}, + {"var X int; var Y string", false}, + + // TODO: add more tests for complex types. + + // Named types. + {"type X int; type Y int", false}, + + // Aliases. + {"type X = int; type Y = int", true}, + + // Functions. + {`func X(int) string { return "" }; func Y(int) string { return "" }`, true}, + {`func X() string { return "" }; func Y(int) string { return "" }`, false}, + {`func X(int) string { return "" }; func Y(int) {}`, false}, + + // Generic functions. Type parameters should be considered identical modulo + // renaming. See also issue #49722. + {`func X[P ~int](){}; func Y[Q ~int]() {}`, true}, + {`func X[P1 any, P2 ~*P1](){}; func Y[Q1 any, Q2 ~*Q1]() {}`, true}, + {`func X[P1 any, P2 ~[]P1](){}; func Y[Q1 any, Q2 ~*Q1]() {}`, false}, + {`func X[P ~int](P){}; func Y[Q ~int](Q) {}`, true}, + {`func X[P ~string](P){}; func Y[Q ~int](Q) {}`, false}, + {`func X[P ~int]([]P){}; func Y[Q ~int]([]Q) {}`, true}, + } + + for _, test := range tests { + pkg, err := pkgFor("test", "package p;"+test.src, nil) + if err != nil { + t.Errorf("%s: incorrect test case: %s", test.src, err) + continue + } + X := pkg.Scope().Lookup("X") + Y := pkg.Scope().Lookup("Y") + if X == nil || Y == nil { + t.Fatal("test must declare both X and Y") + } + if got := Identical(X.Type(), Y.Type()); got != test.want { + t.Errorf("Identical(%s, %s) = %t, want %t", X.Type(), Y.Type(), got, test.want) + } + } +} + func TestIdentical_issue15173(t *testing.T) { // Identical should allow nil arguments and be symmetric. for _, test := range []struct { diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go index e7834a0f9e..cf2993f68b 100644 --- a/src/cmd/compile/internal/types2/predicates.go +++ b/src/cmd/compile/internal/types2/predicates.go @@ -235,19 +235,56 @@ func identical(x, y Type, cmpTags bool, p *ifacePair) bool { } case *Signature: - // Two function types are identical if they have the same number of parameters - // and result values, corresponding parameter and result types are identical, - // and either both functions are variadic or neither is. Parameter and result - // names are not required to match. - // Generic functions must also have matching type parameter lists, but for the - // parameter names. - if y, ok := y.(*Signature); ok { - return x.variadic == y.variadic && - identicalTParams(x.TypeParams().list(), y.TypeParams().list(), cmpTags, p) && - identical(x.params, y.params, cmpTags, p) && - identical(x.results, y.results, cmpTags, p) + y, _ := y.(*Signature) + if y == nil { + return false } + // Two function types are identical if they have the same number of + // parameters and result values, corresponding parameter and result types + // are identical, and either both functions are variadic or neither is. + // Parameter and result names are not required to match, and type + // parameters are considered identical modulo renaming. + + if x.TypeParams().Len() != y.TypeParams().Len() { + return false + } + + // In the case of generic signatures, we will substitute in yparams and + // yresults. + yparams := y.params + yresults := y.results + + if x.TypeParams().Len() > 0 { + // We must ignore type parameter names when comparing x and y. The + // easiest way to do this is to substitute x's type parameters for y's. + xtparams := x.TypeParams().list() + ytparams := y.TypeParams().list() + + var targs []Type + for i := range xtparams { + targs = append(targs, x.TypeParams().At(i)) + } + smap := makeSubstMap(ytparams, targs) + + var check *Checker // ok to call subst on a nil *Checker + + // Constraints must be pair-wise identical, after substitution. + for i, xtparam := range xtparams { + ybound := check.subst(nopos, ytparams[i].bound, smap, nil) + if !identical(xtparam.bound, ybound, cmpTags, p) { + return false + } + } + + yparams = check.subst(nopos, y.params, smap, nil).(*Tuple) + yresults = check.subst(nopos, y.results, smap, nil).(*Tuple) + } + + return x.variadic == y.variadic && + identical(x.params, yparams, cmpTags, p) && + identical(x.results, yresults, cmpTags, p) + case *Union: if y, _ := y.(*Union); y != nil { xset := computeUnionTypeSet(nil, nopos, x) @@ -389,19 +426,6 @@ func identicalInstance(xorig Type, xargs []Type, yorig Type, yargs []Type) bool return Identical(xorig, yorig) } -func identicalTParams(x, y []*TypeParam, cmpTags bool, p *ifacePair) bool { - if len(x) != len(y) { - return false - } - for i, x := range x { - y := y[i] - if !identical(x.bound, y.bound, cmpTags, p) { - return false - } - } - return true -} - // Default returns the default "typed" type for an "untyped" type; // it returns the incoming type for all other types. The default type // for untyped nil is untyped nil. diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go index d8ca8ad611..c8fda5521a 100644 --- a/src/go/types/api_test.go +++ b/src/go/types/api_test.go @@ -1661,6 +1661,56 @@ func TestAssignableTo(t *testing.T) { } } +func TestIdentical(t *testing.T) { + // For each test, we compare the types of objects X and Y in the source. + tests := []struct { + src string + want bool + }{ + // Basic types. + {"var X int; var Y int", true}, + {"var X int; var Y string", false}, + + // TODO: add more tests for complex types. + + // Named types. + {"type X int; type Y int", false}, + + // Aliases. + {"type X = int; type Y = int", true}, + + // Functions. + {`func X(int) string { return "" }; func Y(int) string { return "" }`, true}, + {`func X() string { return "" }; func Y(int) string { return "" }`, false}, + {`func X(int) string { return "" }; func Y(int) {}`, false}, + + // Generic functions. Type parameters should be considered identical modulo + // renaming. See also issue #49722. + {`func X[P ~int](){}; func Y[Q ~int]() {}`, true}, + {`func X[P1 any, P2 ~*P1](){}; func Y[Q1 any, Q2 ~*Q1]() {}`, true}, + {`func X[P1 any, P2 ~[]P1](){}; func Y[Q1 any, Q2 ~*Q1]() {}`, false}, + {`func X[P ~int](P){}; func Y[Q ~int](Q) {}`, true}, + {`func X[P ~string](P){}; func Y[Q ~int](Q) {}`, false}, + {`func X[P ~int]([]P){}; func Y[Q ~int]([]Q) {}`, true}, + } + + for _, test := range tests { + pkg, err := pkgForMode("test", "package p;"+test.src, nil, 0) + if err != nil { + t.Errorf("%s: incorrect test case: %s", test.src, err) + continue + } + X := pkg.Scope().Lookup("X") + Y := pkg.Scope().Lookup("Y") + if X == nil || Y == nil { + t.Fatal("test must declare both X and Y") + } + if got := Identical(X.Type(), Y.Type()); got != test.want { + t.Errorf("Identical(%s, %s) = %t, want %t", X.Type(), Y.Type(), got, test.want) + } + } +} + func TestIdentical_issue15173(t *testing.T) { // Identical should allow nil arguments and be symmetric. for _, test := range []struct { diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go index 229a616eac..22ccdd7744 100644 --- a/src/go/types/predicates.go +++ b/src/go/types/predicates.go @@ -237,19 +237,56 @@ func identical(x, y Type, cmpTags bool, p *ifacePair) bool { } case *Signature: - // Two function types are identical if they have the same number of parameters - // and result values, corresponding parameter and result types are identical, - // and either both functions are variadic or neither is. Parameter and result - // names are not required to match. - // Generic functions must also have matching type parameter lists, but for the - // parameter names. - if y, ok := y.(*Signature); ok { - return x.variadic == y.variadic && - identicalTParams(x.TypeParams().list(), y.TypeParams().list(), cmpTags, p) && - identical(x.params, y.params, cmpTags, p) && - identical(x.results, y.results, cmpTags, p) + y, _ := y.(*Signature) + if y == nil { + return false } + // Two function types are identical if they have the same number of + // parameters and result values, corresponding parameter and result types + // are identical, and either both functions are variadic or neither is. + // Parameter and result names are not required to match, and type + // parameters are considered identical modulo renaming. + + if x.TypeParams().Len() != y.TypeParams().Len() { + return false + } + + // In the case of generic signatures, we will substitute in yparams and + // yresults. + yparams := y.params + yresults := y.results + + if x.TypeParams().Len() > 0 { + // We must ignore type parameter names when comparing x and y. The + // easiest way to do this is to substitute x's type parameters for y's. + xtparams := x.TypeParams().list() + ytparams := y.TypeParams().list() + + var targs []Type + for i := range xtparams { + targs = append(targs, x.TypeParams().At(i)) + } + smap := makeSubstMap(ytparams, targs) + + var check *Checker // ok to call subst on a nil *Checker + + // Constraints must be pair-wise identical, after substitution. + for i, xtparam := range xtparams { + ybound := check.subst(token.NoPos, ytparams[i].bound, smap, nil) + if !identical(xtparam.bound, ybound, cmpTags, p) { + return false + } + } + + yparams = check.subst(token.NoPos, y.params, smap, nil).(*Tuple) + yresults = check.subst(token.NoPos, y.results, smap, nil).(*Tuple) + } + + return x.variadic == y.variadic && + identical(x.params, yparams, cmpTags, p) && + identical(x.results, yresults, cmpTags, p) + case *Union: if y, _ := y.(*Union); y != nil { xset := computeUnionTypeSet(nil, token.NoPos, x) @@ -391,19 +428,6 @@ func identicalInstance(xorig Type, xargs []Type, yorig Type, yargs []Type) bool return Identical(xorig, yorig) } -func identicalTParams(x, y []*TypeParam, cmpTags bool, p *ifacePair) bool { - if len(x) != len(y) { - return false - } - for i, x := range x { - y := y[i] - if !identical(x.bound, y.bound, cmpTags, p) { - return false - } - } - return true -} - // Default returns the default "typed" type for an "untyped" type; // it returns the incoming type for all other types. The default type // for untyped nil is untyped nil. From 17aa21279965f5d088606639c17aa60208a34b7d Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 22 Nov 2021 14:30:40 -0500 Subject: [PATCH 270/752] runtime: in TestSpuriousWakeupsNeverHangSemasleep, wait for the runtime to register handlers According to https://man7.org/linux/man-pages/man7/signal.7.html, the default behavior of SIGIO is to terminate the program. The Go runtime changes that behavior with its own signal handler, so the program will terminate if we send the signal before the runtime has finished setting up. Fixes #49727 Change-Id: I65db66f5176831c8d7454eebc0138d825c68e100 Reviewed-on: https://go-review.googlesource.com/c/go/+/366255 Trust: Bryan C. Mills Run-TryBot: Bryan C. Mills Reviewed-by: Ian Lance Taylor --- src/runtime/semasleep_test.go | 41 +++++++++++++++++++------- src/runtime/testdata/testprog/sleep.go | 7 ++++- 2 files changed, 37 insertions(+), 11 deletions(-) diff --git a/src/runtime/semasleep_test.go b/src/runtime/semasleep_test.go index cf4ef18208..bc73140a2a 100644 --- a/src/runtime/semasleep_test.go +++ b/src/runtime/semasleep_test.go @@ -7,6 +7,7 @@ package runtime_test import ( + "io" "os/exec" "syscall" "testing" @@ -28,6 +29,10 @@ func TestSpuriousWakeupsNeverHangSemasleep(t *testing.T) { start := time.Now() cmd := exec.Command(exe, "After1") + stdout, err := cmd.StdoutPipe() + if err != nil { + t.Fatalf("StdoutPipe: %v", err) + } if err := cmd.Start(); err != nil { t.Fatalf("Failed to start command: %v", err) } @@ -36,27 +41,43 @@ func TestSpuriousWakeupsNeverHangSemasleep(t *testing.T) { doneCh <- cmd.Wait() }() + // Wait for After1 to close its stdout so that we know the runtime's SIGIO + // handler is registered. + b, err := io.ReadAll(stdout) + if len(b) > 0 { + t.Logf("read from testprog stdout: %s", b) + } + if err != nil { + t.Fatalf("error reading from testprog: %v", err) + } + // With the repro running, we can continuously send to it - // a non-terminal signal such as SIGIO, to spuriously - // wakeup pthread_cond_timedwait_relative_np. - unfixedTimer := time.NewTimer(2 * time.Second) + // a signal that the runtime considers non-terminal, + // such as SIGIO, to spuriously wake up + // pthread_cond_timedwait_relative_np. + ticker := time.NewTicker(200 * time.Millisecond) + defer ticker.Stop() for { select { - case <-time.After(200 * time.Millisecond): + case now := <-ticker.C: + if now.Sub(start) > 2*time.Second { + t.Error("Program failed to return on time and has to be killed, issue #27520 still exists") + cmd.Process.Signal(syscall.SIGKILL) + <-doneCh + return + } + // Send the pesky signal that toggles spinning // indefinitely if #27520 is not fixed. cmd.Process.Signal(syscall.SIGIO) - case <-unfixedTimer.C: - t.Error("Program failed to return on time and has to be killed, issue #27520 still exists") - cmd.Process.Signal(syscall.SIGKILL) - return - case err := <-doneCh: if err != nil { t.Fatalf("The program returned but unfortunately with an error: %v", err) } - if time.Since(start) < 100*time.Millisecond { + if time.Since(start) < 1*time.Second { + // The program was supposed to sleep for a full (monotonic) second; + // it should not return before that has elapsed. t.Fatalf("The program stopped too quickly.") } return diff --git a/src/runtime/testdata/testprog/sleep.go b/src/runtime/testdata/testprog/sleep.go index 86e2f6cfe6..b230e60181 100644 --- a/src/runtime/testdata/testprog/sleep.go +++ b/src/runtime/testdata/testprog/sleep.go @@ -4,7 +4,10 @@ package main -import "time" +import ( + "os" + "time" +) // for golang.org/issue/27250 @@ -13,5 +16,7 @@ func init() { } func After1() { + os.Stdout.WriteString("ready\n") + os.Stdout.Close() <-time.After(1 * time.Second) } From f13fcd9e6839978b883016a50a4e61d4ba843335 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 22 Nov 2021 14:37:41 -0500 Subject: [PATCH 271/752] runtime: execute TestSpuriousWakeupsNeverHangSemasleep in parallel This test spends most of its time sleeping and waiting on a subprocess to sleep. It seems like a prime candidate to run in parallel, although we may need to relax its hard-coded 2s timeout on the sleep(1) subprocess. For #48770 Change-Id: I4e839739fe82446615f9894c1904c87e5f3cf386 Reviewed-on: https://go-review.googlesource.com/c/go/+/366256 Trust: Bryan C. Mills Run-TryBot: Bryan C. Mills Reviewed-by: Emmanuel Odeke Reviewed-by: Ian Lance Taylor TryBot-Result: Go Bot --- src/runtime/semasleep_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/src/runtime/semasleep_test.go b/src/runtime/semasleep_test.go index bc73140a2a..0057b0729e 100644 --- a/src/runtime/semasleep_test.go +++ b/src/runtime/semasleep_test.go @@ -21,6 +21,7 @@ func TestSpuriousWakeupsNeverHangSemasleep(t *testing.T) { if *flagQuick { t.Skip("-quick") } + t.Parallel() // Waits for a program to sleep for 1s. exe, err := buildTestProg(t, "testprog") if err != nil { From 100d7ea50dbe601164f428f5e4203be7727093f9 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Mon, 22 Nov 2021 15:37:29 -0500 Subject: [PATCH 272/752] cmd/go: correct an inaccuracy in the 'go help work' docs Change-Id: If2c6586b5ad212214b8041f8768fe7d26b877207 Reviewed-on: https://go-review.googlesource.com/c/go/+/366314 Trust: Michael Matloob Run-TryBot: Michael Matloob TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/cmd/go/alldocs.go | 2 +- src/cmd/go/internal/workcmd/work.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index 296f8f8c6a..12b64d309c 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -1383,7 +1383,7 @@ // module directories with the "use" directive. These modules are used // as root modules by the go command for builds and related operations. // A workspace that does not specify modules to be used cannot be used -// to do builds from local code. +// to do builds from local modules. // // To determine whether the go command is operating in workspace mode, // use the "go env GOWORK" command. This will specify the workspace diff --git a/src/cmd/go/internal/workcmd/work.go b/src/cmd/go/internal/workcmd/work.go index a79eebe649..3ddbfbe772 100644 --- a/src/cmd/go/internal/workcmd/work.go +++ b/src/cmd/go/internal/workcmd/work.go @@ -24,7 +24,7 @@ A workspace is specified by a go.work file that specifies a set of module directories with the "use" directive. These modules are used as root modules by the go command for builds and related operations. A workspace that does not specify modules to be used cannot be used -to do builds from local code. +to do builds from local modules. To determine whether the go command is operating in workspace mode, use the "go env GOWORK" command. This will specify the workspace From 11972353a67456d776cf891a9e46873e8a1fe630 Mon Sep 17 00:00:00 2001 From: Ryan Leung Date: Mon, 22 Nov 2021 02:41:07 +0000 Subject: [PATCH 273/752] cmd/go: allow a package that ends with _test having an internal test package Fixes #45477 Change-Id: I2f1ed281515ec40d31fd07ce9f4901777691bfa7 GitHub-Last-Rev: 7894d9400c95b8d84efe88f401fa75c3dd01921a GitHub-Pull-Request: golang/go#49673 Reviewed-on: https://go-review.googlesource.com/c/go/+/365534 Trust: Heschi Kreinick Reviewed-by: Bryan C. Mills Run-TryBot: Bryan C. Mills TryBot-Result: Go Bot --- src/cmd/go/testdata/script/test_issue45477.txt | 12 ++++++++++++ src/go/build/build.go | 2 +- 2 files changed, 13 insertions(+), 1 deletion(-) create mode 100644 src/cmd/go/testdata/script/test_issue45477.txt diff --git a/src/cmd/go/testdata/script/test_issue45477.txt b/src/cmd/go/testdata/script/test_issue45477.txt new file mode 100644 index 0000000000..f435b6a6f4 --- /dev/null +++ b/src/cmd/go/testdata/script/test_issue45477.txt @@ -0,0 +1,12 @@ +[short] skip # links and runs a test binary + +go test -v . + +-- go.mod -- +module example.com/pkg_test + +-- pkg.go -- +package pkg_test + +-- pkg_test.go -- +package pkg_test diff --git a/src/go/build/build.go b/src/go/build/build.go index eb47ffe285..6f7260b78f 100644 --- a/src/go/build/build.go +++ b/src/go/build/build.go @@ -894,7 +894,7 @@ Found: isTest := strings.HasSuffix(name, "_test.go") isXTest := false - if isTest && strings.HasSuffix(pkg, "_test") { + if isTest && strings.HasSuffix(pkg, "_test") && p.Name != pkg { isXTest = true pkg = pkg[:len(pkg)-len("_test")] } From 7fbe2f4cc877a02465f36e10e7547e03bcb6e1af Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 22 Nov 2021 12:21:12 -0800 Subject: [PATCH 274/752] doc/go1.18: document compiler change for "declared but not used" errors Fixes #49214. For #47694. Change-Id: Iba68ed17bfd81890309b6a6732087f87a03e1350 Reviewed-on: https://go-review.googlesource.com/c/go/+/366274 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Go Bot Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 61bb8dbbcb..5f94aa86c4 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -29,6 +29,20 @@ Do not send CLs removing the interior tags from such phrases. TODO: complete this section

    +

    Bug fixes

    + +

    + The Go 1.18 compiler now correctly reports declared but not used errors + for variables that are set inside a function literal but are never used. Before Go 1.18, + the compiler did not report an error in such cases. This fixes long-outstanding compiler + issue #8560. As a result of this change, + (possibly incorrect) programs may not compile anymore. The necessary fix is + straightforward: fix the program if it was in fact incorrect, or use the offending + variable, for instance by assigning it to the blank identifier _. + Since go vet always pointed out this error, the number of affected + programs is likely very small. +

    +

    Generics

    From 7456b948532e752c0ea0ac98e56e6898271f4dcd Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 22 Nov 2021 12:33:11 -0800 Subject: [PATCH 275/752] doc/go1.18: document new overflow error for some untyped arguments to print/ln Fixes #49216. For #47694. Change-Id: Ib129d790c382ddcc9677d87db4ca827b7159856a Reviewed-on: https://go-review.googlesource.com/c/go/+/366275 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 5f94aa86c4..4175063edd 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -43,6 +43,19 @@ Do not send CLs removing the interior tags from such phrases. programs is likely very small.

    +

    + The Go 1.18 compiler now reports an overflow when passing a rune constant expression + such as '1' << 32 as an argument to the predeclared functions + print and println, consistent with the behavior of + user-defined functions. Before Go 1.18, the compiler did not report an error + in such cases but silently accepted such constant arguments if they fit into an + int64. As a result of this change, (possibly incorrect) programs + may not compile anymore. The necessary fix is straightforward: fix the program if it + was in fact incorrect, or explicitly convert the offending argument to the correct type. + Since go vet always pointed out this error, the number of affected + programs is likely very small. +

    +

    Generics

    From 0244343088e074c5f92b42a9812521f711a69410 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 22 Nov 2021 11:43:46 -0800 Subject: [PATCH 276/752] spec: fix Swap example (correctly swap type arguments and parameters) Thanks to @danscales for noticing the mistake. Change-Id: I547ee80a78419765b82d39d7b34dc8d3bf962c35 Reviewed-on: https://go-review.googlesource.com/c/go/+/366215 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor Reviewed-by: Dan Scales --- doc/go_spec.html | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index bf589f0ae6..ecd2f084c9 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1,6 +1,6 @@ @@ -2808,7 +2808,7 @@ type Pair[A, B any] struct { b B } -func (p Pair[A, B]) Swap() Pair[A, B] { return Pair[A, B]{p.b, p.a} } +func (p Pair[A, B]) Swap() Pair[B, A] { return Pair[B, A]{p.b, p.a} } func (p Pair[First, _]) First() First { return p.a } From 9678f794149d07857cbf2a518bfc7aec532fb732 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20Mart=C3=AD?= Date: Thu, 18 Nov 2021 22:58:17 +0000 Subject: [PATCH 277/752] cmd/go: work out VCS information once per repository MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit We need VCS status information for each main package we load. If two main packages are under the same VCS repository, we can reuse that information to avoid duplicating work. For instance, the kubernetes holds 51 main packages in its root module, meaning that "go list ./..." repeated the same git calls 51 times. Instead, use a global par.Cache to deduplicate that work. Below are the numbers on kubernetes 5eb584d1cb6917, via "benchcmd -n 8 KubernetesListPackages go list ./...": name old time/op new time/op delta KubernetesListPackages 8.91s ± 0% 3.33s ± 1% -62.61% (p=0.000 n=7+8) name old user-time/op new user-time/op delta KubernetesListPackages 11.2s ± 1% 8.1s ± 2% -27.50% (p=0.000 n=7+8) name old sys-time/op new sys-time/op delta KubernetesListPackages 8.02s ± 0% 1.67s ± 6% -79.21% (p=0.001 n=6+8) name old peak-RSS-bytes new peak-RSS-bytes delta KubernetesListPackages 127MB ± 2% 123MB ± 7% ~ (p=0.328 n=8+8) Fixes #49582. Change-Id: Ib7ef5dc7a35c83a11e209441f5d6f3b8da068259 Reviewed-on: https://go-review.googlesource.com/c/go/+/365394 Trust: Daniel Martí Trust: Dominik Honnef Run-TryBot: Bryan C. Mills Reviewed-by: Bryan C. Mills TryBot-Result: Go Bot --- src/cmd/go/internal/load/pkg.go | 17 +++++++++++++++-- .../testdata/script/version_buildvcs_git.txt | 19 +++++++++++++++++++ 2 files changed, 34 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go index 360d265de6..41afa42f0f 100644 --- a/src/cmd/go/internal/load/pkg.go +++ b/src/cmd/go/internal/load/pkg.go @@ -2203,6 +2203,10 @@ func (p *Package) collectDeps() { } } +// vcsStatusCache maps repository directories (string) +// to their VCS information (vcsStatusError). +var vcsStatusCache par.Cache + // setBuildInfo gathers build information, formats it as a string to be // embedded in the binary, then sets p.Internal.BuildInfo to that string. // setBuildInfo should only be called on a main package with no errors. @@ -2365,11 +2369,20 @@ func (p *Package) setBuildInfo() { return } - st, err := vcsCmd.Status(vcsCmd, repoDir) - if err != nil { + type vcsStatusError struct { + Status vcs.Status + Err error + } + cached := vcsStatusCache.Do(repoDir, func() interface{} { + st, err := vcsCmd.Status(vcsCmd, repoDir) + return vcsStatusError{st, err} + }).(vcsStatusError) + if err := cached.Err; err != nil { setVCSError(err) return } + st := cached.Status + if st.Revision != "" { appendSetting(vcsCmd.Cmd+"revision", st.Revision) } diff --git a/src/cmd/go/testdata/script/version_buildvcs_git.txt b/src/cmd/go/testdata/script/version_buildvcs_git.txt index 3d56c6d8b4..72cbe28285 100644 --- a/src/cmd/go/testdata/script/version_buildvcs_git.txt +++ b/src/cmd/go/testdata/script/version_buildvcs_git.txt @@ -16,6 +16,7 @@ rm $GOBIN/a$GOEXE # If there is a repository, but it can't be used for some reason, # there should be an error. It should hint about -buildvcs=false. +# Also ensure that multiple errors are collected by "go list -e". cd .. mkdir .git env PATH=$WORK${/}fakebin${:}$oldpath @@ -24,6 +25,10 @@ chmod 0755 $WORK/fakebin/git cd a ! go install stderr '^error obtaining VCS status: exit status 1\n\tUse -buildvcs=false to disable VCS stamping.$' +go list -e -f '{{.ImportPath}}: {{.Error}}' ./... +stdout -count=1 '^example\.com/a: error obtaining VCS status' +stdout -count=1 '^example\.com/a/library: ' +stdout -count=1 '^example\.com/a/othermain: error obtaining VCS status' cd .. env PATH=$oldpath rm .git @@ -99,6 +104,14 @@ go version -m $GOBIN/d$GOEXE exec git checkout go.mod rm $GOBIN/d$GOEXE +# If we're loading multiple main packages, +# but they share the same VCS repository, +# we only need to execute VCS status commands once. +go list -x ./... +stdout -count=3 '^example.com' +stderr -count=1 '^git status' +stderr -count=1 '^git show' + -- $WORK/fakebin/git -- #!/bin/sh exit 1 @@ -114,6 +127,12 @@ go 1.18 -- repo/a/a.go -- package main +func main() {} +-- repo/a/library/f.go -- +package library +-- repo/a/othermain/f.go -- +package main + func main() {} -- repo/b/go.mod -- module example.com/b From 83bfed916b97d51646b4bdc95e0e0fd7798b754f Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 22 Nov 2021 13:53:21 -0800 Subject: [PATCH 278/752] cmd/compile/internal/types2: print "nil" rather than "untyped nil" When we have a typed nil, we already say so; thus it is sufficient to use "nil" in all the other cases. This is closer to (1.17) compiler behavior. In cases where the 1.17 compiler prints "untyped nil" (e.g., wrong uses of "copy"), we already print a different message. We can do better in those cases as well; will be addressed in a separate CL (see #49735). Fixes #48852. Change-Id: I9a7a72e0f99185b00f80040c5510a693b1ea80f6 Reviewed-on: https://go-review.googlesource.com/c/go/+/366276 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/assignments.go | 3 --- src/cmd/compile/internal/types2/operand.go | 2 +- .../internal/types2/testdata/check/stmt0.src | 6 +++--- .../types2/testdata/fixedbugs/issue49296.go2 | 2 +- .../types2/testdata/spec/assignability.go2 | 18 +++++++++--------- test/fixedbugs/issue6004.go | 9 ++++----- test/fixedbugs/issue6402.go | 2 +- test/fixedbugs/issue7223.go | 11 ++++++----- 8 files changed, 25 insertions(+), 28 deletions(-) diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go index a3d32093d6..ac4f7b88a4 100644 --- a/src/cmd/compile/internal/types2/assignments.go +++ b/src/cmd/compile/internal/types2/assignments.go @@ -220,9 +220,6 @@ func (check *Checker) assignVar(lhs syntax.Expr, x *operand) Type { return nil case variable, mapindex: // ok - case nilvalue: - check.error(&z, "cannot assign to nil") // default would print "untyped nil" - return nil default: if sel, ok := z.expr.(*syntax.SelectorExpr); ok { var op operand diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go index 6581d80323..f6bd0291ec 100644 --- a/src/cmd/compile/internal/types2/operand.go +++ b/src/cmd/compile/internal/types2/operand.go @@ -116,7 +116,7 @@ func operandString(x *operand, qf Qualifier) string { case nil, Typ[Invalid]: return "nil (with invalid type)" case Typ[UntypedNil]: - return "untyped nil" + return "nil" default: return fmt.Sprintf("nil (of type %s)", TypeString(x.typ, qf)) } diff --git a/src/cmd/compile/internal/types2/testdata/check/stmt0.src b/src/cmd/compile/internal/types2/testdata/check/stmt0.src index d744f2ba81..353444f068 100644 --- a/src/cmd/compile/internal/types2/testdata/check/stmt0.src +++ b/src/cmd/compile/internal/types2/testdata/check/stmt0.src @@ -69,10 +69,10 @@ func assignments1() { // test cases for issue 5800 var ( - _ int = nil /* ERROR "untyped nil" */ - _ [10]int = nil /* ERROR "untyped nil" */ + _ int = nil /* ERROR "nil" */ + _ [10]int = nil /* ERROR "nil" */ _ []byte = nil - _ struct{} = nil /* ERROR "untyped nil" */ + _ struct{} = nil /* ERROR "nil" */ _ func() = nil _ map[int]string = nil _ chan int = nil diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49296.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49296.go2 index 8f52acc8a4..eaa8e4dc7d 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49296.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49296.go2 @@ -9,7 +9,7 @@ func _[ T1 []int, T2 ~float64 | ~complex128 | chan int, ]() { - _ = T0(nil /* ERROR cannot convert untyped nil to T0 */ ) + _ = T0(nil /* ERROR cannot convert nil to T0 */ ) _ = T1(1 /* ERROR cannot convert 1 .* to T1 */ ) _ = T2(2 /* ERROR cannot convert 2 .* to T2 */ ) } diff --git a/src/cmd/compile/internal/types2/testdata/spec/assignability.go2 b/src/cmd/compile/internal/types2/testdata/spec/assignability.go2 index fb28358bbb..507fe6d021 100644 --- a/src/cmd/compile/internal/types2/testdata/spec/assignability.go2 +++ b/src/cmd/compile/internal/types2/testdata/spec/assignability.go2 @@ -153,28 +153,28 @@ func _[ // "x is the predeclared identifier nil and T is a pointer, function, slice, map, channel, or interface type" func _[TP Interface](X TP) { - b = nil // ERROR cannot use untyped nil - a = nil // ERROR cannot use untyped nil + b = nil // ERROR cannot use nil + a = nil // ERROR cannot use nil l = nil - s = nil // ERROR cannot use untyped nil + s = nil // ERROR cannot use nil p = nil f = nil i = nil m = nil c = nil - d = nil // ERROR cannot use untyped nil + d = nil // ERROR cannot use nil - B = nil // ERROR cannot use untyped nil - A = nil // ERROR cannot use untyped nil + B = nil // ERROR cannot use nil + A = nil // ERROR cannot use nil L = nil - S = nil // ERROR cannot use untyped nil + S = nil // ERROR cannot use nil P = nil F = nil I = nil M = nil C = nil - D = nil // ERROR cannot use untyped nil - X = nil // ERROR cannot use untyped nil + D = nil // ERROR cannot use nil + X = nil // ERROR cannot use nil } // "x is an untyped constant representable by a value of type T" diff --git a/test/fixedbugs/issue6004.go b/test/fixedbugs/issue6004.go index 2b3dcd923d..99d6ab85ea 100644 --- a/test/fixedbugs/issue6004.go +++ b/test/fixedbugs/issue6004.go @@ -7,9 +7,8 @@ package main func main() { - _ = nil // ERROR "use of untyped nil" - _, _ = nil, 1 // ERROR "use of untyped nil" - _, _ = 1, nil // ERROR "use of untyped nil" - _ = append(nil, 1, 2, 3) // ERROR "untyped nil" + _ = nil // ERROR "use of untyped nil" + _, _ = nil, 1 // ERROR "use of untyped nil" + _, _ = 1, nil // ERROR "use of untyped nil" + _ = append(nil, 1, 2, 3) // ERROR "untyped nil|nil" } - diff --git a/test/fixedbugs/issue6402.go b/test/fixedbugs/issue6402.go index 39cb9ac3f0..9977027d18 100644 --- 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|incompatible type|cannot use untyped nil" + return nil // ERROR "cannot use nil as type uintptr in return argument|incompatible type|cannot use nil" } diff --git a/test/fixedbugs/issue7223.go b/test/fixedbugs/issue7223.go index c78de287ff..129e20f497 100644 --- a/test/fixedbugs/issue7223.go +++ b/test/fixedbugs/issue7223.go @@ -7,14 +7,15 @@ package main var bits1 uint = 10 + const bits2 uint = 10 func main() { _ = make([]byte, 1< Date: Tue, 23 Nov 2021 14:30:56 +0000 Subject: [PATCH 279/752] runtime: ensure no GC is running in TestParallelRWMutexReaders Currently this test makes it clear that it's unsafe for a GC to run, otherwise a deadlock could occur, so it calls SetGCPercent(-1). However, a GC may be actively in progress, and SetGCPercent is not going to end any in-progress GC. Call runtime.GC to block until at least the current GC is over. Updates #49680. Change-Id: Ibdc7d378e8cf7e05270910e92effcad8c6874e59 Reviewed-on: https://go-review.googlesource.com/c/go/+/366534 Trust: Michael Knyszek Run-TryBot: Michael Knyszek Reviewed-by: Than McIntosh Reviewed-by: Cherry Mui --- src/runtime/rwmutex_test.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/runtime/rwmutex_test.go b/src/runtime/rwmutex_test.go index 291a32ea5e..33ddd7d1d5 100644 --- a/src/runtime/rwmutex_test.go +++ b/src/runtime/rwmutex_test.go @@ -55,6 +55,9 @@ func TestParallelRWMutexReaders(t *testing.T) { // since the goroutines can't be stopped/preempted. // Disable GC for this test (see issue #10958). defer debug.SetGCPercent(debug.SetGCPercent(-1)) + // Finish any in-progress GCs and get ourselves to a clean slate. + GC() + doTestParallelReaders(1) doTestParallelReaders(3) doTestParallelReaders(4) From b90c6b99b3fbe60f4782c3e3b85f0ba9bbcf5f50 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Tue, 23 Nov 2021 10:54:49 -0500 Subject: [PATCH 280/752] misc/reboot: skip TestRepeatBootstrap on short builders This test is slow and resource-intensive, and will rarely catch failures. It is important to run sometimes, but probably a waste of time on smaller (and especially reverse) builders. Rather than hard-coding a list of small builders, only run it on the longtest builders. Fixes #35233 Fixes #30892 Fixes #49753 Change-Id: I25a9702e1f541246ea200fd7c79414ca5f69edae Reviewed-on: https://go-review.googlesource.com/c/go/+/366538 Trust: Bryan C. Mills Run-TryBot: Bryan C. Mills Reviewed-by: Ian Lance Taylor --- misc/reboot/reboot_test.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/misc/reboot/reboot_test.go b/misc/reboot/reboot_test.go index 6bafc608b5..ef164d3232 100644 --- a/misc/reboot/reboot_test.go +++ b/misc/reboot/reboot_test.go @@ -15,6 +15,10 @@ import ( ) func TestRepeatBootstrap(t *testing.T) { + if testing.Short() { + t.Skipf("skipping test that rebuilds the entire toolchain") + } + goroot, err := os.MkdirTemp("", "reboot-goroot") if err != nil { t.Fatal(err) From 00045b76e50d98db354aa185bcbd60a6f62499ac Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Tue, 23 Nov 2021 10:39:07 -0500 Subject: [PATCH 281/752] runtime: skip TestCgoCallbackGC on darwin-amd64-10_14 builder This test occasionally fails due to a real bug on this platform. Due to the age of the platform and the rarity of the failure, we do not believe that the bug is worth working around. Fixes #43926 Change-Id: Ia227c5afe81fc21b6630813228f976cc3a54013c Reviewed-on: https://go-review.googlesource.com/c/go/+/366537 Trust: Bryan C. Mills Run-TryBot: Bryan C. Mills Reviewed-by: Cherry Mui TryBot-Result: Go Bot --- src/runtime/crash_cgo_test.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/runtime/crash_cgo_test.go b/src/runtime/crash_cgo_test.go index 9a174fa549..45ee6d6905 100644 --- a/src/runtime/crash_cgo_test.go +++ b/src/runtime/crash_cgo_test.go @@ -64,6 +64,10 @@ func TestCgoCallbackGC(t *testing.T) { t.Skip("too slow for mips64x builders") } } + if testenv.Builder() == "darwin-amd64-10_14" { + // TODO(#23011): When the 10.14 builders are gone, remove this skip. + t.Skip("skipping due to platform bug on macOS 10.14; see https://golang.org/issue/43926") + } got := runTestProg(t, "testprogcgo", "CgoCallbackGC") want := "OK\n" if got != want { From 0f64c21d90c7017df4f199a5852d60d4b474c03c Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 19 Nov 2021 13:28:49 -0800 Subject: [PATCH 282/752] cmd/compile: special packages must not have any path separators We want to distinguish special compiler-generated package paths, like go.shape, from user paths, like go.opentelemetry.io/otel/semconv. The former have no slash in them. Writing a test for this seems hard, as the dependency we'd need to add would be non-hermetic. (Or it would need a new tricky run.go mode.) This CL does fix the example in the issue. Fixes #49606 Change-Id: I38f1b970b6dd31e0617763a27ff227e3afee74d5 Reviewed-on: https://go-review.googlesource.com/c/go/+/365834 Trust: Keith Randall Trust: Dan Scales Run-TryBot: Keith Randall TryBot-Result: Go Bot Reviewed-by: Dan Scales --- src/cmd/compile/internal/types/pkg.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cmd/compile/internal/types/pkg.go b/src/cmd/compile/internal/types/pkg.go index fe42049cee..0b822a450c 100644 --- a/src/cmd/compile/internal/types/pkg.go +++ b/src/cmd/compile/internal/types/pkg.go @@ -49,7 +49,7 @@ func NewPkg(path, name string) *Pkg { p := new(Pkg) p.Path = path p.Name = name - if strings.HasPrefix(path, "go.") { + if strings.HasPrefix(path, "go.") && !strings.Contains(path, "/") { // Special compiler-internal packages don't need to be escaped. // This particularly helps with the go.shape package. p.Prefix = path From e3eaedb5cf623d0836533573db4140749da42768 Mon Sep 17 00:00:00 2001 From: Chaoqun Han Date: Tue, 23 Nov 2021 22:05:40 +0800 Subject: [PATCH 283/752] os/signal: reset SIGURG in TestSignal MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Accepting SIGURG signals could cause SIGURG to take up the entire channel buffer. Enhance the stability of test cases by: 1. Stop accepting the SIGURG signal by adding ‘Reset(sys call.SIGURG)’ 2. Close the c1 chan by adding ‘defer Stop(c1)’ (Another bug, NOT this bug) Fixes #49724 Change-Id: I909a9993f0f6dd109c15e48a861683b87dfc4ab3 Reviewed-on: https://go-review.googlesource.com/c/go/+/366514 Reviewed-by: Ian Lance Taylor Reviewed-by: Bryan C. Mills Trust: Bryan C. Mills --- src/os/signal/signal_test.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/os/signal/signal_test.go b/src/os/signal/signal_test.go index 3e85d936f8..e6fb24c6a8 100644 --- a/src/os/signal/signal_test.go +++ b/src/os/signal/signal_test.go @@ -136,6 +136,9 @@ func TestSignal(t *testing.T) { // Using 10 is arbitrary. c1 := make(chan os.Signal, 10) Notify(c1) + // Stop relaying the SIGURG signals. See #49724 + Reset(syscall.SIGURG) + defer Stop(c1) // Send this process a SIGWINCH t.Logf("sigwinch...") From 1ac45e026b2cbae91e3495e2cc6e93b6d505b4f4 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 23 Nov 2021 12:25:10 -0800 Subject: [PATCH 284/752] runtime: run the right test in TestCgoExternalThreadSignal The code was accidentally repeating the TestCgoExternalThreadSIGPROF test. While we're here remove an obsolete skip on ppc64/linux. Change-Id: Icdc4032a67aa80fbcfcd7c5c7ab8a6f23f321e2e Reviewed-on: https://go-review.googlesource.com/c/go/+/366755 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/runtime/crash_cgo_test.go | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/runtime/crash_cgo_test.go b/src/runtime/crash_cgo_test.go index 45ee6d6905..bfb260a143 100644 --- a/src/runtime/crash_cgo_test.go +++ b/src/runtime/crash_cgo_test.go @@ -94,11 +94,6 @@ func TestCgoExternalThreadSIGPROF(t *testing.T) { case "plan9", "windows": t.Skipf("no pthreads on %s", runtime.GOOS) } - if runtime.GOARCH == "ppc64" && runtime.GOOS == "linux" { - // TODO(austin) External linking not implemented on - // linux/ppc64 (issue #8912) - t.Skipf("no external linking on ppc64") - } exe, err := buildTestProg(t, "testprogcgo", "-tags=threadprof") if err != nil { @@ -128,7 +123,7 @@ func TestCgoExternalThreadSignal(t *testing.T) { t.Fatal(err) } - got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoExternalThreadSIGPROF")).CombinedOutput() + got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoExternalThreadSignal")).CombinedOutput() if err != nil { t.Fatalf("exit status: %v\n%s", err, got) } From 47db3bb443774c0b0df2cab188aa3d76b361dca2 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 23 Nov 2021 16:30:17 -0800 Subject: [PATCH 285/752] runtime: skip TestTimePprof if nanotime calls libc Fixes #43118 Change-Id: I499bf335904e2b72a2a8876d0368fff5e69aa7fa Reviewed-on: https://go-review.googlesource.com/c/go/+/366759 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor Reviewed-by: Bryan C. Mills TryBot-Result: Go Bot --- src/runtime/crash_test.go | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/runtime/crash_test.go b/src/runtime/crash_test.go index 91a1a41ed5..1c28e47ac3 100644 --- a/src/runtime/crash_test.go +++ b/src/runtime/crash_test.go @@ -714,6 +714,13 @@ func TestBadTraceback(t *testing.T) { } func TestTimePprof(t *testing.T) { + // This test is unreliable on any system in which nanotime + // calls into libc. + switch runtime.GOOS { + case "aix", "darwin", "openbsd", "solaris": + t.Skipf("skipping on %s because nanotime calls libc", runtime.GOOS) + } + // Pass GOTRACEBACK for issue #41120 to try to get more // information on timeout. fn := runTestProg(t, "testprog", "TimeProf", "GOTRACEBACK=crash") From 465b4028082339bb7aa64ed6e30aef4c0b0413b4 Mon Sep 17 00:00:00 2001 From: Than McIntosh Date: Tue, 23 Nov 2021 08:19:45 -0500 Subject: [PATCH 286/752] cmd/compile/internal/inline: revise closure inl position fix This patch revises the fix for issue 46234, fixing a bug that was accidentally introduced by CL 320913. When inlining a chunk of code with a closure expression, we want to avoid updating the source positions in the function being closed over, but we do want to update the position for the ClosureExpr itself (since it is part of the function we are inlining). CL 320913 unintentionally did away with the closure expr source position update; here we restore it again. Updates #46234. Fixes #49171. Change-Id: Iaa51bc498e374b9e5a46fa0acd7db520edbbbfca Reviewed-on: https://go-review.googlesource.com/c/go/+/366494 Trust: Than McIntosh Trust: Dan Scales Reviewed-by: Dan Scales --- src/cmd/compile/internal/inline/inl.go | 15 ++++++++++----- test/closure3.dir/main.go | 8 ++++---- test/inline.go | 4 ++-- 3 files changed, 16 insertions(+), 11 deletions(-) diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go index 47b895f7e3..716a7fbcd9 100644 --- a/src/cmd/compile/internal/inline/inl.go +++ b/src/cmd/compile/internal/inline/inl.go @@ -1108,11 +1108,15 @@ func (subst *inlsubst) clovar(n *ir.Name) *ir.Name { // closure does the necessary substitions for a ClosureExpr n and returns the new // closure node. func (subst *inlsubst) closure(n *ir.ClosureExpr) ir.Node { - // Prior to the subst edit, set a flag in the inlsubst to - // indicated that we don't want to update the source positions in - // the new closure. If we do this, it will appear that the closure - // itself has things inlined into it, which is not the case. See - // issue #46234 for more details. + // Prior to the subst edit, set a flag in the inlsubst to indicate + // that we don't want to update the source positions in the new + // closure function. If we do this, it will appear that the + // closure itself has things inlined into it, which is not the + // case. See issue #46234 for more details. At the same time, we + // do want to update the position in the new ClosureExpr (which is + // part of the function we're working on). See #49171 for an + // example of what happens if we miss that update. + newClosurePos := subst.updatedPos(n.Pos()) defer func(prev bool) { subst.noPosUpdate = prev }(subst.noPosUpdate) subst.noPosUpdate = true @@ -1175,6 +1179,7 @@ func (subst *inlsubst) closure(n *ir.ClosureExpr) ir.Node { // Actually create the named function for the closure, now that // the closure is inlined in a specific function. newclo := newfn.OClosure + newclo.SetPos(newClosurePos) newclo.SetInit(subst.list(n.Init())) return typecheck.Expr(newclo) } diff --git a/test/closure3.dir/main.go b/test/closure3.dir/main.go index 662a2e967b..7ef0a47595 100644 --- a/test/closure3.dir/main.go +++ b/test/closure3.dir/main.go @@ -94,10 +94,10 @@ func main() { return x + 2 } y, sink = func() (func(int) int, int) { // ERROR "can inline main.func12" - return func(x int) int { // ERROR "func literal does not escape" "can inline main.func12" + return func(x int) int { // ERROR "can inline main.func12" return x + 1 }, 42 - }() // ERROR "inlining call to main.func12" + }() // ERROR "func literal does not escape" "inlining call to main.func12" if y(40) != 41 { ppanic("y(40) != 41") } @@ -109,10 +109,10 @@ func main() { return x + 2 } y, sink = func() (func(int) int, int) { // ERROR "can inline main.func13.2" - return func(x int) int { // ERROR "func literal does not escape" "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" + }() // ERROR "func literal does not escape" "inlining call to main.func13.2" if y(40) != 41 { ppanic("y(40) != 41") } diff --git a/test/inline.go b/test/inline.go index d0ebe84aa5..2780e10b19 100644 --- a/test/inline.go +++ b/test/inline.go @@ -92,9 +92,9 @@ func o() int { foo := func() int { return 1 } // ERROR "can inline o.func1" "func literal does not escape" func(x int) { // ERROR "can inline o.func2" if x > 10 { - foo = func() int { return 2 } // ERROR "func literal does not escape" "can inline o.func2" + foo = func() int { return 2 } // ERROR "can inline o.func2" } - }(11) // ERROR "inlining call to o.func2" + }(11) // ERROR "func literal does not escape" "inlining call to o.func2" return foo() } From 14f2b2a4c55b707828be2890b8c750cb849203f6 Mon Sep 17 00:00:00 2001 From: zhouguangyuan Date: Mon, 22 Nov 2021 23:39:52 +0800 Subject: [PATCH 287/752] cmd/internal/obj/x86: modify the threshold of assert loop for span6 Fixes: #49716 Change-Id: I7ed73f874c2ee1ee3f31c9c4428ed484167ca803 Reviewed-on: https://go-review.googlesource.com/c/go/+/366094 Reviewed-by: Cherry Mui Trust: Heschi Kreinick --- src/cmd/internal/obj/x86/asm6.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go index 6555756fd3..a508e484e4 100644 --- a/src/cmd/internal/obj/x86/asm6.go +++ b/src/cmd/internal/obj/x86/asm6.go @@ -2174,7 +2174,7 @@ func span6(ctxt *obj.Link, s *obj.LSym, newprog obj.ProgAlloc) { } n++ - if n > 20 { + if n > 1000 { ctxt.Diag("span must be looping") log.Fatalf("loop") } From b38ab0ac5f78ac03a38052018ff629c03e36b864 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Tue, 23 Nov 2021 18:03:47 -0500 Subject: [PATCH 288/752] cmd/internal/objfile, debug/gosym: use the address of runtime.text as textStart Tools like objdump uses the pcln table to find the line number of a given PC. For a PIE binary, at least in some cases such as on macOS 12 with ld64-711, the table contains unrelocated address, which does not match the address in the symbol table, causing the lookup to fail. In Go 1.18 the pcln table is essentually position independent, except the start PC. Instead of reading the static content from the table, use the PC of runtime.text from the symbol table. While here, change the type of textStart to uint64. What matters here is the word size of the target program, not the host, so it shouldn't be uintptr. Fixes #49700. Change-Id: I517d79be7ba02dd4dd0275e75a11a136b08d76cd Reviewed-on: https://go-review.googlesource.com/c/go/+/366695 Trust: Cherry Mui Run-TryBot: Cherry Mui TryBot-Result: Go Bot Reviewed-by: Than McIntosh --- src/cmd/internal/objfile/objfile.go | 9 +++++++++ src/debug/gosym/pclntab.go | 8 ++++---- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/src/cmd/internal/objfile/objfile.go b/src/cmd/internal/objfile/objfile.go index dcfd158ec2..d890a0b756 100644 --- a/src/cmd/internal/objfile/objfile.go +++ b/src/cmd/internal/objfile/objfile.go @@ -152,6 +152,15 @@ func (e *Entry) PCLineTable() (Liner, error) { if err != nil { return nil, err } + syms, err := e.raw.symbols() + if err == nil { + for _, s := range syms { + if s.Name == "runtime.text" { + textStart = s.Addr + break + } + } + } return gosym.NewTable(symtab, gosym.NewLineTable(pclntab, textStart)) } diff --git a/src/debug/gosym/pclntab.go b/src/debug/gosym/pclntab.go index a687c406b2..d9ae8b73a9 100644 --- a/src/debug/gosym/pclntab.go +++ b/src/debug/gosym/pclntab.go @@ -54,7 +54,7 @@ type LineTable struct { binary binary.ByteOrder quantum uint32 ptrsize uint32 - textStart uintptr // address of runtime.text symbol (1.18+) + textStart uint64 // address of runtime.text symbol (1.18+) funcnametab []byte cutab []byte funcdata []byte @@ -249,7 +249,7 @@ func (t *LineTable) parsePclnTab() { case ver118: t.nfunctab = uint32(offset(0)) t.nfiletab = uint32(offset(1)) - t.textStart = uintptr(offset(2)) + t.textStart = t.PC // use the start PC instead of reading from the table, which may be unrelocated t.funcnametab = data(3) t.cutab = data(4) t.filetab = data(5) @@ -402,7 +402,7 @@ func (f funcTab) Count() int { func (f funcTab) pc(i int) uint64 { u := f.uint(f.functab[2*i*f.sz:]) if f.version >= ver118 { - u += uint64(f.textStart) + u += f.textStart } return u } @@ -444,7 +444,7 @@ func (f *funcData) entryPC() uint64 { if f.t.version >= ver118 { // TODO: support multiple text sections. // See runtime/symtab.go:(*moduledata).textAddr. - return uint64(f.t.binary.Uint32(f.data)) + uint64(f.t.textStart) + return uint64(f.t.binary.Uint32(f.data)) + f.t.textStart } return f.t.uintptr(f.data) } From e883005d2ae5c9de0f3a072af53968da299bb8a8 Mon Sep 17 00:00:00 2001 From: Dmitri Shuralyov Date: Wed, 24 Nov 2021 11:05:51 -0500 Subject: [PATCH 289/752] doc/go1.18: document that iOS 12 or newer is required For #47694. Updates #49616. Updates #48076. Change-Id: I570564c3a54d3cd9cfc9b8267df9fbee3363b650 Reviewed-on: https://go-review.googlesource.com/c/go/+/366914 Trust: Dmitri Shuralyov Reviewed-by: Cherry Mui --- doc/go1.18.html | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 4175063edd..c6c338984c 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -105,6 +105,14 @@ proposal. now supports the c-archive and c-shared build modes.

    +

    iOS

    + +

    + On iOS (the ios/arm64 port) + and iOS simulator running on AMD64-based macOS (the ios/amd64 port), + Go 1.18 now requires iOS 12 or later; support for previous versions has been discontinued. +

    +

    Tools

    Go command

    From 4da06e7b00ae9965ec7d2f6f131266e44f966754 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Fri, 19 Nov 2021 16:09:52 -0500 Subject: [PATCH 290/752] cmd/go: fix bug in using the workfile flag with tests Tests do custom flag processing so we must process the workfile flag after that happens. Also fix an issue where errors weren't handled properly when the workfile wasn't absolute (the go command should just exit), and where a parse error was just dropped. Fixes #48576 Change-Id: I3a94d8d3a515114b2c4cc0e73f63447df2fc6bc9 Reviewed-on: https://go-review.googlesource.com/c/go/+/366174 Trust: Michael Matloob Run-TryBot: Michael Matloob TryBot-Result: Go Bot Reviewed-by: Bryan C. Mills --- src/cmd/go/internal/modload/init.go | 5 ++--- src/cmd/go/internal/test/test.go | 2 +- src/cmd/go/testdata/script/work_workfile.txt | 21 ++++++++++++++++++++ 3 files changed, 24 insertions(+), 4 deletions(-) create mode 100644 src/cmd/go/testdata/script/work_workfile.txt diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go index 30fe446e43..943547e71b 100644 --- a/src/cmd/go/internal/modload/init.go +++ b/src/cmd/go/internal/modload/init.go @@ -294,7 +294,7 @@ func InitWorkfile() { workFilePath = findWorkspaceFile(base.Cwd()) default: if !filepath.IsAbs(cfg.WorkFile) { - base.Errorf("the path provided to -workfile must be an absolute path") + base.Fatalf("the path provided to -workfile must be an absolute path") } workFilePath = cfg.WorkFile } @@ -590,9 +590,8 @@ func ReadWorkFile(path string) (*modfile.WorkFile, error) { if err != nil { return nil, err } - wf, err := modfile.ParseWork(path, workData, nil) - return wf, nil + return modfile.ParseWork(path, workData, nil) } // WriteWorkFile cleans and writes out the go.work file to the given path. diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go index b7bbcb4513..7ea9d4f1f1 100644 --- a/src/cmd/go/internal/test/test.go +++ b/src/cmd/go/internal/test/test.go @@ -619,8 +619,8 @@ var defaultVetFlags = []string{ } func runTest(ctx context.Context, cmd *base.Command, args []string) { - modload.InitWorkfile() pkgArgs, testArgs = testFlags(args) + modload.InitWorkfile() // The test command does custom flag processing; initialize workspaces after that. if cfg.DebugTrace != "" { var close func() error diff --git a/src/cmd/go/testdata/script/work_workfile.txt b/src/cmd/go/testdata/script/work_workfile.txt new file mode 100644 index 0000000000..b62918147e --- /dev/null +++ b/src/cmd/go/testdata/script/work_workfile.txt @@ -0,0 +1,21 @@ +! go list -workfile=stop.work a # require absolute path +! stderr panic +! go list -workfile=doesnotexist a +! stderr panic + +go list -n -workfile=$GOPATH/src/stop.work a +go build -n -workfile=$GOPATH/src/stop.work a +go test -n -workfile=$GOPATH/src/stop.work a + +-- stop.work -- +go 1.18 + +use ./a +-- a/a.go -- +package a +-- a/a_test.go -- +package a +-- a/go.mod -- +module a + +go 1.18 \ No newline at end of file From 5d8c49a5a13d922c24dc30675d64f0c49b676535 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 23 Nov 2021 12:02:40 -0800 Subject: [PATCH 291/752] spec: add definition of "specific types" of an interface The notion of specific types will be used to define rules for assignability, convertability, etc. when type parameters are involved. Change-Id: Ic5c134261e2a9fe05cdf25efd342f052458ab5c8 Reviewed-on: https://go-review.googlesource.com/c/go/+/366754 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 64 ++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 57 insertions(+), 7 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index ecd2f084c9..176e1a755d 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1,6 +1,6 @@ @@ -1290,8 +1290,8 @@ UnderlyingType = "~" Type .

    An interface type is specified by a list of interface elements. -An interface element is either a method or a type element, -where a type element is a union of one or more type terms. +An interface element is either a method or a type element, +where a type element is a union of one or more type terms. A type term is either a single type or a single underlying type.

    @@ -1926,7 +1926,60 @@ x T x is not representable by a value of T because 1e1000 float64 1e1000 overflows to IEEE +Inf after rounding -

    Structural interfaces

    +

    Structure of interfaces

    + +

    +An interface specification which contains type elements +that are not interface types defines a (possibly empty) set of specific types. +Loosely speaking, these are the types T that appear in the +interface definition in terms of the form T, ~T, +or in unions of such terms. +

    + +

    +More precisely, for a given interface, the set of specific types is defined as follows: +

    + +
      +
    • The set of specific types of the empty interface is the empty set. +
      • + +
    • The set of specific types of a non-empty interface is the intersection + of the specific types of its interface elements. +
      • + +
    • The set of specific types of a method specification is the empty set. +
      • + +
    • The set of specific types of a non-interface type term T + or ~T is the set consisting of the type T. +
      • + +
    • The set of specific types of a union of terms + t1|t2|…|tn + is the union of the specific types of the terms. +
      • +
    + +

    +If the set of specific types is empty, the interface has no specific types. +

    + +

    +Examples of interfaces with their specific types: +

    + +
    +type Celsius float32
+type Kelvin  float32
+
+interface{}                    // no specific types
+interface{ int }               // int
+interface{ ~string }           // string
+interface{ int|~string }       // int, string
+interface{ Celsius|Kelvin }    // Celsius, Kelvin
+interface{ int; string }       // no specific types (intersection is empty)
+

    An interface T is called structural if one of the following @@ -1966,9 +2019,6 @@ Examples of structural interfaces with their structural types: 

    -type Celsius float32
-type Kelvin  float32
-
 interface{ int }                          // int
 interface{ Celsius|Kelvin }               // float32
 interface{ ~chan int }                    // chan int

From 003e7faf53a3e7d0e280871447c60922bff89bcf Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sat, 20 Nov 2021 13:29:02 -0800
Subject: [PATCH 292/752] spec: adjust representability rules for type
 parameters

Change-Id: I4423a059527066c4418c195911f8184dfd3f5a15
Reviewed-on: https://go-review.googlesource.com/c/go/+/365914
Trust: Robert Griesemer 
Reviewed-by: Ian Lance Taylor 
---
 doc/go_spec.html | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 176e1a755d..186600f015 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1876,7 +1876,9 @@ by a value of type T.
 
 
    
 A constant x is representable
-by a value of type T if one of the following conditions applies:
+by a value of type T,
+where T is not a type parameter,
+if one of the following conditions applies:
 
    
 
 
      
@@ -1899,6 +1901,12 @@ are representable by values of T's component type (float32
 
    
 
+
    
+If T is a type parameter with specific types,
+x is representable by a value of type T if x is representable
+by a value of each specific type of T.
+
    
+
 
     x                   T           x is representable by a value of T because
 

From 939480033aa2c09f1b511a1928c0b465f41a45da Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Thu, 18 Nov 2021 16:11:10 -0800
Subject: [PATCH 293/752] spec: adjust assignability rules for type parameters

Change-Id: I3c4d8bdb5e92ee7fdca9593fb043f94f467755e8
Reviewed-on: https://go-review.googlesource.com/c/go/+/365434
Trust: Robert Griesemer 
Reviewed-by: Ian Lance Taylor 
---
 doc/go_spec.html | 42 +++++++++++++++++++++++++++++++++---------
 1 file changed, 33 insertions(+), 9 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 186600f015..904132adf0 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1848,21 +1848,22 @@ A value x is assignable to a variable
 
  • 
 x's type V and T have identical
-underlying types and at least one of V
-or T is not a defined type.
+underlying types and at least one of V
+or T is not a named type.
 
    • 
 
  • 
-T is an interface type and
+x's type V and T are channel types with
+identical element types, V is a bidirectional channel,
+and at least one of V or T is not a named type.
+
    • 
+
  • 
+T is an interface type, but not a type parameter, and
 x implements T.
 
    • 
 
  • 
-x is a bidirectional channel value, T is a channel type,
-x's type V and T have identical element types,
-and at least one of V or T is not a defined type.
-
    • 
-
  • 
 x is the predeclared identifier nil and T
-is a pointer, function, slice, map, channel, or interface type.
+is a pointer, function, slice, map, channel, or interface type,
+but not a type parameter.
 
    • 
 
  • 
 x is an untyped constant
@@ -1871,6 +1872,29 @@ by a value of type T.
 
    • 
 
 
+
    
+Additionally, if x's type V or T are type parameters
+with specific types, x
+is assignable to a variable of type T if one of the following conditions applies:
+
    
+
+
      
+
    • 
+x is the predeclared identifier nil, T is
+a type parameter, and x is assignable to each specific type of
+T.
+
      • 
+
    • 
+V is not a named type, T is
+a type parameter, and x is assignable to each specific type of
+T.
+
      • 
+
    • 
+V is a type parameter and T is not a named type,
+and values of each specific type of V are assignable
+to T.
+
      • 
+
    
 
 
    Representability
    
 

From ce2a20af467c8dfa10874abc4b45af413e2b1954 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sat, 20 Nov 2021 13:17:27 -0800
Subject: [PATCH 294/752] spec: adjust conversion rules for type parameters

Change-Id: I7bfddf4be0d1d95419f312bb349ae2e16b74b795
Reviewed-on: https://go-review.googlesource.com/c/go/+/365915
Trust: Robert Griesemer 
Reviewed-by: Ian Lance Taylor 
---
 doc/go_spec.html | 28 ++++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 904132adf0..d8e6bb7b8e 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -4633,7 +4633,9 @@ as for non-constant x.
 
    
 
 
    
-Converting a constant yields a typed constant as result.
+Converting a constant to a type that is not a type parameter
+yields a typed constant.
+Converting a constant to a type parameter yields a non-constant value of that type.	
 
    
 
 
    @@ -4669,7 +4671,7 @@ in any of these cases:
 	
  • 
 	ignoring struct tags (see below),
 	x's type and T are pointer types
-	that are not defined types,
+	that are not named types,
 	and their pointer base types have identical underlying types.
 	
    • 
 	
  • 
@@ -4692,6 +4694,28 @@ in any of these cases:
 	
    • 
 
 
+
    
+Additionally, if T or x's type V are type
+parameters with specific types, x
+can also be converted to type T if one of the following conditions applies:
+
    
+
+
      
+
    • 
+Both V and T are type parameters and a value of each
+specific type of V can be converted to each specific type
+of T.
+
      • 
+
    • 
+Only V is a type parameter and a value of each
+specific type of V can be converted to T.
+
      • 
+
    • 
+Only T is a type parameter and x can can be converted to each
+specific type of T.
+
      • 
+
    
+
 
    
 Struct tags are ignored when comparing struct types
 for identity for the purpose of conversion:

From a3b8f627c258f34325d2284ce636f8d4fb103331 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sat, 20 Nov 2021 14:35:02 -0800
Subject: [PATCH 295/752] spec: add section on instantiation

Change-Id: I2770da87b4c977b51dfa046f2f08283917675e1c
Reviewed-on: https://go-review.googlesource.com/c/go/+/365916
Trust: Robert Griesemer 
Trust: Dan Scales 
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Dan Scales 
---
 doc/go_spec.html | 90 ++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 88 insertions(+), 2 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index d8e6bb7b8e..6f30ed7b91 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -2913,13 +2913,19 @@ non-blank identifier denoting a
 or a parenthesized expression.
 
    
 
+
    
+An operand name denoting a type-parameterized function
+may be followed by a list of type arguments; the
+resulting operand is an instantiated function.
+
    
+
 
    
 The blank identifier may appear as an
 operand only on the left-hand side of an assignment.
 
    
 
 
    -Operand     = Literal | OperandName | "(" Expression ")" .
+Operand     = Literal | OperandName [ TypeArgs ] | "(" Expression ")" .
 Literal     = BasicLit | CompositeLit | FunctionLit .
 BasicLit    = int_lit | float_lit | imaginary_lit | rune_lit | string_lit .
 OperandName = identifier | QualifiedIdent .
@@ -2928,7 +2934,7 @@ OperandName = identifier | QualifiedIdent .
 
    Qualified identifiers
    
 
 
    
-A qualified identifier is an identifier qualified with a package name prefix.
+A qualified identifier is an identifier qualified with a package name prefix.
 Both the package name and the identifier must not be
 blank.
 
    
@@ -3962,6 +3968,11 @@ var pt *Point
 pt.Scale(3.5)     // method call with receiver pt
 
    
 
+
    
+If f denotes a parameterized function, it must be
+instantiated before it can be called.
+
    
+
 
    
 In a function call, the function value and arguments are evaluated in
 the usual order.
@@ -4073,6 +4084,81 @@ within Greeting, who will have the same value as 
 
+
    Instantiations
    
+
+
    
+A parameterized function or type is instantiated by substituting type arguments
+for the type parameters.
+Instantiation proceeds in two phases:
+
    
+
+
      
+
    1. 
+Each type argument is substituted for its corresponding type parameter in the parameterized
+declaration.
+This substitution happens across the entire function or type declaration,
+including the type parameter list itself and any types in that list.
+
      2. 
+
+
    2. 
+After substitution, each type argument must implement
+the constraint (instantiated, if necessary)
+of the corresponding type parameter. Otherwise instantiation fails.
+
      3. 
+
    
+
+
    
+Instantiating a type results in a new non-parameterized named type;
+instantiating a function produces a new non-parameterized function.
+
    
+
+
    +type parameter list    type arguments    after substitution
+
+[P any]                int               [int any]
+[S ~[]E, E any]        []int, int        [[]int ~[]int, int any]
+[P io.Writer]          string            [string io.Writer]         // illegal: string doesn't implement io.Writer
+
    
+
+
    
+Type arguments may be provided explicitly, or they may be partially or completely
+inferred.
+A partially provided type argument list cannot be empty; there must be at least the
+first argument.
+
    
+
+
    +type T[P1 ~int, P2 ~[]P1] struct{ … }
+
+T[]            // illegal: at least the first type argument must be present, even if it could be inferred
+T[int]         // argument for P1 explicitly provided, argument for P2 inferred
+T[int, []int]  // both arguments explicitly provided
+
    
+
+
    
+A partial type argument list specifies a prefix of the full list of type arguments, leaving
+the remaining arguments to be inferred. Loosely speaking, type arguments may be omitted from
+"right to left".
+
    
+
+
    
+Parameterized types, and parameterized functions that are not called,
+require a type argument list for instantiation; if the list is partial, all
+remaining type arguments must be inferrable.
+Calls to parameterized functions may provide a (possibly partial) type
+argument list, or may omit it entirely if the omitted type arguments are
+inferrable from the ordinary (non-type) function arguments.
+
    
+
+
    +func min[T constraints.Ordered](x, y T) T { … }
+
+f := min                   // illegal: min must be instantiated when used without being called
+minInt := min[int]         // minInt has type func(x, y int) int
+a := minInt(2, 3)          // a has value 2 of type int
+b := min[float64](2.0, 3)  // b has value 2.0 of type float64
+c := min(b, -1)            // c has value -1.0 of type float64
+
    
 
 
    Operators
    
 

From 6ea17aa52c5f66c1fd72b74c36f8036e17ddde34 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 23 Nov 2021 18:11:07 -0800
Subject: [PATCH 296/752] spec: adjust type identity rules for type parameters

Change-Id: I5ffc7f26236487070447eaa0f6b14d1fab44c3c7
Reviewed-on: https://go-review.googlesource.com/c/go/+/366794
Trust: Robert Griesemer 
Reviewed-by: Ian Lance Taylor 
---
 doc/go_spec.html | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 6f30ed7b91..0fc5b4590f 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1750,7 +1750,7 @@ Two types are either identical or different.
 
    
 
 
    
-A defined type is always different from any other type.
+A named type is always different from any other type.
 Otherwise, two types are identical if their underlying type literals are
 structurally equivalent; that is, they have the same literal structure and corresponding
 components have identical types. In detail:
@@ -1775,15 +1775,17 @@ components have identical types. In detail:
 	    identical, and either both functions are variadic or neither is.
 	    Parameter and result names are not required to match.
 
-	
  • Two interface types are identical if they have the same set of methods
-	    with the same names and identical function types.
-	    Non-exported method names from different
-	    packages are always different. The order of the methods is irrelevant.
    • 
+	
  • Two interface types are identical if they define the same type set.
+	
    • 
 
 	
  • Two map types are identical if they have identical key and element types.
    • 
 
 	
  • Two channel types are identical if they have identical element types and
 	    the same direction.
    • 
+
+	
  • Two instantiated types are identical if
+	    their defined types and all type arguments are identical.
+	
    • 
 
 
 
    
@@ -1798,18 +1800,18 @@ type (
 	A3 = int
 	A4 = func(A3, float64) *A0
 	A5 = func(x int, _ float64) *[]string
-)
 
-type (
 	B0 A0
 	B1 []string
 	B2 struct{ a, b int }
 	B3 struct{ a, c int }
 	B4 func(int, float64) *B0
 	B5 func(x int, y float64) *A1
-)
 
-type	C0 = B0
+	C0 = B0
+	D0[P1, P2 any] struct{ x P1; y P2 }
+	E0 = D0[int, string]
+)
 
    
 
 
    
@@ -1823,6 +1825,7 @@ A3 and int
 A4, func(int, float64) *[]string, and A5
 
 B0 and C0
+D0[int, string] and E0
 []int and []int
 struct{ a, b *T5 } and struct{ a, b *T5 }
 func(x int, y float64) *[]string, func(int, float64) (result *[]string), and A5
@@ -1832,7 +1835,13 @@ func(x int, y float64) *[]string, func(int, float64) (result *[]string), and A5
 B0 and B1 are different because they are new types
 created by distinct type definitions;
 func(int, float64) *B0 and func(x int, y float64) *[]string
-are different because B0 is different from []string.
+are different because B0 is different from []string;
+and P1 and P2 are different because they are different
+type parameters.
+D0[int, string] and struct{ x int; y string } are
+different because the former is an instantiated
+defined type while the latter is a type literal
+(but they are still assignable).
 
    
 
 
    Assignability
    

From 696515ee396566ba02da145cf71fe5913d65b9a6 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 23 Nov 2021 20:56:33 -0800
Subject: [PATCH 297/752] spec: type assertions and switches don't operate on
 type parameters

Change-Id: I11111b3617673be94508128489aed6488d518537
Reviewed-on: https://go-review.googlesource.com/c/go/+/366834
Trust: Robert Griesemer 
Reviewed-by: Ian Lance Taylor 
---
 doc/go_spec.html | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 0fc5b4590f..b8e6aceee9 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -3884,8 +3884,9 @@ If the indices are out of range at run time, a run-ti
 
    Type assertions
    
 
 
    
-For an expression x of interface type
-and a type T, the primary expression
+For an expression x of interface type,
+but not a type parameter, and a type T,
+the primary expression
 
    
 
 
    @@ -5677,7 +5678,8 @@ switch x.(type) {
 
    
 Cases then match actual types T against the dynamic type of the
 expression x. As with type assertions, x must be of
-interface type, and each non-interface type
+interface type, but not a
+type parameter, and each non-interface type
 T listed in a case must implement the type of x.
 The types listed in the cases of a type switch must all be
 different.

From 9e7600d3fccf1920028bc808c755198db73482c0 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Mon, 22 Nov 2021 16:04:17 -0800
Subject: [PATCH 298/752] go/types: print "nil" rather than "untyped nil"

This is a port of CL 366276 from types2 to go/types
with minor adjustments due to the slightly different
handling of nil in go/types.

It uses some more detailed error strings in stmt0.src;
the same changes are made to the corresponding types2
file.

For #48852.

Change-Id: I2cdf258799bcbe2d12bbadaf67b8b4504b356bd0
Reviewed-on: https://go-review.googlesource.com/c/go/+/366277
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 .../internal/types2/testdata/check/stmt0.src   |  6 +++---
 src/go/types/operand.go                        |  5 +++++
 src/go/types/testdata/check/stmt0.src          |  6 +++---
 src/go/types/testdata/fixedbugs/issue49296.go2 |  2 +-
 src/go/types/testdata/spec/assignability.go2   | 18 +++++++++---------
 5 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/src/cmd/compile/internal/types2/testdata/check/stmt0.src b/src/cmd/compile/internal/types2/testdata/check/stmt0.src
index 353444f068..8171c57d8b 100644
--- a/src/cmd/compile/internal/types2/testdata/check/stmt0.src
+++ b/src/cmd/compile/internal/types2/testdata/check/stmt0.src
@@ -69,10 +69,10 @@ func assignments1() {
 
 	// test cases for issue 5800
 	var (
-		_ int = nil /* ERROR "nil" */
-		_ [10]int = nil /* ERROR "nil" */
+		_ int = nil /* ERROR "cannot use nil as int value in variable declaration" */
+		_ [10]int = nil /* ERROR "cannot use nil as \[10\]int value in variable declaration" */
 		_ []byte = nil
-		_ struct{} = nil /* ERROR "nil" */
+		_ struct{} = nil /* ERROR "cannot use nil as struct{} value in variable declaration" */
 		_ func() = nil
 		_ map[int]string = nil
 		_ chan int = nil
diff --git a/src/go/types/operand.go b/src/go/types/operand.go
index 8cc5eda866..c35b1650be 100644
--- a/src/go/types/operand.go
+++ b/src/go/types/operand.go
@@ -105,6 +105,11 @@ func (x *operand) Pos() token.Pos {
 // cgofunc     (                      of type )
 //
 func operandString(x *operand, qf Qualifier) string {
+	// special-case nil
+	if x.mode == value && x.typ == Typ[UntypedNil] {
+		return "nil"
+	}
+
 	var buf bytes.Buffer
 
 	var expr string
diff --git a/src/go/types/testdata/check/stmt0.src b/src/go/types/testdata/check/stmt0.src
index 15df37703c..2cce0b59b2 100644
--- a/src/go/types/testdata/check/stmt0.src
+++ b/src/go/types/testdata/check/stmt0.src
@@ -69,10 +69,10 @@ func assignments1() {
 
 	// test cases for issue 5800
 	var (
-		_ int = nil /* ERROR "untyped nil value" */
-		_ [10]int = nil /* ERROR "untyped nil value" */
+		_ int = nil /* ERROR "cannot use nil as int value in variable declaration" */
+		_ [10]int = nil /* ERROR "cannot use nil as \[10\]int value in variable declaration" */
 		_ []byte = nil
-		_ struct{} = nil /* ERROR "untyped nil value" */
+		_ struct{} = nil /* ERROR "cannot use nil as struct{} value in variable declaration" */
 		_ func() = nil
 		_ map[int]string = nil
 		_ chan int = nil
diff --git a/src/go/types/testdata/fixedbugs/issue49296.go2 b/src/go/types/testdata/fixedbugs/issue49296.go2
index 8c6d0b678d..0ad71ef4b2 100644
--- a/src/go/types/testdata/fixedbugs/issue49296.go2
+++ b/src/go/types/testdata/fixedbugs/issue49296.go2
@@ -10,7 +10,7 @@ func _[
         T2 ~float64 | ~complex128 | chan int,
 ]() {
 	// TODO(rfindley): the types2 error here is clearer.
-        _ = T0(nil /* ERROR cannot convert nil \(untyped nil value\) to T0 */ )
+        _ = T0(nil /* ERROR cannot convert nil to T0 */ )
         _ = T1(1 /* ERROR cannot convert 1 .* to T1 */ )
         _ = T2(2 /* ERROR cannot convert 2 .* to T2 */ )
 }
diff --git a/src/go/types/testdata/spec/assignability.go2 b/src/go/types/testdata/spec/assignability.go2
index a6e71aac81..d5f6ab4419 100644
--- a/src/go/types/testdata/spec/assignability.go2
+++ b/src/go/types/testdata/spec/assignability.go2
@@ -155,28 +155,28 @@ func _[
 // TODO(rfindley) error messages about untyped nil diverge from types2 here.
 // Consider aligning them.
 func _[TP Interface](X TP) {
-	b = nil // ERROR cannot use.*untyped nil
-	a = nil // ERROR cannot use.*untyped nil
+	b = nil // ERROR cannot use nil
+	a = nil // ERROR cannot use nil
 	l = nil
-	s = nil // ERROR cannot use.*untyped nil
+	s = nil // ERROR cannot use nil
 	p = nil
 	f = nil
 	i = nil
 	m = nil
 	c = nil
-	d = nil // ERROR cannot use.*untyped nil
+	d = nil // ERROR cannot use nil
 
-	B = nil // ERROR cannot use.*untyped nil
-	A = nil // ERROR cannot use.*untyped nil
+	B = nil // ERROR cannot use nil
+	A = nil // ERROR cannot use nil
 	L = nil
-	S = nil // ERROR cannot use.*untyped nil
+	S = nil // ERROR cannot use nil
 	P = nil
 	F = nil
 	I = nil
 	M = nil
 	C = nil
-	D = nil // ERROR cannot use.*untyped nil
-	X = nil // ERROR cannot use.*untyped nil
+	D = nil // ERROR cannot use nil
+	X = nil // ERROR cannot use nil
 }
 
 // "x is an untyped constant representable by a value of type T"

From c25bf0d959c299e5fa5392ae6f835570ed6d111f Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Wed, 17 Nov 2021 15:23:12 -0800
Subject: [PATCH 299/752] cmd/compile/internal/types2: report types for
 mismatched call and return statements

Thanks to emmanuel@orijtech.com who wrote the initial version of
this change (CL 354490).

This change is following CL 354490 in idea but also contains various
simplifications, slightly improved printing of signature/type patterns,
adjustments for types2, and some fine-tuning of error positions.

Also adjusted several ERROR regexp patterns.

Fixes #48834.
Fixes #48835.

Change-Id: I31cf20c81753b1dc84836dbe83a39030ceb9db23
Reviewed-on: https://go-review.googlesource.com/c/go/+/364874
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
Reviewed-by: Emmanuel Odeke 
---
 .../compile/internal/types2/assignments.go    | 81 +++++++++++++++++--
 src/cmd/compile/internal/types2/call.go       | 25 ++++--
 src/cmd/compile/internal/types2/decl.go       |  2 +-
 src/cmd/compile/internal/types2/stmt.go       |  2 +-
 .../types2/testdata/check/builtins.src        |  2 +-
 .../internal/types2/testdata/check/errors.src | 28 ++++---
 .../internal/types2/testdata/check/expr3.src  | 14 ++--
 .../internal/types2/testdata/check/stmt0.src  | 16 ++--
 .../types2/testdata/check/typeparams.go2      |  2 +-
 .../types2/testdata/check/vardecl.src         |  2 +-
 test/fixedbugs/bug326.go                      |  2 +-
 test/fixedbugs/issue4215.go                   | 20 ++---
 test/fixedbugs/issue46957.go                  |  2 +-
 test/fixedbugs/issue48834.go                  | 24 ++++++
 test/fixedbugs/issue48835.go                  | 25 ++++++
 15 files changed, 190 insertions(+), 57 deletions(-)
 create mode 100644 test/fixedbugs/issue48834.go
 create mode 100644 test/fixedbugs/issue48835.go

diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index ac4f7b88a4..0a85d8eb39 100644
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -9,6 +9,7 @@ package types2
 import (
 	"cmd/compile/internal/syntax"
 	"fmt"
+	"strings"
 )
 
 // assignment reports whether x can be assigned to a variable of type T,
@@ -241,6 +242,58 @@ func (check *Checker) assignVar(lhs syntax.Expr, x *operand) Type {
 	return x.typ
 }
 
+// operandTypes returns the list of types for the given operands.
+func operandTypes(list []*operand) (res []Type) {
+	for _, x := range list {
+		res = append(res, x.typ)
+	}
+	return res
+}
+
+// varTypes returns the list of types for the given variables.
+func varTypes(list []*Var) (res []Type) {
+	for _, x := range list {
+		res = append(res, x.typ)
+	}
+	return res
+}
+
+// typesSummary returns a string of the form "(t1, t2, ...)" where the
+// ti's are user-friendly string representations for the given types.
+// If variadic is set and the last type is a slice, its string is of
+// the form "...E" where E is the slice's element type.
+func (check *Checker) typesSummary(list []Type, variadic bool) string {
+	var res []string
+	for i, t := range list {
+		var s string
+		switch {
+		case t == nil:
+			fallthrough // should not happend but be cautious
+		case t == Typ[Invalid]:
+			s = ""
+		case isUntyped(t):
+			if isNumeric(t) {
+				// Do not imply a specific type requirement:
+				// "have number, want float64" is better than
+				// "have untyped int, want float64" or
+				// "have int, want float64".
+				s = "number"
+			} else {
+				// If we don't have a number, omit the "untyped" qualifier
+				// for compactness.
+				s = strings.Replace(t.(*Basic).name, "untyped ", "", -1)
+			}
+		case variadic && i == len(list)-1:
+			s = check.sprintf("...%s", t.(*Slice).elem)
+		}
+		if s == "" {
+			s = check.sprintf("%s", t)
+		}
+		res = append(res, s)
+	}
+	return "(" + strings.Join(res, ", ") + ")"
+}
+
 func (check *Checker) assignError(rhs []syntax.Expr, nvars, nvals int) {
 	measure := func(x int, unit string) string {
 		s := fmt.Sprintf("%d %s", x, unit)
@@ -263,10 +316,10 @@ func (check *Checker) assignError(rhs []syntax.Expr, nvars, nvals int) {
 	check.errorf(rhs0, "assignment mismatch: %s but %s", vars, vals)
 }
 
-// If returnPos is valid, initVars is called to type-check the assignment of
-// return expressions, and returnPos is the position of the return statement.
-func (check *Checker) initVars(lhs []*Var, orig_rhs []syntax.Expr, returnPos syntax.Pos) {
-	rhs, commaOk := check.exprList(orig_rhs, len(lhs) == 2 && !returnPos.IsKnown())
+// If returnStmt != nil, initVars is called to type-check the assignment
+// of return expressions, and returnStmt is the the return statement.
+func (check *Checker) initVars(lhs []*Var, orig_rhs []syntax.Expr, returnStmt syntax.Stmt) {
+	rhs, commaOk := check.exprList(orig_rhs, len(lhs) == 2 && returnStmt == nil)
 
 	if len(lhs) != len(rhs) {
 		// invalidate lhs
@@ -282,8 +335,20 @@ func (check *Checker) initVars(lhs []*Var, orig_rhs []syntax.Expr, returnPos syn
 				return
 			}
 		}
-		if returnPos.IsKnown() {
-			check.errorf(returnPos, "wrong number of return values (want %d, got %d)", len(lhs), len(rhs))
+		if returnStmt != nil {
+			var at poser = returnStmt
+			qualifier := "not enough"
+			if len(rhs) > len(lhs) {
+				at = rhs[len(lhs)].expr // report at first extra value
+				qualifier = "too many"
+			} else if len(rhs) > 0 {
+				at = rhs[len(rhs)-1].expr // report at last value
+			}
+			var err error_
+			err.errorf(at, "%s return values", qualifier)
+			err.errorf(nopos, "have %s", check.typesSummary(operandTypes(rhs), false))
+			err.errorf(nopos, "want %s", check.typesSummary(varTypes(lhs), false))
+			check.report(&err)
 			return
 		}
 		if check.conf.CompilerErrorMessages {
@@ -295,7 +360,7 @@ func (check *Checker) initVars(lhs []*Var, orig_rhs []syntax.Expr, returnPos syn
 	}
 
 	context := "assignment"
-	if returnPos.IsKnown() {
+	if returnStmt != nil {
 		context = "return statement"
 	}
 
@@ -449,7 +514,7 @@ func (check *Checker) shortVarDecl(pos syntax.Pos, lhs, rhs []syntax.Expr) {
 		}
 	}
 
-	check.initVars(lhsVars, rhs, nopos)
+	check.initVars(lhsVars, rhs, nil)
 
 	// process function literals in rhs expressions before scope changes
 	check.processDelayed(top)
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 4e2c2a2989..91e2a8f783 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -350,12 +350,25 @@ func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, targs []T
 	}
 
 	// check argument count
-	switch {
-	case nargs < npars:
-		check.errorf(call, "not enough arguments in call to %s", call.Fun)
-		return
-	case nargs > npars:
-		check.errorf(args[npars], "too many arguments in call to %s", call.Fun) // report at first extra argument
+	if nargs != npars {
+		var at poser = call
+		qualifier := "not enough"
+		if nargs > npars {
+			at = args[npars].expr // report at first extra argument
+			qualifier = "too many"
+		} else if nargs > 0 {
+			at = args[nargs-1].expr // report at last argument
+		}
+		// take care of empty parameter lists represented by nil tuples
+		var params []*Var
+		if sig.params != nil {
+			params = sig.params.vars
+		}
+		var err error_
+		err.errorf(at, "%s arguments in call to %s", qualifier, call.Fun)
+		err.errorf(nopos, "have %s", check.typesSummary(operandTypes(args), false))
+		err.errorf(nopos, "want %s", check.typesSummary(varTypes(params), sig.variadic))
+		check.report(&err)
 		return
 	}
 
diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go
index 4b79c59af3..a4bc3969c0 100644
--- a/src/cmd/compile/internal/types2/decl.go
+++ b/src/cmd/compile/internal/types2/decl.go
@@ -549,7 +549,7 @@ func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init syntax.Expr) {
 		}
 	}
 
-	check.initVars(lhs, []syntax.Expr{init}, nopos)
+	check.initVars(lhs, []syntax.Expr{init}, nil)
 }
 
 // isImportedConstraint reports whether typ is an imported type constraint.
diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index 44d9256c50..ab64882c02 100644
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -493,7 +493,7 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) {
 				}
 			} else {
 				// return has results or result parameters are unnamed
-				check.initVars(res.vars, results, s.Pos())
+				check.initVars(res.vars, results, s)
 			}
 		} else if len(results) > 0 {
 			check.error(results[0], "no result values expected")
diff --git a/src/cmd/compile/internal/types2/testdata/check/builtins.src b/src/cmd/compile/internal/types2/testdata/check/builtins.src
index 17e4068d65..de27f5c632 100644
--- a/src/cmd/compile/internal/types2/testdata/check/builtins.src
+++ b/src/cmd/compile/internal/types2/testdata/check/builtins.src
@@ -25,7 +25,7 @@ func append1() {
 	_ = append(s, b)
 	_ = append(s, x /* ERROR cannot use x */ )
 	_ = append(s, s /* ERROR cannot use s */ )
-	_ = append(s... ) /* ERROR not enough arguments */
+	_ = append(s /* ERROR not enough arguments */ ...)
 	_ = append(s, b, s /* ERROR too many arguments */ ... )
 	_ = append(s, 1, 2, 3)
 	_ = append(s, 1, 2, 3, x /* ERROR cannot use x */ , 5, 6, 6)
diff --git a/src/cmd/compile/internal/types2/testdata/check/errors.src b/src/cmd/compile/internal/types2/testdata/check/errors.src
index ff929217c4..5f09197bde 100644
--- a/src/cmd/compile/internal/types2/testdata/check/errors.src
+++ b/src/cmd/compile/internal/types2/testdata/check/errors.src
@@ -8,32 +8,38 @@ package errors
 // (matching messages are regular expressions, hence the \'s).
 func f(x int, m map[string]int) {
 	// no values
-	_ = f /* ERROR "f\(0, m\) \(no value\) used as value" */ (0, m)
+	_ = f /* ERROR f\(0, m\) \(no value\) used as value */ (0, m)
 
 	// built-ins
-	_ = println /* ERROR "println \(built-in\) must be called" */
+	_ = println // ERROR println \(built-in\) must be called
 
 	// types
-	_ = complex128 /* ERROR "complex128 \(type\) is not an expression" */
+	_ = complex128 // ERROR complex128 \(type\) is not an expression
 
 	// constants
 	const c1 = 991
 	const c2 float32 = 0.5
-	0 /* ERROR "0 \(untyped int constant\) is not used" */
-	c1 /* ERROR "c1 \(untyped int constant 991\) is not used" */
-	c2 /* ERROR "c2 \(constant 0.5 of type float32\) is not used" */
-	c1 /* ERROR "c1 \+ c2 \(constant 991.5 of type float32\) is not used" */ + c2
+	const c3 = "foo"
+	0 // ERROR 0 \(untyped int constant\) is not used
+	0.5 // ERROR 0.5 \(untyped float constant\) is not used
+	"foo" // ERROR "foo" \(untyped string constant\) is not used
+	c1 // ERROR c1 \(untyped int constant 991\) is not used
+	c2 // ERROR c2 \(constant 0.5 of type float32\) is not used
+	c1 /* ERROR c1 \+ c2 \(constant 991.5 of type float32\) is not used */ + c2
+	c3 // ERROR c3 \(untyped string constant "foo"\) is not used
 
 	// variables
-	x /* ERROR "x \(variable of type int\) is not used" */
+	x // ERROR x \(variable of type int\) is not used
 
 	// values
-	x /* ERROR "x != x \(untyped bool value\) is not used" */ != x
-	x /* ERROR "x \+ x \(value of type int\) is not used" */ + x
+	nil // ERROR nil is not used
+	(*int)(nil) // ERROR \(\*int\)\(nil\) \(value of type \*int\) is not used
+	x /* ERROR x != x \(untyped bool value\) is not used */ != x
+	x /* ERROR x \+ x \(value of type int\) is not used */ + x
 
 	// value, ok's
 	const s = "foo"
-	m /* ERROR "m\[s\] \(map index expression of type int\) is not used" */ [s]
+	m /* ERROR m\[s\] \(map index expression of type int\) is not used */ [s]
 }
 
 // Valid ERROR comments can have a variety of forms.
diff --git a/src/cmd/compile/internal/types2/testdata/check/expr3.src b/src/cmd/compile/internal/types2/testdata/check/expr3.src
index 0d7bbae9f9..646319e4c4 100644
--- a/src/cmd/compile/internal/types2/testdata/check/expr3.src
+++ b/src/cmd/compile/internal/types2/testdata/check/expr3.src
@@ -494,23 +494,23 @@ func _calls() {
 	f1(0)
 	f1(x)
 	f1(10.0)
-	f1() /* ERROR "not enough arguments" */
-	f1(x, y /* ERROR "too many arguments" */ )
+	f1 /* ERROR "not enough arguments in call to f1\n\thave \(\)\n\twant \(int\)" */ ()
+	f1(x, y /* ERROR "too many arguments in call to f1\n\thave \(int, float32\)\n\twant \(int\)" */ )
 	f1(s /* ERROR "cannot use .* in argument" */ )
 	f1(x ... /* ERROR "cannot use ..." */ )
 	f1(g0 /* ERROR "used as value" */ ())
 	f1(g1())
-	f1(g2 /* ERROR "too many arguments" */ ())
+	f1(g2 /* ERROR "too many arguments in call to f1\n\thave \(float32, string\)\n\twant \(int\)" */ ())
 
-	f2() /* ERROR "not enough arguments" */
-	f2(3.14) /* ERROR "not enough arguments" */
+	f2 /* ERROR "not enough arguments in call to f2\n\thave \(\)\n\twant \(float32, string\)" */ ()
+	f2(3.14 /* ERROR "not enough arguments in call to f2\n\thave \(number\)\n\twant \(float32, string\)" */ )
 	f2(3.14, "foo")
 	f2(x /* ERROR "cannot use .* in argument" */ , "foo")
 	f2(g0 /* ERROR "used as value" */ ())
-	f2(g1()) /* ERROR "not enough arguments" */
+	f2(g1 /* ERROR "not enough arguments in call to f2\n\thave \(int\)\n\twant \(float32, string\)" */ ())
 	f2(g2())
 
-	fs() /* ERROR "not enough arguments" */
+	fs /* ERROR "not enough arguments" */ ()
 	fs(g0 /* ERROR "used as value" */ ())
 	fs(g1 /* ERROR "cannot use .* in argument" */ ())
 	fs(g2 /* ERROR "too many arguments" */ ())
diff --git a/src/cmd/compile/internal/types2/testdata/check/stmt0.src b/src/cmd/compile/internal/types2/testdata/check/stmt0.src
index 8171c57d8b..8b18d676ac 100644
--- a/src/cmd/compile/internal/types2/testdata/check/stmt0.src
+++ b/src/cmd/compile/internal/types2/testdata/check/stmt0.src
@@ -29,10 +29,10 @@ func assignments0() (int, int) {
 
 	a, b, c = <- /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ ch
 
-	return /* ERROR "wrong number of return values" */
-	return /* ERROR "wrong number of return values" */ 1
+	return /* ERROR "not enough return values\n\thave \(\)\n\twant \(int, int\)" */
+	return 1 /* ERROR "not enough return values\n\thave \(number\)\n\twant \(int, int\)" */
 	return 1, 2
-	return /* ERROR "wrong number of return values" */ 1, 2, 3
+	return 1, 2, 3 /* ERROR "too many return values\n\thave \(number, number, number\)\n\twant \(int, int\)" */
 }
 
 func assignments1() {
@@ -81,12 +81,12 @@ func assignments1() {
 	// test cases for issue 5500
 	_ = func() (int, bool) {
 		var m map[int]int
-		return /* ERROR "wrong number of return values" */ m[0]
+		return m /* ERROR "not enough return values" */ [0]
 	}
 
 	g := func(int, bool){}
 	var m map[int]int
-	g(m[0]) /* ERROR "not enough arguments" */
+	g(m /* ERROR "not enough arguments" */ [0])
 
 	// assignments to _
 	_ = nil /* ERROR "use of untyped nil" */
@@ -380,15 +380,15 @@ func returns0() {
 
 func returns1(x float64) (int, *float64) {
 	return 0, &x
-	return /* ERROR wrong number of return values */
+	return /* ERROR not enough return values */
 	return "foo" /* ERROR "cannot .* in return statement" */, x /* ERROR "cannot use .* in return statement" */
-	return /* ERROR wrong number of return values */ 0, &x, 1
+	return 0, &x, 1 /* ERROR too many return values */
 }
 
 func returns2() (a, b int) {
 	return
 	return 1, "foo" /* ERROR cannot use .* in return statement */
-	return /* ERROR wrong number of return values */ 1, 2, 3
+	return 1, 2, 3 /* ERROR too many return values */
 	{
 		type a int
 		return 1, 2
diff --git a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
index d72cf078a7..007157ea0f 100644
--- a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
+++ b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2
@@ -312,7 +312,7 @@ var _ = f7(1.2, 3 /* ERROR does not match */ )
 
 func f8[A, B any](A, B, ...B) int { panic(0) }
 
-var _ = f8(1) /* ERROR not enough arguments */
+var _ = f8(1 /* ERROR not enough arguments */ )
 var _ = f8(1, 2.3)
 var _ = f8(1, 2.3, 3.4, 4.5)
 var _ = f8(1, 2.3, 3.4, 4 /* ERROR does not match */ )
diff --git a/src/cmd/compile/internal/types2/testdata/check/vardecl.src b/src/cmd/compile/internal/types2/testdata/check/vardecl.src
index 9e48cdf847..827b9b9d69 100644
--- a/src/cmd/compile/internal/types2/testdata/check/vardecl.src
+++ b/src/cmd/compile/internal/types2/testdata/check/vardecl.src
@@ -183,7 +183,7 @@ func _() {
 
 func _() int {
 	var x, y int
-	return /* ERROR wrong number of return values */ x, y
+	return x, y /* ERROR too many return values */
 }
 
 // Short variable declarations must declare at least one new non-blank variable.
diff --git a/test/fixedbugs/bug326.go b/test/fixedbugs/bug326.go
index dfd8be8005..74e06f39d7 100644
--- a/test/fixedbugs/bug326.go
+++ b/test/fixedbugs/bug326.go
@@ -19,7 +19,7 @@ func h() (_ int, _ error) {
 }
 
 func i() (int, error) {
-	return // ERROR "not enough arguments to return|wrong number of return values"
+	return // ERROR "not enough return values|not enough arguments to return"
 }
 
 func f1() (_ int, err error) {
diff --git a/test/fixedbugs/issue4215.go b/test/fixedbugs/issue4215.go
index 7201591f3f..b6ece4bf21 100644
--- a/test/fixedbugs/issue4215.go
+++ b/test/fixedbugs/issue4215.go
@@ -7,7 +7,7 @@
 package main
 
 func foo() (int, int) {
-	return 2.3 // ERROR "not enough arguments to return\n\thave \(number\)\n\twant \(int, int\)|not enough arguments to return|wrong number of return values"
+	return 2.3 // ERROR "not enough return values\n\thave \(number\)\n\twant \(int, int\)|not enough arguments to return"
 }
 
 func foo2() {
@@ -16,19 +16,19 @@ func foo2() {
 
 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\)|not enough arguments to return|wrong number of return values"
+		return 1 // ERROR "not enough return values\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\)|not enough arguments to return|wrong number of return values"
+	return 2, 3 // ERROR "not enough return values\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\)|not enough arguments to return|wrong number of return values"
+		return "moo" // ERROR "not enough return values\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\)|too many values in return statement|wrong number of return values"
+		return "dog", 10, true // ERROR "too many return values\n\thave \(string, number, bool\)\n\twant \(string, int\)|too many arguments to return"
 	case "fish":
-		return "" // ERROR "not enough arguments to return\n\thave \(string\)\n\twant \(string, int\)|not enough arguments to return|wrong number of return values"
+		return "" // ERROR "not enough return values\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\)|not enough arguments to return|wrong number of return values"
+		return "" // ERROR "not enough return values\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\)|not enough arguments to return|wrong number of return values"
+		return ptr // ERROR "not enough return values\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\)|too many values in return statement|wrong number of return values"
+	return new(S), 12.34, 1 + 0i, 'r', true // ERROR "too many return values\n\thave \(\*S, number, number, number, bool\)\n\twant \(S, T, U\)|too many arguments to return"
 }
 
 func foo6() (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|wrong number of return values"
+	return "T", true, true // ERROR "too many return values\n\thave \(string, bool, bool\)\n\twant \(T, string\)|too many arguments to return"
 }
diff --git a/test/fixedbugs/issue46957.go b/test/fixedbugs/issue46957.go
index f3ed3c3def..6c1c0fe0c2 100644
--- a/test/fixedbugs/issue46957.go
+++ b/test/fixedbugs/issue46957.go
@@ -9,5 +9,5 @@ package main
 func f(a int, b ...int) {}
 
 func main() {
-	f(nil...) // ERROR "not enough arguments in call to f$"
+	f(nil...) // ERROR "not enough arguments in call to f\n\thave \(nil\)\n\twant \(int, \[\]int\)|not enough arguments"
 }
diff --git a/test/fixedbugs/issue48834.go b/test/fixedbugs/issue48834.go
new file mode 100644
index 0000000000..cf97d132c3
--- /dev/null
+++ b/test/fixedbugs/issue48834.go
@@ -0,0 +1,24 @@
+// 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
+
+func _() (int, error) {
+	return 1 // ERROR "not enough (arguments to return|return values)\n\thave \(number\)\n\twant \(int, error\)"
+}
+
+func _() (int, error) {
+	var x int
+	return x // ERROR "not enough (arguments to return|return values)\n\thave \(int\)\n\twant \(int, error\)"
+}
+
+func _() int {
+	return 1, 2 // ERROR "too many (arguments to return|return values)\n\thave \(number, number\)\n\twant \(int\)"
+}
+
+func _() {
+	return 1 // ERROR "too many arguments to return\n\thave \(number\)\n\twant \(\)|no result values expected"
+}
diff --git a/test/fixedbugs/issue48835.go b/test/fixedbugs/issue48835.go
new file mode 100644
index 0000000000..c000f8357d
--- /dev/null
+++ b/test/fixedbugs/issue48835.go
@@ -0,0 +1,25 @@
+// 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
+
+func f0()
+func f1(_ int)
+func f2(_, _ int)
+func f2ddd(_, _ int, _ ...int)
+
+func f() {
+	var x int
+	f0(1)              // ERROR "too many arguments in call to f0\n\thave \(number\)\n\twant \(\)"
+	f0(x)              // ERROR "too many arguments in call to f0\n\thave \(int\)\n\twant \(\)"
+	f1()               // ERROR "not enough arguments in call to f1\n\thave \(\)\n\twant \(int\)"
+	f1(1, 2)           // ERROR "too many arguments in call to f1\n\thave \(number, number\)\n\twant \(int\)"
+	f2(1)              // ERROR "not enough arguments in call to f2\n\thave \(number\)\n\twant \(int, int\)"
+	f2(1, "foo", true) // ERROR "too many arguments in call to f2\n\thave \(number, string, bool\)\n\twant \(int, int\)"
+	f2ddd(1)           // ERROR "not enough arguments in call to f2ddd\n\thave \(number\)\n\twant \(int, int, \.\.\.int\)"
+	f2ddd(1, 2)
+	f2ddd(1, 2, 3)
+}

From 67dd9ee92c454ded14f117e2d958db9ee56e8b02 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Mon, 22 Nov 2021 19:02:56 -0800
Subject: [PATCH 300/752] cmd/compile/internal/types2: produce empty type set
 for invalid ~T

If ~T is not permitted because the underlying type of T is not the
same as T, there is no type that satisfies ~T. Besides reporting an
error, also ensure that the corresponding type set is empty.

For #49739.

Change-Id: I127f75f170902e7989f7fe7b352dabda9f72e2a5
Reviewed-on: https://go-review.googlesource.com/c/go/+/366278
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 .../types2/testdata/fixedbugs/issue49739.go2  | 23 +++++++++++++++++++
 src/cmd/compile/internal/types2/typeset.go    | 16 ++++++++-----
 2 files changed, 33 insertions(+), 6 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue49739.go2

diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49739.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49739.go2
new file mode 100644
index 0000000000..46b1e71a3b
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49739.go2
@@ -0,0 +1,23 @@
+// 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.
+
+// Verify that we get an empty type set (not just an error)
+// when using an invalid ~A.
+
+package p
+
+type A int
+type C interface {
+	~ /* ERROR invalid use of ~ */ A
+}
+
+func f[_ C]()              {}
+func g[_ interface{ C }]() {}
+func h[_ C | int]()        {}
+
+func _() {
+	_ = f[int /* ERROR cannot implement C \(empty type set\) */]
+	_ = g[int /* ERROR cannot implement interface{C} \(empty type set\) */]
+	_ = h[int]
+}
diff --git a/src/cmd/compile/internal/types2/typeset.go b/src/cmd/compile/internal/types2/typeset.go
index 54a8266838..a55e9d1d63 100644
--- a/src/cmd/compile/internal/types2/typeset.go
+++ b/src/cmd/compile/internal/types2/typeset.go
@@ -367,14 +367,18 @@ func computeUnionTypeSet(check *Checker, pos syntax.Pos, utyp *Union) *_TypeSet
 	var allTerms termlist
 	for _, t := range utyp.terms {
 		var terms termlist
-		switch u := under(t.typ).(type) {
-		case *Interface:
+		u := under(t.typ)
+		if ui, _ := u.(*Interface); ui != nil {
 			// For now we don't permit type parameters as constraints.
 			assert(!isTypeParam(t.typ))
-			terms = computeInterfaceTypeSet(check, pos, u).terms
-		default:
-			if t.typ == Typ[Invalid] {
-				continue
+			terms = computeInterfaceTypeSet(check, pos, ui).terms
+		} else if t.typ == Typ[Invalid] {
+			continue
+		} else {
+			if t.tilde && !Identical(t.typ, u) {
+				// There is no underlying type which is t.typ.
+				// The corresponding type set is empty.
+				t = nil // ∅ term
 			}
 			terms = termlist{(*term)(t)}
 		}

From 5527d7ff7935d8a58a693be5d1ec4a5312f0f07d Mon Sep 17 00:00:00 2001
From: jiahua wang 
Date: Tue, 16 Nov 2021 15:36:37 +0800
Subject: [PATCH 301/752] doc/go1.18: add Clone doc

For #47694

Change-Id: I3b135f6ff199d7a9746726b131fbe7dd97a8e95e
Reviewed-on: https://go-review.googlesource.com/c/go/+/364254
Reviewed-by: Dmitri Shuralyov 
Trust: Heschi Kreinick 
---
 doc/go1.18.html | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index c6c338984c..6d813dce2e 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -439,7 +439,9 @@ proposal.
 
    strings
    
   
    
     
    
-      TODO: https://golang.org/cl/345849: add Clone function
+      The new Clone function copies the input
+      string without the returned cloned string referencing
+      the input string's memory.
     
    
 
     
    

From 7e5331ac445045a70256eeeef5b7aad43886c9ec Mon Sep 17 00:00:00 2001
From: Tobias Klauser 
Date: Wed, 24 Nov 2021 15:37:21 +0100
Subject: [PATCH 302/752] runtime: skip TestTimePprof on illumos

On illumos nanotime calls libc, like on the other systems for which
TestTimePprof is skipped.

For #43118

Change-Id: I370d3f098a261185920cb1e3e3402d16200e301a
Reviewed-on: https://go-review.googlesource.com/c/go/+/366737
Trust: Tobias Klauser 
Run-TryBot: Tobias Klauser 
TryBot-Result: Go Bot 
Reviewed-by: Ian Lance Taylor 
---
 src/runtime/crash_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/crash_test.go b/src/runtime/crash_test.go
index 1c28e47ac3..ec4db99d78 100644
--- a/src/runtime/crash_test.go
+++ b/src/runtime/crash_test.go
@@ -717,7 +717,7 @@ func TestTimePprof(t *testing.T) {
 	// This test is unreliable on any system in which nanotime
 	// calls into libc.
 	switch runtime.GOOS {
-	case "aix", "darwin", "openbsd", "solaris":
+	case "aix", "darwin", "illumos", "openbsd", "solaris":
 		t.Skipf("skipping on %s because nanotime calls libc", runtime.GOOS)
 	}
 

From 8cdfe408bbd608c5129036e40f346d526049ffc4 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 23 Nov 2021 13:54:02 -0800
Subject: [PATCH 303/752] cmd/compile/internal/types2: better error position
 for instantiation failure

- Thread type argument expressions (rather than posLists) through various
type-checker functions so we can provide a better error position.

- Adjust signatures that expect a syntax.Pos to accept a poser instead
to avoid gratuituous conversions from expressions to positions.

- Rename targsx to xlist so we use xlist consistently for expression
lists.

First step in providing a better error message for the issue below.

For #49179.

Change-Id: I8fc685a2ee4f5640f4abd35568ba32bcb34e9e84
Reviewed-on: https://go-review.googlesource.com/c/go/+/366757
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/types2/builtins.go   |  2 +-
 src/cmd/compile/internal/types2/call.go       | 32 ++++++++-----------
 src/cmd/compile/internal/types2/mono.go       |  6 ++--
 .../types2/testdata/fixedbugs/issue39754.go2  |  4 +--
 .../types2/testdata/fixedbugs/issue49179.go2  | 19 +++++++++++
 src/cmd/compile/internal/types2/typexpr.go    | 20 ++++--------
 6 files changed, 44 insertions(+), 39 deletions(-)
 create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue49179.go2

diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index 53d834507a..fcf02a6975 100644
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -129,7 +129,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
 			arg(&x, i)
 			xlist = append(xlist, &x)
 		}
-		check.arguments(call, sig, nil, xlist) // discard result (we know the result type)
+		check.arguments(call, sig, nil, xlist, nil) // discard result (we know the result type)
 		// ok to continue even if check.arguments reported errors
 
 		x.mode = value
diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index 91e2a8f783..ed8b67c607 100644
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -50,14 +50,8 @@ func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
 	}
 	assert(got == want)
 
-	// determine argument positions (for error reporting)
-	poslist := make([]syntax.Pos, len(xlist))
-	for i, x := range xlist {
-		poslist[i] = syntax.StartPos(x)
-	}
-
 	// instantiate function signature
-	res := check.instantiateSignature(x.Pos(), sig, targs, poslist)
+	res := check.instantiateSignature(x.Pos(), sig, targs, xlist)
 	assert(res.TypeParams().Len() == 0) // signature is not generic anymore
 	check.recordInstance(inst.X, targs, res)
 	x.typ = res
@@ -65,7 +59,7 @@ func (check *Checker) funcInst(x *operand, inst *syntax.IndexExpr) {
 	x.expr = inst
 }
 
-func (check *Checker) instantiateSignature(pos syntax.Pos, typ *Signature, targs []Type, posList []syntax.Pos) (res *Signature) {
+func (check *Checker) instantiateSignature(pos syntax.Pos, typ *Signature, targs []Type, xlist []syntax.Expr) (res *Signature) {
 	assert(check != nil)
 	assert(len(targs) == typ.TypeParams().Len())
 
@@ -79,17 +73,17 @@ func (check *Checker) instantiateSignature(pos syntax.Pos, typ *Signature, targs
 	}
 
 	inst := check.instance(pos, typ, targs, check.bestContext(nil)).(*Signature)
-	assert(len(posList) <= len(targs))
+	assert(len(xlist) <= len(targs))
 	tparams := typ.TypeParams().list()
 	if i, err := check.verify(pos, tparams, targs); err != nil {
 		// best position for error reporting
 		pos := pos
-		if i < len(posList) {
-			pos = posList[i]
+		if i < len(xlist) {
+			pos = syntax.StartPos(xlist[i])
 		}
-		check.softErrorf(pos, err.Error())
+		check.softErrorf(pos, "%s", err)
 	} else {
-		check.mono.recordInstance(check.pkg, pos, tparams, targs, posList)
+		check.mono.recordInstance(check.pkg, pos, tparams, targs, xlist)
 	}
 
 	return inst
@@ -179,9 +173,10 @@ func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind {
 	}
 
 	// evaluate type arguments, if any
+	var xlist []syntax.Expr
 	var targs []Type
 	if inst != nil {
-		xlist := unpackExpr(inst.Index)
+		xlist = unpackExpr(inst.Index)
 		targs = check.typeList(xlist)
 		if targs == nil {
 			check.use(call.ArgList...)
@@ -205,7 +200,7 @@ func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind {
 	// evaluate arguments
 	args, _ := check.exprList(call.ArgList, false)
 	isGeneric := sig.TypeParams().Len() > 0
-	sig = check.arguments(call, sig, targs, args)
+	sig = check.arguments(call, sig, targs, args, xlist)
 
 	if isGeneric && sig.TypeParams().Len() == 0 {
 		// update the recorded type of call.Fun to its instantiated type
@@ -279,7 +274,8 @@ func (check *Checker) exprList(elist []syntax.Expr, allowCommaOk bool) (xlist []
 	return
 }
 
-func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, targs []Type, args []*operand) (rsig *Signature) {
+// xlist is the list of type argument expressions supplied in the source code.
+func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, targs []Type, args []*operand, xlist []syntax.Expr) (rsig *Signature) {
 	rsig = sig
 
 	// TODO(gri) try to eliminate this extra verification loop
@@ -381,15 +377,13 @@ func (check *Checker) arguments(call *syntax.CallExpr, sig *Signature, targs []T
 				check.versionErrorf(call.Pos(), "go1.18", "implicit function instantiation")
 			}
 		}
-		// TODO(gri) provide position information for targs so we can feed
-		//           it to the instantiate call for better error reporting
 		targs := check.infer(call.Pos(), sig.TypeParams().list(), targs, sigParams, args)
 		if targs == nil {
 			return // error already reported
 		}
 
 		// compute result signature
-		rsig = check.instantiateSignature(call.Pos(), sig, targs, nil)
+		rsig = check.instantiateSignature(call.Pos(), sig, targs, xlist)
 		assert(rsig.TypeParams().Len() == 0) // signature is not generic anymore
 		check.recordInstance(call.Fun, targs, rsig)
 
diff --git a/src/cmd/compile/internal/types2/mono.go b/src/cmd/compile/internal/types2/mono.go
index 39c4d4fbef..7bd79f4282 100644
--- a/src/cmd/compile/internal/types2/mono.go
+++ b/src/cmd/compile/internal/types2/mono.go
@@ -168,11 +168,11 @@ func (w *monoGraph) recordCanon(mpar, tpar *TypeParam) {
 
 // recordInstance records that the given type parameters were
 // instantiated with the corresponding type arguments.
-func (w *monoGraph) recordInstance(pkg *Package, pos syntax.Pos, tparams []*TypeParam, targs []Type, posList []syntax.Pos) {
+func (w *monoGraph) recordInstance(pkg *Package, pos syntax.Pos, tparams []*TypeParam, targs []Type, xlist []syntax.Expr) {
 	for i, tpar := range tparams {
 		pos := pos
-		if i < len(posList) {
-			pos = posList[i]
+		if i < len(xlist) {
+			pos = syntax.StartPos(xlist[i])
 		}
 		w.assign(pkg, pos, tpar, targs[i])
 	}
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39754.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39754.go2
index a88f4cf2f1..9edd239d7d 100644
--- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39754.go2
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39754.go2
@@ -17,7 +17,5 @@ func f[V interface{}, A, B Box[V]]() {}
 func _() {
 	f[int, Optional[int], Optional[int]]()
 	_ = f[int, Optional[int], Optional /* ERROR does not implement Box */ [string]]
-	// TODO(gri) Provide better position information here.
-	//           See TODO in call.go, Checker.arguments.
-	f[int, Optional[int], Optional[string]]( /* ERROR does not implement Box */ )
+	_ = f[int, Optional[int], Optional /* ERROR Optional.* does not implement Box.* */ [string]]
 }
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49179.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49179.go2
new file mode 100644
index 0000000000..7cba52aa25
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49179.go2
@@ -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 p
+
+type SliceConstraint[T any] interface {
+	[]T
+}
+
+func Map[S SliceConstraint[E], E any](s S, f func(E) E) S {
+	return s
+}
+
+type MySlice []int
+
+func f(s MySlice) {
+	Map[MySlice /* ERROR MySlice does not implement SliceConstraint\[int\] */, int](s, nil)
+}
diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 862a31544a..56a7dcd203 100644
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -402,9 +402,9 @@ func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) {
 	return typ
 }
 
-func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def *Named) (res Type) {
+func (check *Checker) instantiatedType(x syntax.Expr, xlist []syntax.Expr, def *Named) (res Type) {
 	if check.conf.Trace {
-		check.trace(x.Pos(), "-- instantiating %s with %s", x, targsx)
+		check.trace(x.Pos(), "-- instantiating %s with %s", x, xlist)
 		check.indent++
 		defer func() {
 			check.indent--
@@ -424,18 +424,12 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 	}
 
 	// evaluate arguments
-	targs := check.typeList(targsx)
+	targs := check.typeList(xlist)
 	if targs == nil {
 		def.setUnderlying(Typ[Invalid]) // avoid later errors due to lazy instantiation
 		return Typ[Invalid]
 	}
 
-	// determine argument positions
-	posList := make([]syntax.Pos, len(targs))
-	for i, arg := range targsx {
-		posList[i] = arg.Pos()
-	}
-
 	// create the instance
 	ctxt := check.bestContext(nil)
 	h := ctxt.instanceHash(orig, targs)
@@ -484,12 +478,12 @@ func (check *Checker) instantiatedType(x syntax.Expr, targsx []syntax.Expr, def
 			if i, err := check.verify(x.Pos(), inst.tparams.list(), inst.targs.list()); err != nil {
 				// best position for error reporting
 				pos := x.Pos()
-				if i < len(posList) {
-					pos = posList[i]
+				if i < len(xlist) {
+					pos = syntax.StartPos(xlist[i])
 				}
-				check.softErrorf(pos, err.Error())
+				check.softErrorf(pos, "%s", err)
 			} else {
-				check.mono.recordInstance(check.pkg, x.Pos(), inst.tparams.list(), inst.targs.list(), posList)
+				check.mono.recordInstance(check.pkg, x.Pos(), inst.tparams.list(), inst.targs.list(), xlist)
 			}
 		}
 

From b77f5f9667c6e5c2081d94163dd7d11c03fa2b8e Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 23 Nov 2021 15:55:11 -0800
Subject: [PATCH 304/752] cmd/compile/internal/types2: better error message for
 missing ~ in constraint

If a constraint could be satisfied if one of its type elements
had a ~, provide this information in the error message.

Fixes #49179.

Change-Id: I59f1a855a0646ad7254a978420b0334f1f52ec22
Reviewed-on: https://go-review.googlesource.com/c/go/+/366758
Trust: Robert Griesemer 
Reviewed-by: Robert Findley 
---
 .../compile/internal/types2/instantiate.go    | 25 ++++++++++++++++---
 .../types2/testdata/fixedbugs/issue49179.go2  | 20 ++++++++++++++-
 src/cmd/compile/internal/types2/typeset.go    |  2 ++
 3 files changed, 43 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go
index 3f5fc56f5d..f9423dd70e 100644
--- a/src/cmd/compile/internal/types2/instantiate.go
+++ b/src/cmd/compile/internal/types2/instantiate.go
@@ -238,9 +238,28 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 	}
 
 	// Otherwise, V's type must be included in the iface type set.
-	if !Ti.typeSet().includes(V) {
-		// TODO(gri) report which type is missing
-		return errorf("%s does not implement %s", V, T)
+	var alt Type
+	if Ti.typeSet().is(func(t *term) bool {
+		if !t.includes(V) {
+			// If V ∉ t.typ but V ∈ ~t.typ then remember this type
+			// so we can suggest it as an alternative in the error
+			// message.
+			if alt == nil && !t.tilde && Identical(t.typ, under(t.typ)) {
+				tt := *t
+				tt.tilde = true
+				if tt.includes(V) {
+					alt = t.typ
+				}
+			}
+			return true
+		}
+		return false
+	}) {
+		if alt != nil {
+			return errorf("%s does not implement %s (possibly missing ~ for %s in constraint %s)", V, T, alt, T)
+		} else {
+			return errorf("%s does not implement %s", V, T)
+		}
 	}
 
 	return nil
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49179.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49179.go2
index 7cba52aa25..75bea18072 100644
--- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49179.go2
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49179.go2
@@ -4,6 +4,24 @@
 
 package p
 
+func f1[P int | string]()            {}
+func f2[P ~int | string | float64]() {}
+func f3[P int](x P)                  {}
+
+type myInt int
+type myFloat float64
+
+func _() {
+	_ = f1[int]
+	_ = f1[myInt /* ERROR possibly missing ~ for int in constraint int\|string */]
+	_ = f2[myInt]
+	_ = f2[myFloat /* ERROR possibly missing ~ for float64 in constraint int\|string|float64 */]
+	var x myInt
+	f3( /* ERROR myInt does not implement int \(possibly missing ~ for int in constraint int\) */ x)
+}
+
+// test case from the issue
+
 type SliceConstraint[T any] interface {
 	[]T
 }
@@ -15,5 +33,5 @@ func Map[S SliceConstraint[E], E any](s S, f func(E) E) S {
 type MySlice []int
 
 func f(s MySlice) {
-	Map[MySlice /* ERROR MySlice does not implement SliceConstraint\[int\] */, int](s, nil)
+	Map[MySlice /* ERROR MySlice does not implement SliceConstraint\[int\] \(possibly missing ~ for \[\]int in constraint SliceConstraint\[int\]\) */, int](s, nil)
 }
diff --git a/src/cmd/compile/internal/types2/typeset.go b/src/cmd/compile/internal/types2/typeset.go
index a55e9d1d63..eaf614da64 100644
--- a/src/cmd/compile/internal/types2/typeset.go
+++ b/src/cmd/compile/internal/types2/typeset.go
@@ -108,6 +108,8 @@ func (s *_TypeSet) hasTerms() bool { return !s.terms.isEmpty() && !s.terms.isAll
 func (s *_TypeSet) singleType() Type { return s.terms.singleType() }
 
 // includes reports whether t ∈ s.
+// TODO(gri) This function is not used anywhere anymore. Remove once we
+//           are clear that we don't need it elsewhere in the future.
 func (s *_TypeSet) includes(t Type) bool { return s.terms.includes(t) }
 
 // subsetOf reports whether s1 ⊆ s2.

From b2a5a3771f5efdb499da215298c7bcc2f493b4f1 Mon Sep 17 00:00:00 2001
From: Russ Cox 
Date: Wed, 24 Nov 2021 10:35:21 -0500
Subject: [PATCH 305/752] cmd/dist: add buildtag parsing test

Forgot to 'git add' this test written as part of CL 359314.

For #41184.

Change-Id: I2ebd48fd62a2053c8b16e5a8c48c1e11d1b86d5b
Reviewed-on: https://go-review.googlesource.com/c/go/+/366894
Trust: Russ Cox 
Run-TryBot: Russ Cox 
TryBot-Result: Go Bot 
Reviewed-by: Ian Lance Taylor 
---
 src/cmd/dist/buildtag_test.go | 43 +++++++++++++++++++++++++++++++++++
 src/cmd/go/go_test.go         |  6 ++---
 2 files changed, 46 insertions(+), 3 deletions(-)
 create mode 100644 src/cmd/dist/buildtag_test.go

diff --git a/src/cmd/dist/buildtag_test.go b/src/cmd/dist/buildtag_test.go
new file mode 100644
index 0000000000..f64abfd1f1
--- /dev/null
+++ b/src/cmd/dist/buildtag_test.go
@@ -0,0 +1,43 @@
+// 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"
+	"reflect"
+	"testing"
+)
+
+var buildParserTests = []struct {
+	x       string
+	matched bool
+	err     error
+}{
+	{"gc", true, nil},
+	{"gccgo", false, nil},
+	{"!gc", false, nil},
+	{"gc && gccgo", false, nil},
+	{"gc || gccgo", true, nil},
+	{"gc || (gccgo && !gccgo)", true, nil},
+	{"gc && (gccgo || !gccgo)", true, nil},
+	{"!(gc && (gccgo || !gccgo))", false, nil},
+	{"gccgo || gc", true, nil},
+	{"!(!(!(gccgo || gc)))", false, nil},
+	{"compiler_bootstrap", false, nil},
+	{"cmd_go_bootstrap", true, nil},
+	{"syntax(error", false, fmt.Errorf("parsing //go:build line: unexpected (")},
+	{"(gc", false, fmt.Errorf("parsing //go:build line: missing )")},
+	{"gc gc", false, fmt.Errorf("parsing //go:build line: unexpected tag")},
+	{"(gc))", false, fmt.Errorf("parsing //go:build line: unexpected )")},
+}
+
+func TestBuildParser(t *testing.T) {
+	for _, tt := range buildParserTests {
+		matched, err := matchexpr(tt.x)
+		if matched != tt.matched || !reflect.DeepEqual(err, tt.err) {
+			t.Errorf("matchexpr(%q) = %v, %v; want %v, %v", tt.x, matched, err, tt.matched, tt.err)
+		}
+	}
+}
diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index d8bed1dac0..170c882df9 100644
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -1128,11 +1128,11 @@ func TestGoListTest(t *testing.T) {
 	tg.grepStdoutNot(`^testing \[sort.test\]$`, "unexpected test copy of testing")
 	tg.grepStdoutNot(`^testing$`, "unexpected real copy of testing")
 
-	tg.run("list", "-test", "cmd/dist", "cmd/doc")
-	tg.grepStdout(`^cmd/dist$`, "missing cmd/dist")
+	tg.run("list", "-test", "cmd/buildid", "cmd/doc")
+	tg.grepStdout(`^cmd/buildid$`, "missing cmd/buildid")
 	tg.grepStdout(`^cmd/doc$`, "missing cmd/doc")
 	tg.grepStdout(`^cmd/doc\.test$`, "missing cmd/doc test")
-	tg.grepStdoutNot(`^cmd/dist\.test$`, "unexpected cmd/dist test")
+	tg.grepStdoutNot(`^cmd/buildid\.test$`, "unexpected cmd/buildid test")
 	tg.grepStdoutNot(`^testing`, "unexpected testing")
 
 	tg.run("list", "-test", "runtime/cgo")

From c58243aa8a510a0f467715da71a3053a04365038 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" 
Date: Tue, 23 Nov 2021 20:04:24 +0100
Subject: [PATCH 306/752] runtime: support non-cooperative preemption on
 windows/arm

This adds support for injecting asynchronous preemption calls on
windows/arm. This code follows sigctxt.pushCall for POSIX OSes
on arm, except we subtract 1 from IP, just as in CL 273727.

Updates #10958.
Updates #24543.
Updates #49759.

Change-Id: Id0c2aed28662f50631b8c8cede3b4e6f088dafea
Reviewed-on: https://go-review.googlesource.com/c/go/+/366734
Trust: Jason A. Donenfeld 
Reviewed-by: Austin Clements 
Reviewed-by: Patrik Nyblom 
Reviewed-by: Cherry Mui 
---
 src/runtime/os_windows.go | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index 7ffb3a11b5..a85971c6a9 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -1306,7 +1306,7 @@ func setThreadCPUProfiler(hz int32) {
 	atomic.Store((*uint32)(unsafe.Pointer(&getg().m.profilehz)), uint32(hz))
 }
 
-const preemptMSupported = GOARCH == "386" || GOARCH == "amd64"
+const preemptMSupported = GOARCH != "arm64"
 
 // suspendLock protects simultaneous SuspendThread operations from
 // suspending each other.
@@ -1399,8 +1399,20 @@ func preemptM(mp *m) {
 				*(*uintptr)(unsafe.Pointer(sp)) = newpc
 				c.set_sp(sp)
 				c.set_ip(targetPC)
-			}
 
+			case "arm":
+				// Push LR. The injected call is responsible
+				// for restoring LR. gentraceback is aware of
+				// this extra slot. See sigctxt.pushCall in
+				// signal_arm.go, which is similar except we
+				// subtract 1 from IP here.
+				sp := c.sp()
+				sp -= goarch.PtrSize
+				c.set_sp(sp)
+				*(*uint32)(unsafe.Pointer(sp)) = uint32(c.lr())
+				c.set_lr(newpc - 1)
+				c.set_ip(targetPC)
+			}
 			stdcall2(_SetThreadContext, thread, uintptr(unsafe.Pointer(c)))
 		}
 	}

From f7e34e705c533cca0970f1c6d1eafc2666a6a947 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" 
Date: Tue, 23 Nov 2021 20:57:24 +0100
Subject: [PATCH 307/752] runtime: support non-cooperative preemption on
 windows/arm64

This adds support for injecting asynchronous preemption calls on
windows/arm64. This code exactly follows sigctxt.pushCall for POSIX OSes
on arm64.

Fixes #49759.

Change-Id: Id35ff6bc105c1db9d7ed2918d3ecab0e4e9a9431
Reviewed-on: https://go-review.googlesource.com/c/go/+/366735
Trust: Jason A. Donenfeld 
Run-TryBot: Jason A. Donenfeld 
TryBot-Result: Go Bot 
Reviewed-by: Cherry Mui 
Reviewed-by: Austin Clements 
Reviewed-by: Patrik Nyblom 
---
 src/runtime/os_windows.go | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/runtime/os_windows.go b/src/runtime/os_windows.go
index a85971c6a9..15953ffa0c 100644
--- a/src/runtime/os_windows.go
+++ b/src/runtime/os_windows.go
@@ -1306,18 +1306,13 @@ func setThreadCPUProfiler(hz int32) {
 	atomic.Store((*uint32)(unsafe.Pointer(&getg().m.profilehz)), uint32(hz))
 }
 
-const preemptMSupported = GOARCH != "arm64"
+const preemptMSupported = true
 
 // suspendLock protects simultaneous SuspendThread operations from
 // suspending each other.
 var suspendLock mutex
 
 func preemptM(mp *m) {
-	if !preemptMSupported {
-		// TODO: Implement call injection
-		return
-	}
-
 	if mp == getg().m {
 		throw("self-preempt")
 	}
@@ -1412,6 +1407,17 @@ func preemptM(mp *m) {
 				*(*uint32)(unsafe.Pointer(sp)) = uint32(c.lr())
 				c.set_lr(newpc - 1)
 				c.set_ip(targetPC)
+
+			case "arm64":
+				// Push LR. The injected call is responsible
+				// for restoring LR. gentraceback is aware of
+				// this extra slot. See sigctxt.pushCall in
+				// signal_arm64.go.
+				sp := c.sp() - 16 // SP needs 16-byte alignment
+				c.set_sp(sp)
+				*(*uint64)(unsafe.Pointer(sp)) = uint64(c.lr())
+				c.set_lr(newpc)
+				c.set_ip(targetPC)
 			}
 			stdcall2(_SetThreadContext, thread, uintptr(unsafe.Pointer(c)))
 		}

From 45bae64015975a4d7ede597a55397545571d8bc5 Mon Sep 17 00:00:00 2001
From: Chaoqun Han 
Date: Thu, 25 Nov 2021 09:41:06 +0800
Subject: [PATCH 308/752] A+C: add Chaoqun Han (individual CLA)

Change-Id: Id4aa067ef84510a31992d7d32cc697dd8b8342f1
Reviewed-on: https://go-review.googlesource.com/c/go/+/367035
Reviewed-by: Meng Zhuo 
Reviewed-by: Ian Lance Taylor 
Trust: Meng Zhuo 
Run-TryBot: Meng Zhuo 
TryBot-Result: Go Bot 
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index 6f304f3672..43dded948d 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -262,6 +262,7 @@ Casey Callendrello 
 Casey Marshall 
 Cezar Sá Espinola 
 ChaiShushan 
+Chaoqun Han 
 Charles Fenwick Elliott 
 Charles L. Dorian 
 Charles Lee 
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 7f74b0ce5b..8018f9518a 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -475,6 +475,7 @@ ChaiShushan 
 Changkun Ou 
 Channing Kimble-Brown 
 Chao Xu 
+Chaoqun Han 
 Charles Fenwick Elliott 
 Charles Kenney 
 Charles L. Dorian 

From a0506bdf7c9741974c54d9dac55517025ba2572d Mon Sep 17 00:00:00 2001
From: sivchari 
Date: Fri, 26 Nov 2021 07:45:44 +0000
Subject: [PATCH 309/752] test/fixedbugs: fix go directive of issue16008.go

This change modifies issue16008.go
I fixed // go:noinline to //go:noinline

Change-Id: Ic133eec51f0a7c4acf8cb22d25473ca08f1e916c
GitHub-Last-Rev: dd1868f2ca1f9ca7e2d6d1bfc15c601649896fdd
GitHub-Pull-Request: golang/go#49801
Reviewed-on: https://go-review.googlesource.com/c/go/+/367174
Reviewed-by: Alberto Donizetti 
Reviewed-by: Emmanuel Odeke 
Trust: Alberto Donizetti 
Run-TryBot: Alberto Donizetti 
TryBot-Result: Go Bot 
---
 test/fixedbugs/issue16008.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/fixedbugs/issue16008.go b/test/fixedbugs/issue16008.go
index 45457cdb7f..b88e2351b7 100644
--- a/test/fixedbugs/issue16008.go
+++ b/test/fixedbugs/issue16008.go
@@ -37,7 +37,7 @@ type Node struct {
 type MemoryStore struct {
 }
 
-// go:noinline
+//go:noinline
 func setupNodes(n int) (s *MemoryStore, nodeIDs []string) {
 	return
 }

From 77038044ca7b11fce7eb11f3e6115ed753c2c2bd Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" 
Date: Thu, 25 Nov 2021 13:05:58 +0100
Subject: [PATCH 310/752] doc/go1.18: document non-cooperative preemption on
 windows/arm{,64}

For #47694.
Updates #49759.

Change-Id: I7accd81b8ea6c31e4a2b5e155cf93fe9c447813b
Reviewed-on: https://go-review.googlesource.com/c/go/+/367095
Trust: Jason A. Donenfeld 
Reviewed-by: Emmanuel Odeke 
---
 doc/go1.18.html | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 6d813dce2e..c9c70267f1 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -193,8 +193,11 @@ proposal.
 
 
    Runtime
    
 
-
    
-  TODO: complete this section, or delete if not needed
+
    
+  The 
    windows/arm
     and 
    windows/arm64
     ports now support
+  non-cooperative preemption, bringing that capability to all four Windows
+  ports, which should hopefully address subtle bugs encountered when calling
+  into Win32 functions that block for extended periods of time.
 
    
 
 
    Compiler
    

From bf88adadac9bbb1b190ba7af1010373823dabb06 Mon Sep 17 00:00:00 2001
From: Roi Martin 
Date: Thu, 25 Nov 2021 13:47:39 +0100
Subject: [PATCH 311/752] cmd/doc: fix "builtin" package parsing

As stated in the code, "The builtin package needs special treatment: its
symbols are lower case but we want to see them, always". Thus, cmd/doc
forces the -u flag if the package being queried is called "builtin".
However, this happens after having already parsed the package. This
CL forces the -u flag just after parsing the command arguments and
before parsing any package.

Fixes #49796.

Change-Id: If690a900c7cfd1700feecb9529bd4344c3c249d1
Reviewed-on: https://go-review.googlesource.com/c/go/+/367134
Reviewed-by: Rob Pike 
Run-TryBot: Rob Pike 
TryBot-Result: Go Bot 
Trust: Emmanuel Odeke 
---
 src/cmd/doc/main.go | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/cmd/doc/main.go b/src/cmd/doc/main.go
index 0499c40369..dee5d7bbcd 100644
--- a/src/cmd/doc/main.go
+++ b/src/cmd/doc/main.go
@@ -110,6 +110,13 @@ func do(writer io.Writer, flagSet *flag.FlagSet, args []string) (err error) {
 		if buildPackage == nil {
 			return fmt.Errorf("no such package: %s", userPath)
 		}
+
+		// The builtin package needs special treatment: its symbols are lower
+		// case but we want to see them, always.
+		if buildPackage.ImportPath == "builtin" {
+			unexported = true
+		}
+
 		symbol, method = parseSymbol(sym)
 		pkg := parsePackage(writer, buildPackage, userPath)
 		paths = append(paths, pkg.prettyPath())
@@ -128,12 +135,6 @@ func do(writer io.Writer, flagSet *flag.FlagSet, args []string) (err error) {
 			panic(e)
 		}()
 
-		// The builtin package needs special treatment: its symbols are lower
-		// case but we want to see them, always.
-		if pkg.build.ImportPath == "builtin" {
-			unexported = true
-		}
-
 		// We have a package.
 		if showAll && symbol == "" {
 			pkg.allDoc()

From 1d47a1184a4718a34ab1df4d9bf05a284aba4c70 Mon Sep 17 00:00:00 2001
From: Keith Randall 
Date: Fri, 26 Nov 2021 07:36:09 -0800
Subject: [PATCH 312/752] bufio: mention that panic at slicing means underlying
 reader is broken

Fixes #49795

Change-Id: I2b4fd14f0ed36b643522559bebf5ce52b1d7b304
Reviewed-on: https://go-review.googlesource.com/c/go/+/367214
Trust: Keith Randall 
Run-TryBot: Keith Randall 
TryBot-Result: Go Bot 
Reviewed-by: Ian Lance Taylor 
---
 src/bufio/bufio.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/bufio/bufio.go b/src/bufio/bufio.go
index 9ea058db3e..7483946fc0 100644
--- a/src/bufio/bufio.go
+++ b/src/bufio/bufio.go
@@ -244,6 +244,8 @@ func (b *Reader) Read(p []byte) (n int, err error) {
 	}
 
 	// copy as much as we can
+	// Note: if the slice panics here, it is probably because
+	// the underlying reader returned a bad count. See issue 49795.
 	n = copy(p, b.buf[b.r:b.w])
 	b.r += n
 	b.lastByte = int(b.buf[b.r-1])

From fad67f8a5342f4bc309f26f0ae021ce9d21724e6 Mon Sep 17 00:00:00 2001
From: Tobias Klauser 
Date: Thu, 25 Nov 2021 12:22:36 +0100
Subject: [PATCH 313/752] cmd/go/internal: gofmt after CL 355010

Change-Id: I25902cc4e7a3d2a78b467825b723cd72b310e2a3
Reviewed-on: https://go-review.googlesource.com/c/go/+/367094
Trust: Tobias Klauser 
Run-TryBot: Tobias Klauser 
TryBot-Result: Go Bot 
Reviewed-by: Emmanuel Odeke 
---
 src/cmd/go/internal/generate/generate.go | 2 +-
 src/cmd/go/internal/get/get.go           | 2 +-
 src/cmd/go/internal/list/list.go         | 2 +-
 src/cmd/go/internal/load/test.go         | 2 +-
 src/cmd/go/internal/modload/query.go     | 2 +-
 src/cmd/go/internal/run/run.go           | 2 +-
 src/cmd/go/internal/vcs/vcs.go           | 2 +-
 src/cmd/go/internal/work/buildid.go      | 2 +-
 src/cmd/go/internal/work/gccgo.go        | 2 +-
 9 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/cmd/go/internal/generate/generate.go b/src/cmd/go/internal/generate/generate.go
index a3873d1138..4c17f42930 100644
--- a/src/cmd/go/internal/generate/generate.go
+++ b/src/cmd/go/internal/generate/generate.go
@@ -25,8 +25,8 @@ import (
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/load"
 	"cmd/go/internal/modload"
-	"cmd/go/internal/work"
 	"cmd/go/internal/str"
+	"cmd/go/internal/work"
 )
 
 var CmdGenerate = &base.Command{
diff --git a/src/cmd/go/internal/get/get.go b/src/cmd/go/internal/get/get.go
index f46313dcff..8cf8fe6645 100644
--- a/src/cmd/go/internal/get/get.go
+++ b/src/cmd/go/internal/get/get.go
@@ -17,10 +17,10 @@ import (
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/load"
 	"cmd/go/internal/search"
+	"cmd/go/internal/str"
 	"cmd/go/internal/vcs"
 	"cmd/go/internal/web"
 	"cmd/go/internal/work"
-	"cmd/go/internal/str"
 
 	"golang.org/x/mod/module"
 )
diff --git a/src/cmd/go/internal/list/list.go b/src/cmd/go/internal/list/list.go
index 8c85ddcf21..5ecd384787 100644
--- a/src/cmd/go/internal/list/list.go
+++ b/src/cmd/go/internal/list/list.go
@@ -23,8 +23,8 @@ import (
 	"cmd/go/internal/load"
 	"cmd/go/internal/modinfo"
 	"cmd/go/internal/modload"
-	"cmd/go/internal/work"
 	"cmd/go/internal/str"
+	"cmd/go/internal/work"
 )
 
 var CmdList = &base.Command{
diff --git a/src/cmd/go/internal/load/test.go b/src/cmd/go/internal/load/test.go
index 8a18dfbe93..6122428c9c 100644
--- a/src/cmd/go/internal/load/test.go
+++ b/src/cmd/go/internal/load/test.go
@@ -22,8 +22,8 @@ import (
 	"unicode/utf8"
 
 	"cmd/go/internal/fsys"
-	"cmd/go/internal/trace"
 	"cmd/go/internal/str"
+	"cmd/go/internal/trace"
 )
 
 var TestMainDeps = []string{
diff --git a/src/cmd/go/internal/modload/query.go b/src/cmd/go/internal/modload/query.go
index 1eb484de9d..33808ea109 100644
--- a/src/cmd/go/internal/modload/query.go
+++ b/src/cmd/go/internal/modload/query.go
@@ -21,8 +21,8 @@ import (
 	"cmd/go/internal/imports"
 	"cmd/go/internal/modfetch"
 	"cmd/go/internal/search"
-	"cmd/go/internal/trace"
 	"cmd/go/internal/str"
+	"cmd/go/internal/trace"
 
 	"golang.org/x/mod/module"
 	"golang.org/x/mod/semver"
diff --git a/src/cmd/go/internal/run/run.go b/src/cmd/go/internal/run/run.go
index 03895d27eb..878cee367e 100644
--- a/src/cmd/go/internal/run/run.go
+++ b/src/cmd/go/internal/run/run.go
@@ -18,8 +18,8 @@ import (
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/load"
 	"cmd/go/internal/modload"
-	"cmd/go/internal/work"
 	"cmd/go/internal/str"
+	"cmd/go/internal/work"
 )
 
 var CmdRun = &base.Command{
diff --git a/src/cmd/go/internal/vcs/vcs.go b/src/cmd/go/internal/vcs/vcs.go
index b2ce80325a..77a75fd51c 100644
--- a/src/cmd/go/internal/vcs/vcs.go
+++ b/src/cmd/go/internal/vcs/vcs.go
@@ -26,8 +26,8 @@ import (
 	"cmd/go/internal/base"
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/search"
-	"cmd/go/internal/web"
 	"cmd/go/internal/str"
+	"cmd/go/internal/web"
 
 	"golang.org/x/mod/module"
 )
diff --git a/src/cmd/go/internal/work/buildid.go b/src/cmd/go/internal/work/buildid.go
index d4f2a716d7..4e9189a363 100644
--- a/src/cmd/go/internal/work/buildid.go
+++ b/src/cmd/go/internal/work/buildid.go
@@ -15,8 +15,8 @@ import (
 	"cmd/go/internal/cache"
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/fsys"
-	"cmd/internal/buildid"
 	"cmd/go/internal/str"
+	"cmd/internal/buildid"
 )
 
 // Build IDs
diff --git a/src/cmd/go/internal/work/gccgo.go b/src/cmd/go/internal/work/gccgo.go
index 60181b99e4..1499536932 100644
--- a/src/cmd/go/internal/work/gccgo.go
+++ b/src/cmd/go/internal/work/gccgo.go
@@ -16,8 +16,8 @@ import (
 	"cmd/go/internal/cfg"
 	"cmd/go/internal/fsys"
 	"cmd/go/internal/load"
-	"cmd/internal/pkgpath"
 	"cmd/go/internal/str"
+	"cmd/internal/pkgpath"
 )
 
 // The Gccgo toolchain.

From a142d6587cb6a7ac59ebf49120167c96bdc3bcf6 Mon Sep 17 00:00:00 2001
From: Carlo Alberto Ferraris 
Date: Mon, 22 Nov 2021 01:26:48 +0000
Subject: [PATCH 314/752] doc: go1.18 release notes for CLs 323318/332771
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Updates #47694

Change-Id: Ib76737996a701906117e096eb6d05b388576a874
GitHub-Last-Rev: 05b96499651bb4e90617460a72f1df9f2c8615f3
GitHub-Pull-Request: golang/go#49588
Reviewed-on: https://go-review.googlesource.com/c/go/+/363840
Reviewed-by: Dmitri Shuralyov 
Trust: Daniel Martí 
---
 doc/go1.18.html | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index c9c70267f1..1788e97663 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -304,9 +304,10 @@ proposal.
 
 
    bytes
    
   
    
-    
    
-      bytes.Trim and related
-      functions, have had their most common use cases optimized.
+    
    
+      Trim, TrimLeft,
+      and TrimRight are now allocation free and, especially for 
+      small ASCII cutsets, up to 10 times faster.
     
    
 
     
    
@@ -447,9 +448,10 @@ proposal.
       the input string's memory.
     
    
 
-    
    
-      strings.Trim and related functions
-      functions, have had their most common use cases optimized.
+    
    
+      Trim, TrimLeft,
+      and TrimRight are now allocation free and, especially for 
+      small ASCII cutsets, up to 10 times faster.
     
    
 
     
    

From 7e1260f62b7447c36d9f3ff95365d761592323c4 Mon Sep 17 00:00:00 2001
From: sivchari 
Date: Sat, 27 Nov 2021 23:02:16 +0000
Subject: [PATCH 315/752] testing: simplify fuzzResult.String to avoid
 unnecessarily using fmt.Sprintf

Change-Id: I16b6bfb6b0f02672c894b20845aa14d8dd1979b4
GitHub-Last-Rev: 75ab90123a8a5ad42e96795b756d3a9e898aaa06
GitHub-Pull-Request: golang/go#49819
Reviewed-on: https://go-review.googlesource.com/c/go/+/367314
Reviewed-by: Emmanuel Odeke 
Reviewed-by: Ian Lance Taylor 
Run-TryBot: Emmanuel Odeke 
TryBot-Result: Go Bot 
---
 src/testing/fuzz.go | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go
index 24a0080730..19ff39947b 100644
--- a/src/testing/fuzz.go
+++ b/src/testing/fuzz.go
@@ -423,12 +423,10 @@ type fuzzResult struct {
 }
 
 func (r fuzzResult) String() string {
-	s := ""
 	if r.Error == nil {
-		return s
+		return ""
 	}
-	s = fmt.Sprintf("%s", r.Error.Error())
-	return s
+	return r.Error.Error()
 }
 
 // fuzzCrashError is satisfied by a failing input detected while fuzzing.

From 9f2a075df905d873e3e426b2f549c327d228ac26 Mon Sep 17 00:00:00 2001
From: tangxi666 
Date: Sat, 27 Nov 2021 05:20:05 +0000
Subject: [PATCH 316/752] cmd/go: fix a typo in mod_lazy_new_import.txt

x/y -> a/y

Change-Id: If24970623731098bb72345b8f4c8518b563bbec8
GitHub-Last-Rev: 8a35dddbc155d97f03c08c06d945596584bc2e6d
GitHub-Pull-Request: golang/go#49813
Reviewed-on: https://go-review.googlesource.com/c/go/+/367202
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Emmanuel Odeke 
Run-TryBot: Ian Lance Taylor 
TryBot-Result: Go Bot 
---
 src/cmd/go/testdata/script/mod_lazy_new_import.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/testdata/script/mod_lazy_new_import.txt b/src/cmd/go/testdata/script/mod_lazy_new_import.txt
index 4272a52de1..520d8459cc 100644
--- a/src/cmd/go/testdata/script/mod_lazy_new_import.txt
+++ b/src/cmd/go/testdata/script/mod_lazy_new_import.txt
@@ -7,7 +7,7 @@
 #     \
 #      ---- a/y (new) ---- c
 #
-# Where a/x and x/y are disjoint packages, but both contained in module a.
+# Where a/x and a/y are disjoint packages, but both contained in module a.
 #
 # The module dependency graph initially looks like:
 #

From 0fa53e41f122b1661d0678a6d36d71b7b5ad031d Mon Sep 17 00:00:00 2001
From: syumai 
Date: Sat, 27 Nov 2021 11:16:57 +0000
Subject: [PATCH 317/752] spec: fix link for instantiations

This change corrects the link `Instantiantions` to `Instantiations` in the spec.

Change-Id: Ib0ed03420ae401d20af1ea723c5487018b2f462d
GitHub-Last-Rev: b84316c818b4aba022362fd09fac0d2b85da1a81
GitHub-Pull-Request: golang/go#49816
Reviewed-on: https://go-review.googlesource.com/c/go/+/367274
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Emmanuel Odeke 
---
 doc/go_spec.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index b8e6aceee9..4700548cb2 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -2883,7 +2883,7 @@ to use. This makes the receiver type parameters available to the method.
 
 
    
 Syntactically, this type parameter declaration looks like an
-instantiation of the receiver base type, except that
+instantiation of the receiver base type, except that
 the type arguments are the type parameters being declared, one for each type parameter
 of the receiver base type.
 The type parameter names do not need to match their corresponding parameter names in the

From 78af02e8b5c5c9d3c6d5026fd72f57026a14952a Mon Sep 17 00:00:00 2001
From: Bharath Kumar Uppala 
Date: Thu, 25 Nov 2021 10:09:47 +0530
Subject: [PATCH 318/752] A+C: add Bharath Kumar Uppala (individual CLA)

Change-Id: I4943e943892bd29bca2afafddb62f3060bc153e9
Reviewed-on: https://go-review.googlesource.com/c/go/+/367074
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Meng Zhuo 
---
 AUTHORS      | 1 +
 CONTRIBUTORS | 1 +
 2 files changed, 2 insertions(+)

diff --git a/AUTHORS b/AUTHORS
index 43dded948d..1a4a57bae7 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -209,6 +209,7 @@ Benjamin Hsieh 
 Benny Siegert 
 Benoit Sigoure 
 Berengar Lehr 
+Bharath Kumar Uppala 
 Bill Zissimopoulos 
 Billie Harold Cleek 
 Bjorn Tillenius 
diff --git a/CONTRIBUTORS b/CONTRIBUTORS
index 8018f9518a..e2e102f610 100644
--- a/CONTRIBUTORS
+++ b/CONTRIBUTORS
@@ -368,6 +368,7 @@ Benny Siegert 
 Benoit Sigoure 
 Berengar Lehr 
 Berkant Ipek <41230766+0xbkt@users.noreply.github.com>
+Bharath Kumar Uppala 
 Bharath Thiruveedula 
 Bhavin Gandhi 
 Bill Neubauer   

From 1ea4d3b91164fb08b7022958b6cd8e290f12e017 Mon Sep 17 00:00:00 2001
From: Meng Zhuo 
Date: Tue, 30 Mar 2021 19:58:35 +0800
Subject: [PATCH 319/752] cmd/link: merge note sections into one segment

The ld from binutils merges note sections into one PT_NOTE
segment.
We should do that for consistency with binutils.

Change-Id: I45703525c720972d49c36c4f10ac47d1628b5698
Reviewed-on: https://go-review.googlesource.com/c/go/+/265957
Trust: Meng Zhuo 
Trust: Emmanuel Odeke 
Run-TryBot: Meng Zhuo 
TryBot-Result: Go Bot 
Reviewed-by: Cherry Mui 
---
 src/cmd/link/elf_test.go        | 55 +++++++++++++++++++++++++++++++++
 src/cmd/link/internal/ld/elf.go | 39 ++++++++++-------------
 2 files changed, 71 insertions(+), 23 deletions(-)

diff --git a/src/cmd/link/elf_test.go b/src/cmd/link/elf_test.go
index 012c0b5169..760d9ea60d 100644
--- a/src/cmd/link/elf_test.go
+++ b/src/cmd/link/elf_test.go
@@ -201,6 +201,61 @@ func TestMinusRSymsWithSameName(t *testing.T) {
 	}
 }
 
+func TestMergeNoteSections(t *testing.T) {
+	testenv.MustHaveGoBuild(t)
+	expected := 1
+
+	switch runtime.GOOS {
+	case "linux", "freebsd", "dragonfly":
+	case "openbsd", "netbsd":
+		// These OSes require independent segment
+		expected = 2
+	default:
+		t.Skip("We should only test on elf output.")
+	}
+	t.Parallel()
+
+	goFile := filepath.Join(t.TempDir(), "notes.go")
+	if err := ioutil.WriteFile(goFile, []byte(goSource), 0444); err != nil {
+		t.Fatal(err)
+	}
+	outFile := filepath.Join(t.TempDir(), "notes.exe")
+	goTool := testenv.GoToolPath(t)
+	// sha1sum of "gopher"
+	id := "0xf4e8cd51ce8bae2996dc3b74639cdeaa1f7fee5f"
+	cmd := exec.Command(goTool, "build", "-o", outFile, "-ldflags",
+		"-B "+id, goFile)
+	cmd.Dir = t.TempDir()
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Logf("%s", out)
+		t.Fatal(err)
+	}
+
+	ef, err := elf.Open(outFile)
+	if err != nil {
+		t.Fatalf("open elf file failed:%v", err)
+	}
+	defer ef.Close()
+	sec := ef.Section(".note.gnu.build-id")
+	if sec == nil {
+		t.Fatalf("can't find gnu build id")
+	}
+
+	sec = ef.Section(".note.go.buildid")
+	if sec == nil {
+		t.Fatalf("can't find go build id")
+	}
+	cnt := 0
+	for _, ph := range ef.Progs {
+		if ph.Type == elf.PT_NOTE {
+			cnt += 1
+		}
+	}
+	if cnt != expected {
+		t.Fatalf("want %d PT_NOTE segment, got %d", expected, cnt)
+	}
+}
+
 const pieSourceTemplate = `
 package main
 
diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go
index fb75c761a1..4a143dfcaa 100644
--- a/src/cmd/link/internal/ld/elf.go
+++ b/src/cmd/link/internal/ld/elf.go
@@ -1682,13 +1682,18 @@ func asmbElf(ctxt *Link) {
 
 	var pph *ElfPhdr
 	var pnote *ElfPhdr
+	getpnote := func() *ElfPhdr {
+		if pnote == nil {
+			pnote = newElfPhdr()
+			pnote.Type = elf.PT_NOTE
+			pnote.Flags = elf.PF_R
+		}
+		return pnote
+	}
 	if *flagRace && ctxt.IsNetbsd() {
 		sh := elfshname(".note.netbsd.pax")
 		resoff -= int64(elfnetbsdpax(sh, uint64(startva), uint64(resoff)))
-		pnote = newElfPhdr()
-		pnote.Type = elf.PT_NOTE
-		pnote.Flags = elf.PF_R
-		phsh(pnote, sh)
+		phsh(getpnote(), sh)
 	}
 	if ctxt.LinkMode == LinkExternal {
 		/* skip program headers */
@@ -1787,7 +1792,6 @@ func asmbElf(ctxt *Link) {
 		phsh(ph, sh)
 	}
 
-	pnote = nil
 	if ctxt.HeadType == objabi.Hnetbsd || ctxt.HeadType == objabi.Hopenbsd {
 		var sh *ElfShdr
 		switch ctxt.HeadType {
@@ -1799,34 +1803,23 @@ func asmbElf(ctxt *Link) {
 			sh = elfshname(".note.openbsd.ident")
 			resoff -= int64(elfopenbsdsig(sh, uint64(startva), uint64(resoff)))
 		}
-
-		pnote = newElfPhdr()
-		pnote.Type = elf.PT_NOTE
-		pnote.Flags = elf.PF_R
-		phsh(pnote, sh)
+		// netbsd and openbsd require ident in an independent segment.
+		pnotei := newElfPhdr()
+		pnotei.Type = elf.PT_NOTE
+		pnotei.Flags = elf.PF_R
+		phsh(pnotei, sh)
 	}
 
 	if len(buildinfo) > 0 {
 		sh := elfshname(".note.gnu.build-id")
 		resoff -= int64(elfbuildinfo(sh, uint64(startva), uint64(resoff)))
-
-		if pnote == nil {
-			pnote = newElfPhdr()
-			pnote.Type = elf.PT_NOTE
-			pnote.Flags = elf.PF_R
-		}
-
-		phsh(pnote, sh)
+		phsh(getpnote(), sh)
 	}
 
 	if *flagBuildid != "" {
 		sh := elfshname(".note.go.buildid")
 		resoff -= int64(elfgobuildid(sh, uint64(startva), uint64(resoff)))
-
-		pnote := newElfPhdr()
-		pnote.Type = elf.PT_NOTE
-		pnote.Flags = elf.PF_R
-		phsh(pnote, sh)
+		phsh(getpnote(), sh)
 	}
 
 	// Additions to the reserved area must be above this line.

From a59ab29bf2164730e3e6d5439c6ec4b1e46adcc4 Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" 
Date: Mon, 29 Nov 2021 11:05:41 -0500
Subject: [PATCH 320/752] doc/go1.18: use  instead of 
     for target
 specification

For #47694.

Signed-off-by: Jason A. Donenfeld 
Change-Id: I38c2fd9b57fbbacf220a2bc679f67e2dfdcc7cb1
Reviewed-on: https://go-review.googlesource.com/c/go/+/367514
Reviewed-by: Dmitri Shuralyov 
---
 doc/go1.18.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 1788e97663..022541b83d 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -194,7 +194,7 @@ proposal.
 
    Runtime
    
 
 
    
-  The 
    windows/arm
     and 
    windows/arm64
     ports now support
+  The windows/arm and windows/arm64 ports now support
   non-cooperative preemption, bringing that capability to all four Windows
   ports, which should hopefully address subtle bugs encountered when calling
   into Win32 functions that block for extended periods of time.

From 4325c37d6789aff6f24b05526080b011dda86477 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor 
Date: Tue, 23 Nov 2021 12:34:04 -0800
Subject: [PATCH 321/752] vendor: update golang.org/x/net to tip

This brings in a fix for OpenBSD that lets it correctly gather network
interface information.

For #42064

Change-Id: Ib88fd2f494bb2ee86fd2725d8375b2df1404c4ca
Reviewed-on: https://go-review.googlesource.com/c/go/+/366756
Trust: Ian Lance Taylor 
Run-TryBot: Ian Lance Taylor 
Reviewed-by: Dmitri Shuralyov 
Reviewed-by: Damien Neil 
Reviewed-by: Bryan C. Mills 
TryBot-Result: Go Bot 
---
 src/go.mod                                    |  2 +-
 src/go.sum                                    |  4 +-
 src/net/http/h2_bundle.go                     | 76 ++++++++++++-------
 src/vendor/golang.org/x/net/lif/address.go    |  1 +
 src/vendor/golang.org/x/net/lif/binary.go     |  1 +
 src/vendor/golang.org/x/net/lif/lif.go        |  1 +
 src/vendor/golang.org/x/net/lif/link.go       |  1 +
 src/vendor/golang.org/x/net/lif/sys.go        |  1 +
 src/vendor/golang.org/x/net/lif/syscall.go    |  1 +
 src/vendor/golang.org/x/net/route/syscall.go  | 26 ++-----
 .../x/net/route/syscall_go1_12_darwin.go      | 13 ----
 src/vendor/modules.txt                        |  2 +-
 12 files changed, 63 insertions(+), 66 deletions(-)
 delete mode 100644 src/vendor/golang.org/x/net/route/syscall_go1_12_darwin.go

diff --git a/src/go.mod b/src/go.mod
index b8c4d5c16b..d26e4960b3 100644
--- a/src/go.mod
+++ b/src/go.mod
@@ -4,7 +4,7 @@ go 1.18
 
 require (
 	golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa
-	golang.org/x/net v0.0.0-20211108170745-6635138e15ea
+	golang.org/x/net v0.0.0-20211123203042-d83791d6bcd9
 )
 
 require (
diff --git a/src/go.sum b/src/go.sum
index ff1288f81d..fddc4fbe93 100644
--- a/src/go.sum
+++ b/src/go.sum
@@ -1,7 +1,7 @@
 golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa h1:idItI2DDfCokpg0N51B2VtiLdJ4vAuXC9fnCb2gACo4=
 golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/net v0.0.0-20211108170745-6635138e15ea h1:FosBMXtOc8Tp9Hbo4ltl1WJSrTVewZU8MPnTPY2HdH8=
-golang.org/x/net v0.0.0-20211108170745-6635138e15ea/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.0.0-20211123203042-d83791d6bcd9 h1:0qxwC5n+ttVOINCBeRHO0nq9X7uy8SDsPoi5OaCdIEI=
+golang.org/x/net v0.0.0-20211123203042-d83791d6bcd9/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e h1:i6Vklmyu+fZMFYpum+sR4ZWABGW7MyIxfJZXYvcnbns=
 golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2 h1:GLw7MR8AfAG2GmGcmVgObFOHXYypgGjnGno25RDwn3Y=
diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go
index 23a4d15326..8d19c42b5a 100644
--- a/src/net/http/h2_bundle.go
+++ b/src/net/http/h2_bundle.go
@@ -7830,36 +7830,49 @@ func (cc *http2ClientConn) RoundTrip(req *Request) (*Response, error) {
 		}
 	}
 
+	handleResponseHeaders := func() (*Response, error) {
+		res := cs.res
+		if res.StatusCode > 299 {
+			// On error or status code 3xx, 4xx, 5xx, etc abort any
+			// ongoing write, assuming that the server doesn't care
+			// about our request body. If the server replied with 1xx or
+			// 2xx, however, then assume the server DOES potentially
+			// want our body (e.g. full-duplex streaming:
+			// golang.org/issue/13444). If it turns out the server
+			// doesn't, they'll RST_STREAM us soon enough. This is a
+			// heuristic to avoid adding knobs to Transport. Hopefully
+			// we can keep it.
+			cs.abortRequestBodyWrite()
+		}
+		res.Request = req
+		res.TLS = cc.tlsState
+		if res.Body == http2noBody && http2actualContentLength(req) == 0 {
+			// If there isn't a request or response body still being
+			// written, then wait for the stream to be closed before
+			// RoundTrip returns.
+			if err := waitDone(); err != nil {
+				return nil, err
+			}
+		}
+		return res, nil
+	}
+
 	for {
 		select {
 		case <-cs.respHeaderRecv:
-			res := cs.res
-			if res.StatusCode > 299 {
-				// On error or status code 3xx, 4xx, 5xx, etc abort any
-				// ongoing write, assuming that the server doesn't care
-				// about our request body. If the server replied with 1xx or
-				// 2xx, however, then assume the server DOES potentially
-				// want our body (e.g. full-duplex streaming:
-				// golang.org/issue/13444). If it turns out the server
-				// doesn't, they'll RST_STREAM us soon enough. This is a
-				// heuristic to avoid adding knobs to Transport. Hopefully
-				// we can keep it.
-				cs.abortRequestBodyWrite()
-			}
-			res.Request = req
-			res.TLS = cc.tlsState
-			if res.Body == http2noBody && http2actualContentLength(req) == 0 {
-				// If there isn't a request or response body still being
-				// written, then wait for the stream to be closed before
-				// RoundTrip returns.
-				if err := waitDone(); err != nil {
-					return nil, err
-				}
-			}
-			return res, nil
+			return handleResponseHeaders()
 		case <-cs.abort:
-			waitDone()
-			return nil, cs.abortErr
+			select {
+			case <-cs.respHeaderRecv:
+				// If both cs.respHeaderRecv and cs.abort are signaling,
+				// pick respHeaderRecv. The server probably wrote the
+				// response and immediately reset the stream.
+				// golang.org/issue/49645
+				return handleResponseHeaders()
+			default:
+				waitDone()
+				return nil, cs.abortErr
+			}
 		case <-ctx.Done():
 			err := ctx.Err()
 			cs.abortStream(err)
@@ -7919,6 +7932,9 @@ func (cs *http2clientStream) writeRequest(req *Request) (err error) {
 		return err
 	}
 	cc.addStreamLocked(cs) // assigns stream ID
+	if http2isConnectionCloseRequest(req) {
+		cc.doNotReuse = true
+	}
 	cc.mu.Unlock()
 
 	// TODO(bradfitz): this is a copy of the logic in net/http. Unify somewhere?
@@ -8016,6 +8032,7 @@ func (cs *http2clientStream) writeRequest(req *Request) (err error) {
 		case <-respHeaderTimer:
 			return http2errTimeout
 		case <-respHeaderRecv:
+			respHeaderRecv = nil
 			respHeaderTimer = nil // keep waiting for END_STREAM
 		case <-cs.abort:
 			return cs.abortErr
@@ -9019,7 +9036,7 @@ func (rl *http2clientConnReadLoop) handleResponse(cs *http2clientStream, f *http
 	cs.bytesRemain = res.ContentLength
 	res.Body = http2transportResponseBody{cs}
 
-	if cs.requestedGzip && res.Header.Get("Content-Encoding") == "gzip" {
+	if cs.requestedGzip && http2asciiEqualFold(res.Header.Get("Content-Encoding"), "gzip") {
 		res.Header.Del("Content-Encoding")
 		res.Header.Del("Content-Length")
 		res.ContentLength = -1
@@ -9158,7 +9175,10 @@ func (b http2transportResponseBody) Close() error {
 	select {
 	case <-cs.donec:
 	case <-cs.ctx.Done():
-		return cs.ctx.Err()
+		// See golang/go#49366: The net/http package can cancel the
+		// request context after the response body is fully read.
+		// Don't treat this as an error.
+		return nil
 	case <-cs.reqCancel:
 		return http2errRequestCanceled
 	}
diff --git a/src/vendor/golang.org/x/net/lif/address.go b/src/vendor/golang.org/x/net/lif/address.go
index afb957fd8e..34b6432d6e 100644
--- a/src/vendor/golang.org/x/net/lif/address.go
+++ b/src/vendor/golang.org/x/net/lif/address.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build solaris
 // +build solaris
 
 package lif
diff --git a/src/vendor/golang.org/x/net/lif/binary.go b/src/vendor/golang.org/x/net/lif/binary.go
index 738a94f422..f31ca3ad07 100644
--- a/src/vendor/golang.org/x/net/lif/binary.go
+++ b/src/vendor/golang.org/x/net/lif/binary.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build solaris
 // +build solaris
 
 package lif
diff --git a/src/vendor/golang.org/x/net/lif/lif.go b/src/vendor/golang.org/x/net/lif/lif.go
index 6e81f81f1c..95c7d25846 100644
--- a/src/vendor/golang.org/x/net/lif/lif.go
+++ b/src/vendor/golang.org/x/net/lif/lif.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build solaris
 // +build solaris
 
 // Package lif provides basic functions for the manipulation of
diff --git a/src/vendor/golang.org/x/net/lif/link.go b/src/vendor/golang.org/x/net/lif/link.go
index 913a53e118..f1af1306ca 100644
--- a/src/vendor/golang.org/x/net/lif/link.go
+++ b/src/vendor/golang.org/x/net/lif/link.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build solaris
 // +build solaris
 
 package lif
diff --git a/src/vendor/golang.org/x/net/lif/sys.go b/src/vendor/golang.org/x/net/lif/sys.go
index c896041b7b..d0b532d9dc 100644
--- a/src/vendor/golang.org/x/net/lif/sys.go
+++ b/src/vendor/golang.org/x/net/lif/sys.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build solaris
 // +build solaris
 
 package lif
diff --git a/src/vendor/golang.org/x/net/lif/syscall.go b/src/vendor/golang.org/x/net/lif/syscall.go
index aadab2e14b..8d03b4aa92 100644
--- a/src/vendor/golang.org/x/net/lif/syscall.go
+++ b/src/vendor/golang.org/x/net/lif/syscall.go
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:build solaris
 // +build solaris
 
 package lif
diff --git a/src/vendor/golang.org/x/net/route/syscall.go b/src/vendor/golang.org/x/net/route/syscall.go
index 97166dd3c4..68d37c9621 100644
--- a/src/vendor/golang.org/x/net/route/syscall.go
+++ b/src/vendor/golang.org/x/net/route/syscall.go
@@ -2,28 +2,12 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build dragonfly || freebsd || netbsd || openbsd
-// +build dragonfly freebsd netbsd openbsd
+//go:build darwin || dragonfly || freebsd || netbsd || openbsd
+// +build darwin dragonfly freebsd netbsd openbsd
 
 package route
 
-import (
-	"syscall"
-	"unsafe"
-)
+import _ "unsafe" // for linkname
 
-var zero uintptr
-
-func sysctl(mib []int32, old *byte, oldlen *uintptr, new *byte, newlen uintptr) error {
-	var p unsafe.Pointer
-	if len(mib) > 0 {
-		p = unsafe.Pointer(&mib[0])
-	} else {
-		p = unsafe.Pointer(&zero)
-	}
-	_, _, errno := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(p), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), newlen)
-	if errno != 0 {
-		return error(errno)
-	}
-	return nil
-}
+//go:linkname sysctl syscall.sysctl
+func sysctl(mib []int32, old *byte, oldlen *uintptr, new *byte, newlen uintptr) error
diff --git a/src/vendor/golang.org/x/net/route/syscall_go1_12_darwin.go b/src/vendor/golang.org/x/net/route/syscall_go1_12_darwin.go
deleted file mode 100644
index 7a13e4fd90..0000000000
--- a/src/vendor/golang.org/x/net/route/syscall_go1_12_darwin.go
+++ /dev/null
@@ -1,13 +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.
-
-//go:build go1.12
-// +build go1.12
-
-package route
-
-import _ "unsafe" // for linkname
-
-//go:linkname sysctl syscall.sysctl
-func sysctl(mib []int32, old *byte, oldlen *uintptr, new *byte, newlen uintptr) error
diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt
index 004b599288..2650806683 100644
--- a/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@@ -9,7 +9,7 @@ golang.org/x/crypto/curve25519/internal/field
 golang.org/x/crypto/hkdf
 golang.org/x/crypto/internal/poly1305
 golang.org/x/crypto/internal/subtle
-# golang.org/x/net v0.0.0-20211108170745-6635138e15ea
+# golang.org/x/net v0.0.0-20211123203042-d83791d6bcd9
 ## explicit; go 1.17
 golang.org/x/net/dns/dnsmessage
 golang.org/x/net/http/httpguts

From 37a5d720d4c4ebf3fd0c8a089a3bde347d72c01a Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sun, 28 Nov 2021 14:17:11 -0800
Subject: [PATCH 322/752] spec: corrections to various sections

- fix definition of "specific types" and add more examples
- state that a parameterized function must be instantiated
  when used as a function value
- remove duplicate word ("can can" -> "can")

Thanks to @danscales for finding these.

Change-Id: Ideb41efc35a3e67694d3bc97e462454feae37c44
Reviewed-on: https://go-review.googlesource.com/c/go/+/367394
Trust: Robert Griesemer 
Trust: Dan Scales 
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Dan Scales 
---
 doc/go_spec.html | 36 +++++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 4700548cb2..11f44d896d 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 
 
@@ -1971,39 +1971,38 @@ x                   T           x is not representable by a value of T because
 
 
    
 An interface specification which contains type elements
-that are not interface types defines a (possibly empty) set of specific types.
+defines a (possibly empty) set of specific types.
 Loosely speaking, these are the types T that appear in the
 interface definition in terms of the form T, ~T,
 or in unions of such terms.
 
    
 
 
    
-More precisely, for a given interface, the set of specific types is defined as follows:
+More precisely, for a given interface, the set 𝑆 of specific types is defined as follows:
 
    
 
 
      
-	
    • The set of specific types of the empty interface is the empty set.
+	
    • For an interface with no type elements, 𝑆 is the empty set.
 	
      • 
 
-	
    • The set of specific types of a non-empty interface is the intersection
-		of the specific types of its interface elements.
+	
    • For an interface with type elements, 𝑆 is the intersection
+		of the specific types of its type elements.
 	
      • 
 
-	
    • The set of specific types of a method specification is the empty set.
+	
    • For a non-interface type term T
+		or ~T, 𝑆 is the set consisting of the type T.
 	
      • 
 
-	
    • The set of specific types of a non-interface type term T
-		or ~T is the set consisting of the type T.
-	
      • 
-
-	
    • The set of specific types of a union of terms
-		t1|t2|…|tn
-		is the union of the specific types of the terms.
+	
    • For a union of terms
+		t1|t2|…|tn,
+		𝑆 is the union of the specific types of the terms.
 	
      • 
 
    
 
 
    
-If the set of specific types is empty, the interface has no specific types.
+If 𝑆 is empty, the interface has no specific types.
+An interface may have specific types even if its type set
+is empty.
 
    
 
 
    
@@ -2019,6 +2018,8 @@ interface{ int }               // int
 interface{ ~string }           // string
 interface{ int|~string }       // int, string
 interface{ Celsius|Kelvin }    // Celsius, Kelvin
+interface{ int; m() }          // int (but type set is empty because int has no method m)
+interface{ int; any }          // no specific types (intersection is empty)
 interface{ int; string }       // no specific types (intersection is empty)
 
    
 
@@ -3980,7 +3981,8 @@ pt.Scale(3.5)     // method call with receiver pt
 
 
    
 If f denotes a parameterized function, it must be
-instantiated before it can be called.
+instantiated before it can be called
+or used as a function value.
 
    
 
 
    
@@ -4807,7 +4809,7 @@ Only V is a type parameter and a value of each
 specific type of V can be converted to T.
 
 
  • 
-Only T is a type parameter and x can can be converted to each
+Only T is a type parameter and x can be converted to each
 specific type of T.
 
    • 
 

From 68da368a4ed0f6f47e841d75aaed0faf1dcf425c Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Tue, 23 Nov 2021 20:24:40 -0800
Subject: [PATCH 323/752] spec: rules for index expressions, len, cap, with
 type parameter types

We want to support some special cases for index expressions, len, and
cap on operands of type parameters (such as indexing a value constrained
by byte slices and strings), hence the extra rules.

Change-Id: I4a07dc7e64bb47361b021d606c52eae1784d5430
Reviewed-on: https://go-review.googlesource.com/c/go/+/366814
Trust: Robert Griesemer 
Trust: Dan Scales 
Reviewed-by: Dan Scales 
---
 doc/go_spec.html | 33 ++++++++++++++++++++++++++++++++-
 1 file changed, 32 insertions(+), 1 deletion(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 11f44d896d..8643d94476 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -2269,7 +2269,6 @@ An identifier is exported if both:
 All other identifiers are not exported.
 
    
 
-
 
    Uniqueness of identifiers
    
 
 
    
@@ -3715,6 +3714,26 @@ For a of map type M:
 	    for the element type of M
 
 
+
    
+For a of type parameter type P:
+
    
+
      
+	
    • P must have specific types.
      • 
+	
    • The index expression a[x] must be valid for values
+	    of all specific types of P.
      • 
+	
    • The element types of all specific types of P must be identical.
+	    In this context, the element type of a string type is byte.
      • 
+	
    • If there is a map type among the specific types of P,
+	    all specific types must be map types, and the respective key types
+	    must be all identical.
      • 
+	
    • a[x] is the array, slice, or string element at index x,
+	    or the map element with key x of the type argument
+	    that P is instantiated with, and the type of a[x] is
+	    the type of the (identical) element types.
      • 
+	
    • a[x] may not be assigned to if the specific types of P
+	    include string types.
+
    
+
 
    
 Otherwise a[x] is illegal.
 
    
@@ -6468,12 +6487,24 @@ len(s)    string type      string length in bytes
           []T              slice length
           map[K]T          map length (number of defined keys)
           chan T           number of elements queued in channel buffer
+	  type parameter   see below
 
 cap(s)    [n]T, *[n]T      array length (== n)
           []T              slice capacity
           chan T           channel buffer capacity
+	  type parameter   see below
 
    
 
+
    
+If the argument type is a type parameter P,
+P must have specific types, and
+the call len(e) (or cap(e) respectively) must be valid for
+each specific type of P.
+The result is the length (or capacity, respectively) of the argument whose type
+corresponds to the type argument with which P was
+instantiated.
+
    
+
 
    
 The capacity of a slice is the number of elements for which there is
 space allocated in the underlying array.

From 61ff5019687c125910c48c22d672a9b6985ee61e Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Sun, 28 Nov 2021 15:25:09 -0800
Subject: [PATCH 324/752] spec: adjust section on package unsafe for type
 parameters

Change-Id: I562d4648756e710020ee491f3801896563a89baa
Reviewed-on: https://go-review.googlesource.com/c/go/+/367395
Trust: Robert Griesemer 
Trust: Dan Scales 
Reviewed-by: Ian Lance Taylor 
---
 doc/go_spec.html | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/doc/go_spec.html b/doc/go_spec.html
index 8643d94476..2832b0739d 100644
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -642,7 +642,7 @@ an identifier denoting a constant,
 a constant expression,
 a conversion with a result that is a constant, or
 the result value of some built-in functions such as
-unsafe.Sizeof applied to any value,
+unsafe.Sizeof applied to certain values,
 cap or len applied to
 some expressions,
 real and imag applied to a complex constant
@@ -7446,8 +7446,14 @@ uintptr(unsafe.Pointer(&x)) % unsafe.Alignof(x) == 0
 
    
 
 
    
-Calls to Alignof, Offsetof, and
-Sizeof are compile-time constant expressions of type uintptr.
+A (variable of) type T has variable size if T
+is a type parameter, or if it is an array or struct type containing elements
+or fields of variable size. Otherwise the size is constant.
+Calls to Alignof, Offsetof, and Sizeof
+are compile-time constant expressions of
+type uintptr if their arguments (or the struct s in
+the selector expression s.f for Offsetof) are types
+of constant size.
 
    
 
 
    

From f598e2962d3a358b59faa68471b6ed378fc68806 Mon Sep 17 00:00:00 2001
From: Austin Clements 
Date: Mon, 22 Nov 2021 15:33:01 -0500
Subject: [PATCH 325/752] runtime: fix preemption sensitivity in
 TestTinyAllocIssue37262

TestTinyAllocIssue37262 assumes that all of its allocations will come
from the same tiny allocator (that is, the same P), and that nothing
else will allocate from that tiny allocator while it's running. It can
fail incorrectly if these assumptions aren't met.

Fix this potential test flakiness by disabling preemption during this
test.

As far as I know, this has never happened on the builders. It was
found by mayMoreStackPreempt.

Change-Id: I59f993e0bdbf46a9add842d0e278415422c3f804
Reviewed-on: https://go-review.googlesource.com/c/go/+/366994
Trust: Austin Clements 
Run-TryBot: Austin Clements 
TryBot-Result: Go Bot 
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Michael Knyszek 
---
 src/runtime/export_test.go | 9 +++++++++
 src/runtime/malloc_test.go | 7 +++++++
 2 files changed, 16 insertions(+)

diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go
index b2e64f14ad..ef601f770c 100644
--- a/src/runtime/export_test.go
+++ b/src/runtime/export_test.go
@@ -1307,3 +1307,12 @@ func escape(x interface{}) interface{} {
 	escapeSink = nil
 	return x
 }
+
+// Acquirem blocks preemption.
+func Acquirem() {
+	acquirem()
+}
+
+func Releasem() {
+	releasem(getg().m)
+}
diff --git a/src/runtime/malloc_test.go b/src/runtime/malloc_test.go
index e028554b23..757f945393 100644
--- a/src/runtime/malloc_test.go
+++ b/src/runtime/malloc_test.go
@@ -198,6 +198,10 @@ func TestTinyAllocIssue37262(t *testing.T) {
 	runtime.GC()
 	runtime.GC()
 
+	// Disable preemption so we stay on one P's tiny allocator and
+	// nothing else allocates from it.
+	runtime.Acquirem()
+
 	// Make 1-byte allocations until we get a fresh tiny slot.
 	aligned := false
 	for i := 0; i < 16; i++ {
@@ -208,6 +212,7 @@ func TestTinyAllocIssue37262(t *testing.T) {
 		}
 	}
 	if !aligned {
+		runtime.Releasem()
 		t.Fatal("unable to get a fresh tiny slot")
 	}
 
@@ -229,6 +234,8 @@ func TestTinyAllocIssue37262(t *testing.T) {
 	tinyByteSink = nil
 	tinyUint32Sink = nil
 	tinyObj12Sink = nil
+
+	runtime.Releasem()
 }
 
 func TestPageCacheLeak(t *testing.T) {

From 1970e3e3b7b6c42676acc22071ced887ac68b520 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Wed, 24 Nov 2021 16:18:57 -0800
Subject: [PATCH 326/752] go/types: restore original assignment error messages

This is the missing portion of the port of CL 351669
from types2 to go/types, now that we have a local flag
to control for compiler error messages.

Mostly a clean port but for adjustments to error reporting
which requires error codes in go/types.

Prerequisite for port of CL 364874.

Change-Id: I5fc8c83003e4396351f42e9adb08f4ebc8a05653
Reviewed-on: https://go-review.googlesource.com/c/go/+/367195
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/go/types/assignments.go | 35 +++++++++++++++++++++++++++++++++--
 src/go/types/expr.go        |  6 +++++-
 2 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index 7e6a230b48..8e9724e911 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -7,6 +7,7 @@
 package types
 
 import (
+	"fmt"
 	"go/ast"
 	"go/token"
 )
@@ -237,6 +238,28 @@ func (check *Checker) assignVar(lhs ast.Expr, x *operand) Type {
 	return x.typ
 }
 
+func (check *Checker) assignError(rhs []ast.Expr, nvars, nvals int) {
+	measure := func(x int, unit string) string {
+		s := fmt.Sprintf("%d %s", x, unit)
+		if x != 1 {
+			s += "s"
+		}
+		return s
+	}
+
+	vars := measure(nvars, "variable")
+	vals := measure(nvals, "value")
+	rhs0 := rhs[0]
+
+	if len(rhs) == 1 {
+		if call, _ := unparen(rhs0).(*ast.CallExpr); call != nil {
+			check.errorf(rhs0, _WrongAssignCount, "assignment mismatch: %s but %s returns %s", vars, call.Fun, vals)
+			return
+		}
+	}
+	check.errorf(rhs0, _WrongAssignCount, "assignment mismatch: %s but %s", vars, vals)
+}
+
 // If returnPos is valid, initVars is called to type-check the assignment of
 // return expressions, and returnPos is the position of the return statement.
 func (check *Checker) initVars(lhs []*Var, origRHS []ast.Expr, returnPos token.Pos) {
@@ -260,7 +283,11 @@ func (check *Checker) initVars(lhs []*Var, origRHS []ast.Expr, returnPos token.P
 			check.errorf(atPos(returnPos), _WrongResultCount, "wrong number of return values (want %d, got %d)", len(lhs), len(rhs))
 			return
 		}
-		check.errorf(rhs[0], _WrongAssignCount, "cannot initialize %d variables with %d values", len(lhs), len(rhs))
+		if compilerErrorMessages {
+			check.assignError(origRHS, len(lhs), len(rhs))
+		} else {
+			check.errorf(rhs[0], _WrongAssignCount, "cannot initialize %d variables with %d values", len(lhs), len(rhs))
+		}
 		return
 	}
 
@@ -294,7 +321,11 @@ func (check *Checker) assignVars(lhs, origRHS []ast.Expr) {
 				return
 			}
 		}
-		check.errorf(rhs[0], _WrongAssignCount, "cannot assign %d values to %d variables", len(rhs), len(lhs))
+		if compilerErrorMessages {
+			check.assignError(origRHS, len(lhs), len(rhs))
+		} else {
+			check.errorf(rhs[0], _WrongAssignCount, "cannot assign %d values to %d variables", len(rhs), len(lhs))
+		}
 		return
 	}
 
diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index c49865aec6..dd18abaf13 100644
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -1657,7 +1657,11 @@ func (check *Checker) singleValue(x *operand) {
 		// tuple types are never named - no need for underlying type below
 		if t, ok := x.typ.(*Tuple); ok {
 			assert(t.Len() != 1)
-			check.errorf(x, _TooManyValues, "%d-valued %s where single value is expected", t.Len(), x)
+			if compilerErrorMessages {
+				check.errorf(x, _TooManyValues, "multiple-value %s in single-value context", x)
+			} else {
+				check.errorf(x, _TooManyValues, "%d-valued %s where single value is expected", t.Len(), x)
+			}
 			x.mode = invalid
 		}
 	}

From 2f6d3820501b34ce530be8193789659c18db0867 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Wed, 24 Nov 2021 16:48:00 -0800
Subject: [PATCH 327/752] go/types: report types for mismatched call and return
 statements

This is a port of CL 364874 from types2 to go/types with various
adjustments:

- the error position for "not enough arguments" in calls is the
  closing ) rather than the position of the last provided argument

- the ERROR comments in tests are positioned accordingly

- the reg. expression for matching error strings accepts newlines
  for the . pattern (added s flag)

For #48834.
For #48835.

Change-Id: I64362ecf605bcf9d89b8dc121432e0131bd5da1b
Reviewed-on: https://go-review.googlesource.com/c/go/+/367196
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/go/types/assignments.go             | 82 ++++++++++++++++++++++---
 src/go/types/call.go                    | 25 ++++++--
 src/go/types/check_test.go              |  2 +-
 src/go/types/decl.go                    |  2 +-
 src/go/types/stmt.go                    |  2 +-
 src/go/types/testdata/check/errors.src  | 28 +++++----
 src/go/types/testdata/check/expr3.src   | 12 ++--
 src/go/types/testdata/check/stmt0.src   | 14 ++---
 src/go/types/testdata/check/vardecl.src |  2 +-
 9 files changed, 126 insertions(+), 43 deletions(-)

diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go
index 8e9724e911..a556e5e017 100644
--- a/src/go/types/assignments.go
+++ b/src/go/types/assignments.go
@@ -9,7 +9,7 @@ package types
 import (
 	"fmt"
 	"go/ast"
-	"go/token"
+	"strings"
 )
 
 // assignment reports whether x can be assigned to a variable of type T,
@@ -238,6 +238,58 @@ func (check *Checker) assignVar(lhs ast.Expr, x *operand) Type {
 	return x.typ
 }
 
+// operandTypes returns the list of types for the given operands.
+func operandTypes(list []*operand) (res []Type) {
+	for _, x := range list {
+		res = append(res, x.typ)
+	}
+	return res
+}
+
+// varTypes returns the list of types for the given variables.
+func varTypes(list []*Var) (res []Type) {
+	for _, x := range list {
+		res = append(res, x.typ)
+	}
+	return res
+}
+
+// typesSummary returns a string of the form "(t1, t2, ...)" where the
+// ti's are user-friendly string representations for the given types.
+// If variadic is set and the last type is a slice, its string is of
+// the form "...E" where E is the slice's element type.
+func (check *Checker) typesSummary(list []Type, variadic bool) string {
+	var res []string
+	for i, t := range list {
+		var s string
+		switch {
+		case t == nil:
+			fallthrough // should not happend but be cautious
+		case t == Typ[Invalid]:
+			s = ""
+		case isUntyped(t):
+			if isNumeric(t) {
+				// Do not imply a specific type requirement:
+				// "have number, want float64" is better than
+				// "have untyped int, want float64" or
+				// "have int, want float64".
+				s = "number"
+			} else {
+				// If we don't have a number, omit the "untyped" qualifier
+				// for compactness.
+				s = strings.Replace(t.(*Basic).name, "untyped ", "", -1)
+			}
+		case variadic && i == len(list)-1:
+			s = check.sprintf("...%s", t.(*Slice).elem)
+		}
+		if s == "" {
+			s = check.sprintf("%s", t)
+		}
+		res = append(res, s)
+	}
+	return "(" + strings.Join(res, ", ") + ")"
+}
+
 func (check *Checker) assignError(rhs []ast.Expr, nvars, nvals int) {
 	measure := func(x int, unit string) string {
 		s := fmt.Sprintf("%d %s", x, unit)
@@ -260,10 +312,10 @@ func (check *Checker) assignError(rhs []ast.Expr, nvars, nvals int) {
 	check.errorf(rhs0, _WrongAssignCount, "assignment mismatch: %s but %s", vars, vals)
 }
 
-// If returnPos is valid, initVars is called to type-check the assignment of
-// return expressions, and returnPos is the position of the return statement.
-func (check *Checker) initVars(lhs []*Var, origRHS []ast.Expr, returnPos token.Pos) {
-	rhs, commaOk := check.exprList(origRHS, len(lhs) == 2 && !returnPos.IsValid())
+// If returnStmt != nil, initVars is called to type-check the assignment
+// of return expressions, and returnStmt is the the return statement.
+func (check *Checker) initVars(lhs []*Var, origRHS []ast.Expr, returnStmt ast.Stmt) {
+	rhs, commaOk := check.exprList(origRHS, len(lhs) == 2 && returnStmt == nil)
 
 	if len(lhs) != len(rhs) {
 		// invalidate lhs
@@ -279,8 +331,20 @@ func (check *Checker) initVars(lhs []*Var, origRHS []ast.Expr, returnPos token.P
 				return
 			}
 		}
-		if returnPos.IsValid() {
-			check.errorf(atPos(returnPos), _WrongResultCount, "wrong number of return values (want %d, got %d)", len(lhs), len(rhs))
+		if returnStmt != nil {
+			var at positioner = returnStmt
+			qualifier := "not enough"
+			if len(rhs) > len(lhs) {
+				at = rhs[len(lhs)].expr // report at first extra value
+				qualifier = "too many"
+			} else if len(rhs) > 0 {
+				at = rhs[len(rhs)-1].expr // report at last value
+			}
+			check.errorf(at, _WrongResultCount, "%s return values\n\thave %s\n\twant %s",
+				qualifier,
+				check.typesSummary(operandTypes(rhs), false),
+				check.typesSummary(varTypes(lhs), false),
+			)
 			return
 		}
 		if compilerErrorMessages {
@@ -292,7 +356,7 @@ func (check *Checker) initVars(lhs []*Var, origRHS []ast.Expr, returnPos token.P
 	}
 
 	context := "assignment"
-	if returnPos.IsValid() {
+	if returnStmt != nil {
 		context = "return statement"
 	}
 
@@ -404,7 +468,7 @@ func (check *Checker) shortVarDecl(pos positioner, lhs, rhs []ast.Expr) {
 		}
 	}
 
-	check.initVars(lhsVars, rhs, token.NoPos)
+	check.initVars(lhsVars, rhs, nil)
 
 	// process function literals in rhs expressions before scope changes
 	check.processDelayed(top)
diff --git a/src/go/types/call.go b/src/go/types/call.go
index 940c0ff468..280ed05d1b 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -355,12 +355,25 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, targs []Type
 	}
 
 	// check argument count
-	switch {
-	case nargs < npars:
-		check.errorf(inNode(call, call.Rparen), _WrongArgCount, "not enough arguments in call to %s", call.Fun)
-		return
-	case nargs > npars:
-		check.errorf(args[npars], _WrongArgCount, "too many arguments in call to %s", call.Fun) // report at first extra argument
+	if nargs != npars {
+		var at positioner = call
+		qualifier := "not enough"
+		if nargs > npars {
+			at = args[npars].expr // report at first extra argument
+			qualifier = "too many"
+		} else {
+			at = atPos(call.Rparen) // report at closing )
+		}
+		// take care of empty parameter lists represented by nil tuples
+		var params []*Var
+		if sig.params != nil {
+			params = sig.params.vars
+		}
+		check.errorf(at, _WrongArgCount, "%s arguments in call to %s\n\thave %s\n\twant %s",
+			qualifier, call.Fun,
+			check.typesSummary(operandTypes(args), false),
+			check.typesSummary(varTypes(params), sig.variadic),
+		)
 		return
 	}
 
diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go
index a3be47e371..e296d13be9 100644
--- a/src/go/types/check_test.go
+++ b/src/go/types/check_test.go
@@ -51,7 +51,7 @@ var (
 var fset = token.NewFileSet()
 
 // Positioned errors are of the form filename:line:column: message .
-var posMsgRx = regexp.MustCompile(`^(.*:[0-9]+:[0-9]+): *(.*)`)
+var posMsgRx = regexp.MustCompile(`^(.*:[0-9]+:[0-9]+): *(?s)(.*)`)
 
 // splitError splits an error's error message into a position string
 // and the actual error message. If there's no position information,
diff --git a/src/go/types/decl.go b/src/go/types/decl.go
index c85087018c..2c51329be9 100644
--- a/src/go/types/decl.go
+++ b/src/go/types/decl.go
@@ -602,7 +602,7 @@ func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init ast.Expr) {
 		}
 	}
 
-	check.initVars(lhs, []ast.Expr{init}, token.NoPos)
+	check.initVars(lhs, []ast.Expr{init}, nil)
 }
 
 // isImportedConstraint reports whether typ is an imported type constraint.
diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go
index ee7d4e4cf1..06c9d3175d 100644
--- a/src/go/types/stmt.go
+++ b/src/go/types/stmt.go
@@ -519,7 +519,7 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
 				}
 			} else {
 				// return has results or result parameters are unnamed
-				check.initVars(res.vars, s.Results, s.Return)
+				check.initVars(res.vars, s.Results, s)
 			}
 		} else if len(s.Results) > 0 {
 			check.error(s.Results[0], _WrongResultCount, "no result values expected")
diff --git a/src/go/types/testdata/check/errors.src b/src/go/types/testdata/check/errors.src
index ff929217c4..7cdc5fb5ff 100644
--- a/src/go/types/testdata/check/errors.src
+++ b/src/go/types/testdata/check/errors.src
@@ -8,32 +8,38 @@ package errors
 // (matching messages are regular expressions, hence the \'s).
 func f(x int, m map[string]int) {
 	// no values
-	_ = f /* ERROR "f\(0, m\) \(no value\) used as value" */ (0, m)
+	_ = f /* ERROR f\(0, m\) \(no value\) used as value */ (0, m)
 
 	// built-ins
-	_ = println /* ERROR "println \(built-in\) must be called" */
+	_ = println // ERROR println \(built-in\) must be called
 
 	// types
-	_ = complex128 /* ERROR "complex128 \(type\) is not an expression" */
+	_ = complex128 // ERROR complex128 \(type\) is not an expression
 
 	// constants
 	const c1 = 991
 	const c2 float32 = 0.5
-	0 /* ERROR "0 \(untyped int constant\) is not used" */
-	c1 /* ERROR "c1 \(untyped int constant 991\) is not used" */
-	c2 /* ERROR "c2 \(constant 0.5 of type float32\) is not used" */
-	c1 /* ERROR "c1 \+ c2 \(constant 991.5 of type float32\) is not used" */ + c2
+	const c3 = "foo"
+	0 // ERROR 0 \(untyped int constant\) is not used
+	0.5 // ERROR 0.5 \(untyped float constant\) is not used
+	"foo" // ERROR "foo" \(untyped string constant\) is not used
+	c1 // ERROR c1 \(untyped int constant 991\) is not used
+	c2 // ERROR c2 \(constant 0.5 of type float32\) is not used
+	c1 /* ERROR c1 \+ c2 \(constant 991.5 of type float32\) is not used */ + c2
+	c3 // ERROR c3 \(untyped string constant "foo"\) is not used
 
 	// variables
-	x /* ERROR "x \(variable of type int\) is not used" */
+	x // ERROR x \(variable of type int\) is not used
 
 	// values
-	x /* ERROR "x != x \(untyped bool value\) is not used" */ != x
-	x /* ERROR "x \+ x \(value of type int\) is not used" */ + x
+	nil // ERROR nil is not used
+	( /* ERROR \(\*int\)\(nil\) \(value of type \*int\) is not used */ *int)(nil)
+	x /* ERROR x != x \(untyped bool value\) is not used */ != x
+	x /* ERROR x \+ x \(value of type int\) is not used */ + x
 
 	// value, ok's
 	const s = "foo"
-	m /* ERROR "m\[s\] \(map index expression of type int\) is not used" */ [s]
+	m /* ERROR m\[s\] \(map index expression of type int\) is not used */ [s]
 }
 
 // Valid ERROR comments can have a variety of forms.
diff --git a/src/go/types/testdata/check/expr3.src b/src/go/types/testdata/check/expr3.src
index 5117a0373b..b8f96dc611 100644
--- a/src/go/types/testdata/check/expr3.src
+++ b/src/go/types/testdata/check/expr3.src
@@ -493,20 +493,20 @@ func _calls() {
 	f1(0)
 	f1(x)
 	f1(10.0)
-	f1() /* ERROR "not enough arguments" */
-	f1(x, y /* ERROR "too many arguments" */ )
+	f1() /* ERROR "not enough arguments in call to f1\n\thave \(\)\n\twant \(int\)" */
+	f1(x, y /* ERROR "too many arguments in call to f1\n\thave \(int, float32\)\n\twant \(int\)" */ )
 	f1(s /* ERROR "cannot use .* in argument" */ )
 	f1(x ... /* ERROR "cannot use ..." */ )
 	f1(g0 /* ERROR "used as value" */ ())
 	f1(g1())
-	f1(g2 /* ERROR "too many arguments" */ ())
+	f1(g2 /* ERROR "too many arguments in call to f1\n\thave \(float32, string\)\n\twant \(int\)" */ ())
 
-	f2() /* ERROR "not enough arguments" */
-	f2(3.14) /* ERROR "not enough arguments" */
+	f2() /* ERROR "not enough arguments in call to f2\n\thave \(\)\n\twant \(float32, string\)" */
+	f2(3.14) /* ERROR "not enough arguments in call to f2\n\thave \(number\)\n\twant \(float32, string\)" */
 	f2(3.14, "foo")
 	f2(x /* ERROR "cannot use .* in argument" */ , "foo")
 	f2(g0 /* ERROR "used as value" */ ())
-	f2(g1()) /* ERROR "not enough arguments" */
+	f2(g1()) /* ERROR "not enough arguments in call to f2\n\thave \(int\)\n\twant \(float32, string\)" */
 	f2(g2())
 
 	fs() /* ERROR "not enough arguments" */
diff --git a/src/go/types/testdata/check/stmt0.src b/src/go/types/testdata/check/stmt0.src
index 2cce0b59b2..c7a718de70 100644
--- a/src/go/types/testdata/check/stmt0.src
+++ b/src/go/types/testdata/check/stmt0.src
@@ -29,10 +29,10 @@ func assignments0() (int, int) {
 
 	a, b, c = <- /* ERROR "cannot assign [1-9]+ values to [1-9]+ variables" */ ch
 
-	return /* ERROR "wrong number of return values" */
-	return /* ERROR "wrong number of return values" */ 1
+	return /* ERROR "not enough return values\n\thave \(\)\n\twant \(int, int\)" */
+	return 1 /* ERROR "not enough return values\n\thave \(number\)\n\twant \(int, int\)" */
 	return 1, 2
-	return /* ERROR "wrong number of return values" */ 1, 2, 3
+	return 1, 2, 3 /* ERROR "too many return values\n\thave \(number, number, number\)\n\twant \(int, int\)" */
 }
 
 func assignments1() {
@@ -81,7 +81,7 @@ func assignments1() {
 	// test cases for issue 5500
 	_ = func() (int, bool) {
 		var m map[int]int
-		return /* ERROR "wrong number of return values" */ m[0]
+		return m /* ERROR "not enough return values" */ [0]
 	}
 
 	g := func(int, bool){}
@@ -380,15 +380,15 @@ func returns0() {
 
 func returns1(x float64) (int, *float64) {
 	return 0, &x
-	return /* ERROR wrong number of return values */
+	return /* ERROR not enough return values */
 	return "foo" /* ERROR "cannot .* in return statement" */, x /* ERROR "cannot use .* in return statement" */
-	return /* ERROR wrong number of return values */ 0, &x, 1
+	return 0, &x, 1 /* ERROR too many return values */
 }
 
 func returns2() (a, b int) {
 	return
 	return 1, "foo" /* ERROR cannot use .* in return statement */
-	return /* ERROR wrong number of return values */ 1, 2, 3
+	return 1, 2, 3 /* ERROR too many return values */
 	{
 		type a int
 		return 1, 2
diff --git a/src/go/types/testdata/check/vardecl.src b/src/go/types/testdata/check/vardecl.src
index 54f5ef1e10..787f7878f1 100644
--- a/src/go/types/testdata/check/vardecl.src
+++ b/src/go/types/testdata/check/vardecl.src
@@ -175,7 +175,7 @@ func _() {
 
 func _() int {
 	var x, y int
-	return /* ERROR wrong number of return values */ x, y
+	return x, y /* ERROR too many return values */
 }
 
 // Short variable declarations must declare at least one new non-blank variable.

From 1ab677a797ab5cdb5c0248b2d63b753820e6ed49 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Fri, 26 Nov 2021 12:43:06 -0800
Subject: [PATCH 328/752] go/types: produce empty type set for invalid ~T

This is a clean port of CL 366278 from types2 to go/types.

For #49739.

Change-Id: I2e2cb739c02fcc07e012499c7b65b13b057875ea
Reviewed-on: https://go-review.googlesource.com/c/go/+/367197
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 .../types/testdata/fixedbugs/issue49739.go2   | 23 +++++++++++++++++++
 src/go/types/typeset.go                       | 16 ++++++++-----
 2 files changed, 33 insertions(+), 6 deletions(-)
 create mode 100644 src/go/types/testdata/fixedbugs/issue49739.go2

diff --git a/src/go/types/testdata/fixedbugs/issue49739.go2 b/src/go/types/testdata/fixedbugs/issue49739.go2
new file mode 100644
index 0000000000..46b1e71a3b
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue49739.go2
@@ -0,0 +1,23 @@
+// 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.
+
+// Verify that we get an empty type set (not just an error)
+// when using an invalid ~A.
+
+package p
+
+type A int
+type C interface {
+	~ /* ERROR invalid use of ~ */ A
+}
+
+func f[_ C]()              {}
+func g[_ interface{ C }]() {}
+func h[_ C | int]()        {}
+
+func _() {
+	_ = f[int /* ERROR cannot implement C \(empty type set\) */]
+	_ = g[int /* ERROR cannot implement interface{C} \(empty type set\) */]
+	_ = h[int]
+}
diff --git a/src/go/types/typeset.go b/src/go/types/typeset.go
index d98080069c..2928368735 100644
--- a/src/go/types/typeset.go
+++ b/src/go/types/typeset.go
@@ -365,14 +365,18 @@ func computeUnionTypeSet(check *Checker, pos token.Pos, utyp *Union) *_TypeSet {
 	var allTerms termlist
 	for _, t := range utyp.terms {
 		var terms termlist
-		switch u := under(t.typ).(type) {
-		case *Interface:
+		u := under(t.typ)
+		if ui, _ := u.(*Interface); ui != nil {
 			// For now we don't permit type parameters as constraints.
 			assert(!isTypeParam(t.typ))
-			terms = computeInterfaceTypeSet(check, pos, u).terms
-		default:
-			if t.typ == Typ[Invalid] {
-				continue
+			terms = computeInterfaceTypeSet(check, pos, ui).terms
+		} else if t.typ == Typ[Invalid] {
+			continue
+		} else {
+			if t.tilde && !Identical(t.typ, u) {
+				// There is no underlying type which is t.typ.
+				// The corresponding type set is empty.
+				t = nil // ∅ term
 			}
 			terms = termlist{(*term)(t)}
 		}

From bc32dd1b69b0629a54cfe50626e42eb4b75eb017 Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Fri, 26 Nov 2021 13:14:01 -0800
Subject: [PATCH 329/752] go/types: better error position for instantiation
 failure

This is a port of CL 366757 from types2 to go/types,
adjusted for the different handling of index expressions
in go/types.

For #49179.

Change-Id: Ic859eb09683134d055e28c8e0cb1f3814a87dc5c
Reviewed-on: https://go-review.googlesource.com/c/go/+/367198
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/go/types/builtins.go                      |  2 +-
 src/go/types/call.go                          | 39 ++++++++-----------
 src/go/types/mono.go                          |  7 ++--
 src/go/types/testdata/check/issues.go2        |  2 +-
 .../types/testdata/fixedbugs/issue39754.go2   |  5 +--
 .../types/testdata/fixedbugs/issue49179.go2   | 19 +++++++++
 src/go/types/typexpr.go                       | 13 ++-----
 7 files changed, 45 insertions(+), 42 deletions(-)
 create mode 100644 src/go/types/testdata/fixedbugs/issue49179.go2

diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go
index daeed81ed8..828220f257 100644
--- a/src/go/types/builtins.go
+++ b/src/go/types/builtins.go
@@ -130,7 +130,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b
 			arg(&x, i)
 			xlist = append(xlist, &x)
 		}
-		check.arguments(call, sig, nil, xlist) // discard result (we know the result type)
+		check.arguments(call, sig, nil, xlist, nil) // discard result (we know the result type)
 		// ok to continue even if check.arguments reported errors
 
 		x.mode = value
diff --git a/src/go/types/call.go b/src/go/types/call.go
index 280ed05d1b..4156d56d9f 100644
--- a/src/go/types/call.go
+++ b/src/go/types/call.go
@@ -51,16 +51,8 @@ func (check *Checker) funcInst(x *operand, ix *typeparams.IndexExpr) {
 	}
 	assert(got == want)
 
-	// determine argument positions (for error reporting)
-	// TODO(rFindley) use a positioner here? instantiate would need to be
-	//                updated accordingly.
-	poslist := make([]token.Pos, len(ix.Indices))
-	for i, x := range ix.Indices {
-		poslist[i] = x.Pos()
-	}
-
 	// instantiate function signature
-	res := check.instantiateSignature(x.Pos(), sig, targs, poslist)
+	res := check.instantiateSignature(x.Pos(), sig, targs, ix.Indices)
 	assert(res.TypeParams().Len() == 0) // signature is not generic anymore
 	check.recordInstance(ix.Orig, targs, res)
 	x.typ = res
@@ -68,7 +60,7 @@ func (check *Checker) funcInst(x *operand, ix *typeparams.IndexExpr) {
 	x.expr = ix.Orig
 }
 
-func (check *Checker) instantiateSignature(pos token.Pos, typ *Signature, targs []Type, posList []token.Pos) (res *Signature) {
+func (check *Checker) instantiateSignature(pos token.Pos, typ *Signature, targs []Type, xlist []ast.Expr) (res *Signature) {
 	assert(check != nil)
 	assert(len(targs) == typ.TypeParams().Len())
 
@@ -82,17 +74,17 @@ func (check *Checker) instantiateSignature(pos token.Pos, typ *Signature, targs
 	}
 
 	inst := check.instance(pos, typ, targs, check.bestContext(nil)).(*Signature)
-	assert(len(posList) <= len(targs))
+	assert(len(xlist) <= len(targs))
 	tparams := typ.TypeParams().list()
 	if i, err := check.verify(pos, tparams, targs); err != nil {
 		// best position for error reporting
 		pos := pos
-		if i < len(posList) {
-			pos = posList[i]
+		if i < len(xlist) {
+			pos = xlist[i].Pos()
 		}
-		check.softErrorf(atPos(pos), _InvalidTypeArg, err.Error())
+		check.softErrorf(atPos(pos), _InvalidTypeArg, "%s", err)
 	} else {
-		check.mono.recordInstance(check.pkg, pos, tparams, targs, posList)
+		check.mono.recordInstance(check.pkg, pos, tparams, targs, xlist)
 	}
 
 	return inst
@@ -184,21 +176,23 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 	}
 
 	// evaluate type arguments, if any
+	var xlist []ast.Expr
 	var targs []Type
 	if ix != nil {
-		targs = check.typeList(ix.Indices)
+		xlist = ix.Indices
+		targs = check.typeList(xlist)
 		if targs == nil {
 			check.use(call.Args...)
 			x.mode = invalid
 			x.expr = call
 			return statement
 		}
-		assert(len(targs) == len(ix.Indices))
+		assert(len(targs) == len(xlist))
 
 		// check number of type arguments (got) vs number of type parameters (want)
 		got, want := len(targs), sig.TypeParams().Len()
 		if got > want {
-			check.errorf(ix.Indices[want], _WrongTypeArgCount, "got %d type arguments but want %d", got, want)
+			check.errorf(xlist[want], _WrongTypeArgCount, "got %d type arguments but want %d", got, want)
 			check.use(call.Args...)
 			x.mode = invalid
 			x.expr = call
@@ -209,7 +203,7 @@ func (check *Checker) callExpr(x *operand, call *ast.CallExpr) exprKind {
 	// evaluate arguments
 	args, _ := check.exprList(call.Args, false)
 	isGeneric := sig.TypeParams().Len() > 0
-	sig = check.arguments(call, sig, targs, args)
+	sig = check.arguments(call, sig, targs, args, xlist)
 
 	if isGeneric && sig.TypeParams().Len() == 0 {
 		// Update the recorded type of call.Fun to its instantiated type.
@@ -286,7 +280,8 @@ func (check *Checker) exprList(elist []ast.Expr, allowCommaOk bool) (xlist []*op
 	return
 }
 
-func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, targs []Type, args []*operand) (rsig *Signature) {
+// xlist is the list of type argument expressions supplied in the source code.
+func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, targs []Type, args []*operand, xlist []ast.Expr) (rsig *Signature) {
 	rsig = sig
 
 	// TODO(gri) try to eliminate this extra verification loop
@@ -388,15 +383,13 @@ func (check *Checker) arguments(call *ast.CallExpr, sig *Signature, targs []Type
 				check.softErrorf(inNode(call, call.Lparen), _UnsupportedFeature, "implicit function instantiation requires go1.18 or later")
 			}
 		}
-		// TODO(gri) provide position information for targs so we can feed
-		//           it to the instantiate call for better error reporting
 		targs := check.infer(call, sig.TypeParams().list(), targs, sigParams, args)
 		if targs == nil {
 			return // error already reported
 		}
 
 		// compute result signature
-		rsig = check.instantiateSignature(call.Pos(), sig, targs, nil)
+		rsig = check.instantiateSignature(call.Pos(), sig, targs, xlist)
 		assert(rsig.TypeParams().Len() == 0) // signature is not generic anymore
 		check.recordInstance(call.Fun, targs, rsig)
 
diff --git a/src/go/types/mono.go b/src/go/types/mono.go
index d4d884393b..84e1e971b6 100644
--- a/src/go/types/mono.go
+++ b/src/go/types/mono.go
@@ -5,6 +5,7 @@
 package types
 
 import (
+	"go/ast"
 	"go/token"
 )
 
@@ -166,11 +167,11 @@ func (w *monoGraph) recordCanon(mpar, tpar *TypeParam) {
 
 // recordInstance records that the given type parameters were
 // instantiated with the corresponding type arguments.
-func (w *monoGraph) recordInstance(pkg *Package, pos token.Pos, tparams []*TypeParam, targs []Type, posList []token.Pos) {
+func (w *monoGraph) recordInstance(pkg *Package, pos token.Pos, tparams []*TypeParam, targs []Type, xlist []ast.Expr) {
 	for i, tpar := range tparams {
 		pos := pos
-		if i < len(posList) {
-			pos = posList[i]
+		if i < len(xlist) {
+			pos = xlist[i].Pos()
 		}
 		w.assign(pkg, pos, tpar, targs[i])
 	}
diff --git a/src/go/types/testdata/check/issues.go2 b/src/go/types/testdata/check/issues.go2
index fdb49d55f2..ac8ef789e5 100644
--- a/src/go/types/testdata/check/issues.go2
+++ b/src/go/types/testdata/check/issues.go2
@@ -48,7 +48,7 @@ func (*T) m2()
 
 func _() {
 	// TODO(rFindley) this error should be positioned on the 'T'.
-	f2 /* ERROR wrong method signature */ [T]()
+	f2[T /* ERROR wrong method signature */ ]()
 	f2[*T]()
 }
 
diff --git a/src/go/types/testdata/fixedbugs/issue39754.go2 b/src/go/types/testdata/fixedbugs/issue39754.go2
index cecbc88043..9edd239d7d 100644
--- a/src/go/types/testdata/fixedbugs/issue39754.go2
+++ b/src/go/types/testdata/fixedbugs/issue39754.go2
@@ -17,8 +17,5 @@ func f[V interface{}, A, B Box[V]]() {}
 func _() {
 	f[int, Optional[int], Optional[int]]()
 	_ = f[int, Optional[int], Optional /* ERROR does not implement Box */ [string]]
-	// TODO(gri) Provide better position information here.
-	//           See TODO in call.go, Checker.arguments.
-	// TODO(rFindley) Reconcile this error position with types2.
-	f /* ERROR does not implement Box */ [int, Optional[int], Optional[string]]()
+	_ = f[int, Optional[int], Optional /* ERROR Optional.* does not implement Box.* */ [string]]
 }
diff --git a/src/go/types/testdata/fixedbugs/issue49179.go2 b/src/go/types/testdata/fixedbugs/issue49179.go2
new file mode 100644
index 0000000000..7cba52aa25
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue49179.go2
@@ -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 p
+
+type SliceConstraint[T any] interface {
+	[]T
+}
+
+func Map[S SliceConstraint[E], E any](s S, f func(E) E) S {
+	return s
+}
+
+type MySlice []int
+
+func f(s MySlice) {
+	Map[MySlice /* ERROR MySlice does not implement SliceConstraint\[int\] */, int](s, nil)
+}
diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go
index 5664d8175f..0a74a875bc 100644
--- a/src/go/types/typexpr.go
+++ b/src/go/types/typexpr.go
@@ -11,7 +11,6 @@ import (
 	"go/ast"
 	"go/constant"
 	"go/internal/typeparams"
-	"go/token"
 	"strings"
 )
 
@@ -416,12 +415,6 @@ func (check *Checker) instantiatedType(ix *typeparams.IndexExpr, def *Named) (re
 		return Typ[Invalid]
 	}
 
-	// determine argument positions
-	posList := make([]token.Pos, len(targs))
-	for i, arg := range ix.Indices {
-		posList[i] = arg.Pos()
-	}
-
 	// create the instance
 	ctxt := check.bestContext(nil)
 	h := ctxt.instanceHash(orig, targs)
@@ -470,12 +463,12 @@ func (check *Checker) instantiatedType(ix *typeparams.IndexExpr, def *Named) (re
 			if i, err := check.verify(pos, inst.tparams.list(), inst.targs.list()); err != nil {
 				// best position for error reporting
 				pos := ix.Pos()
-				if i < len(posList) {
-					pos = posList[i]
+				if i < len(ix.Indices) {
+					pos = ix.Indices[i].Pos()
 				}
 				check.softErrorf(atPos(pos), _InvalidTypeArg, err.Error())
 			} else {
-				check.mono.recordInstance(check.pkg, pos, inst.tparams.list(), inst.targs.list(), posList)
+				check.mono.recordInstance(check.pkg, pos, inst.tparams.list(), inst.targs.list(), ix.Indices)
 			}
 		}
 

From ebd0b778c92c4dfc71195ef83d71116957e173ad Mon Sep 17 00:00:00 2001
From: Robert Griesemer 
Date: Fri, 26 Nov 2021 13:27:12 -0800
Subject: [PATCH 330/752] go/types: better error message for missing ~ in
 constraint

This is a port of CL 366758 from types2 to go/types.

For #49179.

Change-Id: I7e1c6ffb392d5c535cf901004b7acbe8c3be9b0f
Reviewed-on: https://go-review.googlesource.com/c/go/+/367199
Trust: Robert Griesemer 
Run-TryBot: Robert Griesemer 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/go/types/instantiate.go                   | 25 ++++++++++++++++---
 .../types/testdata/fixedbugs/issue49179.go2   | 20 ++++++++++++++-
 src/go/types/typeset.go                       |  2 ++
 3 files changed, 43 insertions(+), 4 deletions(-)

diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go
index 011fb8e540..597a6da624 100644
--- a/src/go/types/instantiate.go
+++ b/src/go/types/instantiate.go
@@ -239,9 +239,28 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error {
 	}
 
 	// Otherwise, V's type must be included in the iface type set.
-	if !Ti.typeSet().includes(V) {
-		// TODO(gri) report which type is missing
-		return errorf("%s does not implement %s", V, T)
+	var alt Type
+	if Ti.typeSet().is(func(t *term) bool {
+		if !t.includes(V) {
+			// If V ∉ t.typ but V ∈ ~t.typ then remember this type
+			// so we can suggest it as an alternative in the error
+			// message.
+			if alt == nil && !t.tilde && Identical(t.typ, under(t.typ)) {
+				tt := *t
+				tt.tilde = true
+				if tt.includes(V) {
+					alt = t.typ
+				}
+			}
+			return true
+		}
+		return false
+	}) {
+		if alt != nil {
+			return errorf("%s does not implement %s (possibly missing ~ for %s in constraint %s)", V, T, alt, T)
+		} else {
+			return errorf("%s does not implement %s", V, T)
+		}
 	}
 
 	return nil
diff --git a/src/go/types/testdata/fixedbugs/issue49179.go2 b/src/go/types/testdata/fixedbugs/issue49179.go2
index 7cba52aa25..d4c8a897c6 100644
--- a/src/go/types/testdata/fixedbugs/issue49179.go2
+++ b/src/go/types/testdata/fixedbugs/issue49179.go2
@@ -4,6 +4,24 @@
 
 package p
 
+func f1[P int | string]()            {}
+func f2[P ~int | string | float64]() {}
+func f3[P int](x P)                  {}
+
+type myInt int
+type myFloat float64
+
+func _() {
+	_ = f1[int]
+	_ = f1[myInt /* ERROR possibly missing ~ for int in constraint int\|string */]
+	_ = f2[myInt]
+	_ = f2[myFloat /* ERROR possibly missing ~ for float64 in constraint int\|string|float64 */]
+	var x myInt
+	f3 /* ERROR myInt does not implement int \(possibly missing ~ for int in constraint int\) */ (x)
+}
+
+// test case from the issue
+
 type SliceConstraint[T any] interface {
 	[]T
 }
@@ -15,5 +33,5 @@ func Map[S SliceConstraint[E], E any](s S, f func(E) E) S {
 type MySlice []int
 
 func f(s MySlice) {
-	Map[MySlice /* ERROR MySlice does not implement SliceConstraint\[int\] */, int](s, nil)
+	Map[MySlice /* ERROR MySlice does not implement SliceConstraint\[int\] \(possibly missing ~ for \[\]int in constraint SliceConstraint\[int\]\) */, int](s, nil)
 }
diff --git a/src/go/types/typeset.go b/src/go/types/typeset.go
index 2928368735..d39483f254 100644
--- a/src/go/types/typeset.go
+++ b/src/go/types/typeset.go
@@ -106,6 +106,8 @@ func (s *_TypeSet) hasTerms() bool { return !s.terms.isEmpty() && !s.terms.isAll
 func (s *_TypeSet) singleType() Type { return s.terms.singleType() }
 
 // includes reports whether t ∈ s.
+// TODO(gri) This function is not used anywhere anymore. Remove once we
+//           are clear that we don't need it elsewhere in the future.
 func (s *_TypeSet) includes(t Type) bool { return s.terms.includes(t) }
 
 // subsetOf reports whether s1 ⊆ s2.

From c402d64f37f819b0f2d9949c6895e342191d11d6 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 29 Nov 2021 12:21:46 -0500
Subject: [PATCH 331/752] go/types: consider structural restrictions in
 Implements

Fixes #49786

Change-Id: I4559d013399deda48bcb97aef3427ecf87a3ef26
Reviewed-on: https://go-review.googlesource.com/c/go/+/367515
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/cmd/compile/internal/types2/api.go      |  12 ++-
 src/cmd/compile/internal/types2/api_test.go | 103 +++++++++++++++++++
 src/go/types/api.go                         |  12 ++-
 src/go/types/api_test.go                    | 104 ++++++++++++++++++++
 4 files changed, 227 insertions(+), 4 deletions(-)

diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go
index 367cb8f700..4ea3989c39 100644
--- a/src/cmd/compile/internal/types2/api.go
+++ b/src/cmd/compile/internal/types2/api.go
@@ -440,8 +440,16 @@ func ConvertibleTo(V, T Type) bool {
 
 // Implements reports whether type V implements interface T.
 func Implements(V Type, T *Interface) bool {
-	f, _ := MissingMethod(V, T, true)
-	return f == nil
+	if T.Empty() {
+		// All types (even Typ[Invalid]) implement the empty interface.
+		return true
+	}
+	// Checker.implements suppresses errors for invalid types, so we need special
+	// handling here.
+	if V.Underlying() == Typ[Invalid] {
+		return false
+	}
+	return (*Checker)(nil).implements(V, T, nil) == nil
 }
 
 // Identical reports whether x and y are identical types.
diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go
index 9436a4ed97..4227397df9 100644
--- a/src/cmd/compile/internal/types2/api_test.go
+++ b/src/cmd/compile/internal/types2/api_test.go
@@ -2102,3 +2102,106 @@ func TestInstanceIdentity(t *testing.T) {
 		t.Errorf("mismatching types: a.A: %s, b.B: %s", a.Type(), b.Type())
 	}
 }
+
+func TestImplements(t *testing.T) {
+	const src = `
+package p
+
+type EmptyIface interface{}
+
+type I interface {
+	m()
+}
+
+type C interface {
+	m()
+	~int
+}
+
+type Integer interface{
+	int8 | int16 | int32 | int64
+}
+
+type EmptyTypeSet interface{
+	Integer
+	~string
+}
+
+type N1 int
+func (N1) m() {}
+
+type N2 int
+func (*N2) m() {}
+
+type N3 int
+func (N3) m(int) {}
+
+type N4 string
+func (N4) m()
+
+type Bad Bad // invalid type
+`
+
+	f, err := parseSrc("p.go", src)
+	if err != nil {
+		t.Fatal(err)
+	}
+	conf := Config{Error: func(error) {}}
+	pkg, _ := conf.Check(f.PkgName.Value, []*syntax.File{f}, nil)
+
+	scope := pkg.Scope()
+	var (
+		EmptyIface   = scope.Lookup("EmptyIface").Type().Underlying().(*Interface)
+		I            = scope.Lookup("I").Type().(*Named)
+		II           = I.Underlying().(*Interface)
+		C            = scope.Lookup("C").Type().(*Named)
+		CI           = C.Underlying().(*Interface)
+		Integer      = scope.Lookup("Integer").Type().Underlying().(*Interface)
+		EmptyTypeSet = scope.Lookup("EmptyTypeSet").Type().Underlying().(*Interface)
+		N1           = scope.Lookup("N1").Type()
+		N1p          = NewPointer(N1)
+		N2           = scope.Lookup("N2").Type()
+		N2p          = NewPointer(N2)
+		N3           = scope.Lookup("N3").Type()
+		N4           = scope.Lookup("N4").Type()
+		Bad          = scope.Lookup("Bad").Type()
+	)
+
+	tests := []struct {
+		t    Type
+		i    *Interface
+		want bool
+	}{
+		{I, II, true},
+		{I, CI, false},
+		{C, II, true},
+		{C, CI, true},
+		{Typ[Int8], Integer, true},
+		{Typ[Int64], Integer, true},
+		{Typ[String], Integer, false},
+		{EmptyTypeSet, II, true},
+		{EmptyTypeSet, EmptyTypeSet, true},
+		{Typ[Int], EmptyTypeSet, false},
+		{N1, II, true},
+		{N1, CI, true},
+		{N1p, II, true},
+		{N1p, CI, false},
+		{N2, II, false},
+		{N2, CI, false},
+		{N2p, II, true},
+		{N2p, CI, false},
+		{N3, II, false},
+		{N3, CI, false},
+		{N4, II, true},
+		{N4, CI, false},
+		{Bad, II, false},
+		{Bad, CI, false},
+		{Bad, EmptyIface, true},
+	}
+
+	for _, test := range tests {
+		if got := Implements(test.t, test.i); got != test.want {
+			t.Errorf("Implements(%s, %s) = %t, want %t", test.t, test.i, got, test.want)
+		}
+	}
+}
diff --git a/src/go/types/api.go b/src/go/types/api.go
index c115d07b41..51d58c49aa 100644
--- a/src/go/types/api.go
+++ b/src/go/types/api.go
@@ -436,8 +436,16 @@ func ConvertibleTo(V, T Type) bool {
 
 // Implements reports whether type V implements interface T.
 func Implements(V Type, T *Interface) bool {
-	f, _ := MissingMethod(V, T, true)
-	return f == nil
+	if T.Empty() {
+		// All types (even Typ[Invalid]) implement the empty interface.
+		return true
+	}
+	// Checker.implements suppresses errors for invalid types, so we need special
+	// handling here.
+	if V.Underlying() == Typ[Invalid] {
+		return false
+	}
+	return (*Checker)(nil).implements(V, T, nil) == nil
 }
 
 // Identical reports whether x and y are identical types.
diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go
index c8fda5521a..7b7baa7604 100644
--- a/src/go/types/api_test.go
+++ b/src/go/types/api_test.go
@@ -2093,3 +2093,107 @@ func TestInstanceIdentity(t *testing.T) {
 		t.Errorf("mismatching types: a.A: %s, b.B: %s", a.Type(), b.Type())
 	}
 }
+
+func TestImplements(t *testing.T) {
+	const src = `
+package p
+
+type EmptyIface interface{}
+
+type I interface {
+	m()
+}
+
+type C interface {
+	m()
+	~int
+}
+
+type Integer interface{
+	int8 | int16 | int32 | int64
+}
+
+type EmptyTypeSet interface{
+	Integer
+	~string
+}
+
+type N1 int
+func (N1) m() {}
+
+type N2 int
+func (*N2) m() {}
+
+type N3 int
+func (N3) m(int) {}
+
+type N4 string
+func (N4) m()
+
+type Bad Bad // invalid type
+`
+
+	fset := token.NewFileSet()
+	f, err := parser.ParseFile(fset, "p.go", src, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	conf := Config{Error: func(error) {}}
+	pkg, _ := conf.Check(f.Name.Name, fset, []*ast.File{f}, nil)
+
+	scope := pkg.Scope()
+	var (
+		EmptyIface   = scope.Lookup("EmptyIface").Type().Underlying().(*Interface)
+		I            = scope.Lookup("I").Type().(*Named)
+		II           = I.Underlying().(*Interface)
+		C            = scope.Lookup("C").Type().(*Named)
+		CI           = C.Underlying().(*Interface)
+		Integer      = scope.Lookup("Integer").Type().Underlying().(*Interface)
+		EmptyTypeSet = scope.Lookup("EmptyTypeSet").Type().Underlying().(*Interface)
+		N1           = scope.Lookup("N1").Type()
+		N1p          = NewPointer(N1)
+		N2           = scope.Lookup("N2").Type()
+		N2p          = NewPointer(N2)
+		N3           = scope.Lookup("N3").Type()
+		N4           = scope.Lookup("N4").Type()
+		Bad          = scope.Lookup("Bad").Type()
+	)
+
+	tests := []struct {
+		t    Type
+		i    *Interface
+		want bool
+	}{
+		{I, II, true},
+		{I, CI, false},
+		{C, II, true},
+		{C, CI, true},
+		{Typ[Int8], Integer, true},
+		{Typ[Int64], Integer, true},
+		{Typ[String], Integer, false},
+		{EmptyTypeSet, II, true},
+		{EmptyTypeSet, EmptyTypeSet, true},
+		{Typ[Int], EmptyTypeSet, false},
+		{N1, II, true},
+		{N1, CI, true},
+		{N1p, II, true},
+		{N1p, CI, false},
+		{N2, II, false},
+		{N2, CI, false},
+		{N2p, II, true},
+		{N2p, CI, false},
+		{N3, II, false},
+		{N3, CI, false},
+		{N4, II, true},
+		{N4, CI, false},
+		{Bad, II, false},
+		{Bad, CI, false},
+		{Bad, EmptyIface, true},
+	}
+
+	for _, test := range tests {
+		if got := Implements(test.t, test.i); got != test.want {
+			t.Errorf("Implements(%s, %s) = %t, want %t", test.t, test.i, got, test.want)
+		}
+	}
+}

From 186f375ecfdd0f9eae109464a93bb0ba8c993f45 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 29 Nov 2021 14:52:54 -0500
Subject: [PATCH 332/752] go/types: ensure that constructed type parameters are
 immutable

TypeParam.iface may mutate TypeParam.bound in the event that the type
parameter bound is not an interface.

Ensure that iface() is called before the type-checking pass returns, and
before NewTypeParam or TypeParam.SetConstraint exits.

Fixes #49788

Change-Id: I72279acf5f0223161671c04887bc2c3df4158927
Reviewed-on: https://go-review.googlesource.com/c/go/+/367614
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 src/cmd/compile/internal/types2/typeparam.go | 17 ++++++++++++++++-
 src/go/types/typeparam.go                    | 18 ++++++++++++++++--
 2 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/types2/typeparam.go b/src/cmd/compile/internal/types2/typeparam.go
index 8dd04ff408..e32063a0af 100644
--- a/src/cmd/compile/internal/types2/typeparam.go
+++ b/src/cmd/compile/internal/types2/typeparam.go
@@ -21,7 +21,7 @@ type TypeParam struct {
 	id    uint64    // unique id, for debugging only
 	obj   *TypeName // corresponding type name
 	index int       // type parameter index in source order, starting at 0
-	bound Type      // any type, but eventually an *Interface for correct programs (see TypeParam.iface)
+	bound Type      // any type, but underlying is eventually *Interface for correct programs (see TypeParam.iface)
 }
 
 // Obj returns the type name for the type parameter t.
@@ -47,6 +47,15 @@ func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
 	if obj.typ == nil {
 		obj.typ = typ
 	}
+	// iface may mutate typ.bound, so we must ensure that iface() is called
+	// at least once before the resulting TypeParam escapes.
+	if check != nil {
+		check.later(func() {
+			typ.iface()
+		})
+	} else if constraint != nil {
+		typ.iface()
+	}
 	return typ
 }
 
@@ -62,11 +71,17 @@ func (t *TypeParam) Constraint() Type {
 }
 
 // SetConstraint sets the type constraint for t.
+//
+// SetConstraint should not be called concurrently, but once SetConstraint
+// returns the receiver t is safe for concurrent use.
 func (t *TypeParam) SetConstraint(bound Type) {
 	if bound == nil {
 		panic("nil constraint")
 	}
 	t.bound = bound
+	// iface may mutate t.bound (if bound is not an interface), so ensure that
+	// this is done before returning.
+	t.iface()
 }
 
 func (t *TypeParam) Underlying() Type {
diff --git a/src/go/types/typeparam.go b/src/go/types/typeparam.go
index 7cce1f7e35..03ba9be55c 100644
--- a/src/go/types/typeparam.go
+++ b/src/go/types/typeparam.go
@@ -24,7 +24,7 @@ type TypeParam struct {
 	id    uint64    // unique id, for debugging only
 	obj   *TypeName // corresponding type name
 	index int       // type parameter index in source order, starting at 0
-	bound Type      // any type, but eventually an *Interface for correct programs (see TypeParam.iface)
+	bound Type      // any type, but underlying is eventually *Interface for correct programs (see TypeParam.iface)
 }
 
 // NewTypeParam returns a new TypeParam. Type parameters may be set on a Named
@@ -47,6 +47,15 @@ func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
 	if obj.typ == nil {
 		obj.typ = typ
 	}
+	// iface may mutate typ.bound, so we must ensure that iface() is called
+	// at least once before the resulting TypeParam escapes.
+	if check != nil {
+		check.later(func() {
+			typ.iface()
+		})
+	} else if constraint != nil {
+		typ.iface()
+	}
 	return typ
 }
 
@@ -65,11 +74,17 @@ func (t *TypeParam) Constraint() Type {
 }
 
 // SetConstraint sets the type constraint for t.
+//
+// SetConstraint should not be called concurrently, but once SetConstraint
+// returns the receiver t is safe for concurrent use.
 func (t *TypeParam) SetConstraint(bound Type) {
 	if bound == nil {
 		panic("nil constraint")
 	}
 	t.bound = bound
+	// iface may mutate t.bound (if bound is not an interface), so ensure that
+	// this is done before returning.
+	t.iface()
 }
 
 func (t *TypeParam) Underlying() Type {
@@ -104,7 +119,6 @@ func (t *TypeParam) iface() *Interface {
 	}
 
 	// If we don't have an interface, wrap constraint into an implicit interface.
-	// TODO(gri) mark it as implicit - see comment in Checker.bound
 	if ityp == nil {
 		ityp = NewInterfaceType(nil, []Type{bound})
 		ityp.implicit = true

From 3ca57c7fb8bfc9b8b633f71a7aaa9de5fe76f63d Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Mon, 29 Nov 2021 17:39:19 -0500
Subject: [PATCH 333/752] go/types, types2: handle case of no specific target
 types in conversion

Avoid a panic by handling the case of no specific target type in a type
parameter to type parameter conversions.

Fixes #49864

Change-Id: I117dd80cc9d47c8c1e168f1caf0f281726270c84
Reviewed-on: https://go-review.googlesource.com/c/go/+/367616
Trust: Robert Findley 
Run-TryBot: Robert Findley 
Reviewed-by: Robert Griesemer 
TryBot-Result: Go Bot 
---
 src/cmd/compile/internal/types2/conversions.go           | 3 +++
 .../internal/types2/testdata/fixedbugs/issue49864.go2    | 9 +++++++++
 src/go/types/conversions.go                              | 3 +++
 src/go/types/testdata/fixedbugs/issue49864.go2           | 9 +++++++++
 4 files changed, 24 insertions(+)
 create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue49864.go2
 create mode 100644 src/go/types/testdata/fixedbugs/issue49864.go2

diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index 47f9ac0a5a..253868cf93 100644
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -233,6 +233,9 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 			}
 			x.typ = V.typ
 			return Tp.is(func(T *term) bool {
+				if T == nil {
+					return false // no specific types
+				}
 				if !x.convertibleTo(check, T.typ, cause) {
 					errorf("cannot convert %s (in %s) to %s (in %s)", V.typ, Vp, T.typ, Tp)
 					return false
diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49864.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49864.go2
new file mode 100644
index 0000000000..0437e74a64
--- /dev/null
+++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49864.go2
@@ -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 p
+
+func _[P ~int, Q any](p P) {
+	_ = Q(p /* ERROR cannot convert */ )
+}
diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go
index 5995d5920f..fb3771635d 100644
--- a/src/go/types/conversions.go
+++ b/src/go/types/conversions.go
@@ -224,6 +224,9 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool {
 			}
 			x.typ = V.typ
 			return Tp.is(func(T *term) bool {
+				if T == nil {
+					return false // no specific types
+				}
 				if !x.convertibleTo(check, T.typ, cause) {
 					errorf("cannot convert %s (in %s) to %s (in %s)", V.typ, Vp, T.typ, Tp)
 					return false
diff --git a/src/go/types/testdata/fixedbugs/issue49864.go2 b/src/go/types/testdata/fixedbugs/issue49864.go2
new file mode 100644
index 0000000000..0437e74a64
--- /dev/null
+++ b/src/go/types/testdata/fixedbugs/issue49864.go2
@@ -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 p
+
+func _[P ~int, Q any](p P) {
+	_ = Q(p /* ERROR cannot convert */ )
+}

From f90a42b41080cf5a289f151f2166d0d0a795e836 Mon Sep 17 00:00:00 2001
From: Dan Scales 
Date: Mon, 29 Nov 2021 12:04:42 -0800
Subject: [PATCH 334/752] cmd/compile: change iexportVersionGeneric to 2

Don't expect/allow generics-related info in iexportVersion 1, now that
we increased the export version to 2.

Fixes #49853

Change-Id: I9bacee7f8e7cb9bb3b02a00084fad77edd220121
Reviewed-on: https://go-review.googlesource.com/c/go/+/367634
Trust: Dan Scales 
Run-TryBot: Dan Scales 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
Reviewed-by: Heschi Kreinick 
---
 src/cmd/compile/internal/importer/iimport.go  | 2 +-
 src/cmd/compile/internal/typecheck/iexport.go | 2 +-
 src/go/internal/gcimporter/iimport.go         | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/cmd/compile/internal/importer/iimport.go b/src/cmd/compile/internal/importer/iimport.go
index 1aa3b7b6a8..23d6ca350e 100644
--- a/src/cmd/compile/internal/importer/iimport.go
+++ b/src/cmd/compile/internal/importer/iimport.go
@@ -45,7 +45,7 @@ func (r *intReader) uint64() uint64 {
 const (
 	iexportVersionGo1_11   = 0
 	iexportVersionPosCol   = 1
-	iexportVersionGenerics = 1 // probably change to 2 before release
+	iexportVersionGenerics = 2
 	iexportVersionGo1_18   = 2
 
 	iexportVersionCurrent = 2
diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go
index 9bd1f626fe..7ebabe7314 100644
--- a/src/cmd/compile/internal/typecheck/iexport.go
+++ b/src/cmd/compile/internal/typecheck/iexport.go
@@ -261,7 +261,7 @@ import (
 const (
 	iexportVersionGo1_11   = 0
 	iexportVersionPosCol   = 1
-	iexportVersionGenerics = 1 // probably change to 2 before release
+	iexportVersionGenerics = 2
 	iexportVersionGo1_18   = 2
 
 	iexportVersionCurrent = 2
diff --git a/src/go/internal/gcimporter/iimport.go b/src/go/internal/gcimporter/iimport.go
index 49ea64392a..d7fc3ee7a9 100644
--- a/src/go/internal/gcimporter/iimport.go
+++ b/src/go/internal/gcimporter/iimport.go
@@ -46,7 +46,7 @@ func (r *intReader) uint64() uint64 {
 const (
 	iexportVersionGo1_11   = 0
 	iexportVersionPosCol   = 1
-	iexportVersionGenerics = 1 // probably change to 2 before release
+	iexportVersionGenerics = 2
 	iexportVersionGo1_18   = 2
 
 	iexportVersionCurrent = 2

From f463b20789c89f0d22e56663a34e57a942f945cf Mon Sep 17 00:00:00 2001
From: "Jason A. Donenfeld" 
Date: Mon, 29 Nov 2021 15:07:04 -0500
Subject: [PATCH 335/752] runtime: keep //go:cgo_unsafe_args arguments alive to
 prevent GC

When syscall's DLL.FindProc calls into syscall_getprocaddress with a
byte slice pointer, we need to keep those bytes alive. Otherwise the GC
will collect the allocation, and we wind up calling `GetProcAddress` on
garbage, which showed up as various flakes in the builders. It turns out
that this problem extends to many uses of //go:cgo_unsafe_args
throughout, on all platforms. So this patch fixes the issue by keeping
non-integer pointer arguments alive through their invocation in
//go:cgo_unsafe_args functions.

Fixes #49731.

Change-Id: I93e4fbc2e8e210cb3fc53149708758bb33f2f9c7
Reviewed-on: https://go-review.googlesource.com/c/go/+/367654
Trust: Jason A. Donenfeld 
Run-TryBot: Jason A. Donenfeld 
Reviewed-by: Matthew Dempsky 
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Patrik Nyblom 
TryBot-Result: Go Bot 
---
 src/runtime/sys_darwin.go       | 94 +++++++++++++++++++++++++++------
 src/runtime/sys_darwin_arm64.go |  4 +-
 src/runtime/sys_openbsd.go      | 22 ++++++--
 src/runtime/sys_openbsd1.go     |  5 +-
 src/runtime/sys_openbsd2.go     | 36 +++++++++++--
 src/runtime/syscall_solaris.go  |  2 +
 src/runtime/syscall_windows.go  |  4 ++
 7 files changed, 138 insertions(+), 29 deletions(-)

diff --git a/src/runtime/sys_darwin.go b/src/runtime/sys_darwin.go
index 9af4cf18f8..80dd1a0378 100644
--- a/src/runtime/sys_darwin.go
+++ b/src/runtime/sys_darwin.go
@@ -105,28 +105,38 @@ func syscallNoErr()
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_attr_init(attr *pthreadattr) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_init_trampoline)), unsafe.Pointer(&attr))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_init_trampoline)), unsafe.Pointer(&attr))
+	KeepAlive(attr)
+	return ret
 }
 func pthread_attr_init_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_attr_getstacksize(attr *pthreadattr, size *uintptr) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_getstacksize_trampoline)), unsafe.Pointer(&attr))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_getstacksize_trampoline)), unsafe.Pointer(&attr))
+	KeepAlive(attr)
+	KeepAlive(size)
+	return ret
 }
 func pthread_attr_getstacksize_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_attr_setdetachstate(attr *pthreadattr, state int) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_setdetachstate_trampoline)), unsafe.Pointer(&attr))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_setdetachstate_trampoline)), unsafe.Pointer(&attr))
+	KeepAlive(attr)
+	return ret
 }
 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(abi.FuncPCABI0(pthread_create_trampoline)), unsafe.Pointer(&attr))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_create_trampoline)), unsafe.Pointer(&attr))
+	KeepAlive(attr)
+	KeepAlive(arg) // Just for consistency. Arg of course needs to be kept alive for the start function.
+	return ret
 }
 func pthread_create_trampoline()
 
@@ -175,6 +185,7 @@ func mmap_trampoline()
 //go:cgo_unsafe_args
 func munmap(addr unsafe.Pointer, n uintptr) {
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(munmap_trampoline)), unsafe.Pointer(&addr))
+	KeepAlive(addr) // Just for consistency. Hopefully addr is not a Go address.
 }
 func munmap_trampoline()
 
@@ -182,6 +193,7 @@ func munmap_trampoline()
 //go:cgo_unsafe_args
 func madvise(addr unsafe.Pointer, n uintptr, flags int32) {
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(madvise_trampoline)), unsafe.Pointer(&addr))
+	KeepAlive(addr) // Just for consistency. Hopefully addr is not a Go address.
 }
 func madvise_trampoline()
 
@@ -189,13 +201,16 @@ func madvise_trampoline()
 //go:cgo_unsafe_args
 func mlock(addr unsafe.Pointer, n uintptr) {
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(mlock_trampoline)), unsafe.Pointer(&addr))
+	KeepAlive(addr) // Just for consistency. Hopefully addr is not a Go address.
 }
 func mlock_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func read(fd int32, p unsafe.Pointer, n int32) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(read_trampoline)), unsafe.Pointer(&fd))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(read_trampoline)), unsafe.Pointer(&fd))
+	KeepAlive(p)
+	return ret
 }
 func read_trampoline()
 
@@ -239,14 +254,18 @@ func usleep_no_g(usec uint32) {
 //go:nosplit
 //go:cgo_unsafe_args
 func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(write_trampoline)), unsafe.Pointer(&fd))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(write_trampoline)), unsafe.Pointer(&fd))
+	KeepAlive(p)
+	return ret
 }
 func write_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func open(name *byte, mode, perm int32) (ret int32) {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(open_trampoline)), unsafe.Pointer(&name))
+	ret = libcCall(unsafe.Pointer(abi.FuncPCABI0(open_trampoline)), unsafe.Pointer(&name))
+	KeepAlive(name)
+	return
 }
 func open_trampoline()
 
@@ -285,6 +304,8 @@ func walltime_trampoline()
 //go:cgo_unsafe_args
 func sigaction(sig uint32, new *usigactiont, old *usigactiont) {
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(sigaction_trampoline)), unsafe.Pointer(&sig))
+	KeepAlive(new)
+	KeepAlive(old)
 }
 func sigaction_trampoline()
 
@@ -292,6 +313,8 @@ func sigaction_trampoline()
 //go:cgo_unsafe_args
 func sigprocmask(how uint32, new *sigset, old *sigset) {
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(sigprocmask_trampoline)), unsafe.Pointer(&how))
+	KeepAlive(new)
+	KeepAlive(old)
 }
 func sigprocmask_trampoline()
 
@@ -306,6 +329,8 @@ func sigaltstack(new *stackt, old *stackt) {
 		new.ss_size = 32768
 	}
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(sigaltstack_trampoline)), unsafe.Pointer(&new))
+	KeepAlive(new)
+	KeepAlive(old)
 }
 func sigaltstack_trampoline()
 
@@ -320,20 +345,32 @@ func raiseproc_trampoline()
 //go:cgo_unsafe_args
 func setitimer(mode int32, new, old *itimerval) {
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(setitimer_trampoline)), unsafe.Pointer(&mode))
+	KeepAlive(new)
+	KeepAlive(old)
 }
 func setitimer_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func sysctl(mib *uint32, miblen uint32, oldp *byte, oldlenp *uintptr, newp *byte, newlen uintptr) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(sysctl_trampoline)), unsafe.Pointer(&mib))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(sysctl_trampoline)), unsafe.Pointer(&mib))
+	KeepAlive(mib)
+	KeepAlive(oldp)
+	KeepAlive(oldlenp)
+	KeepAlive(newp)
+	return ret
 }
 func sysctl_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func sysctlbyname(name *byte, oldp *byte, oldlenp *uintptr, newp *byte, newlen uintptr) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(sysctlbyname_trampoline)), unsafe.Pointer(&name))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(sysctlbyname_trampoline)), unsafe.Pointer(&name))
+	KeepAlive(name)
+	KeepAlive(oldp)
+	KeepAlive(oldlenp)
+	KeepAlive(newp)
+	return ret
 }
 func sysctlbyname_trampoline()
 
@@ -355,56 +392,79 @@ 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(abi.FuncPCABI0(kevent_trampoline)), unsafe.Pointer(&kq))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(kevent_trampoline)), unsafe.Pointer(&kq))
+	KeepAlive(ch)
+	KeepAlive(ev)
+	KeepAlive(ts)
+	return ret
 }
 func kevent_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_mutex_init(m *pthreadmutex, attr *pthreadmutexattr) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_init_trampoline)), unsafe.Pointer(&m))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_init_trampoline)), unsafe.Pointer(&m))
+	KeepAlive(m)
+	KeepAlive(attr)
+	return ret
 }
 func pthread_mutex_init_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_mutex_lock(m *pthreadmutex) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_lock_trampoline)), unsafe.Pointer(&m))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_lock_trampoline)), unsafe.Pointer(&m))
+	KeepAlive(m)
+	return ret
 }
 func pthread_mutex_lock_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_mutex_unlock(m *pthreadmutex) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_unlock_trampoline)), unsafe.Pointer(&m))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_unlock_trampoline)), unsafe.Pointer(&m))
+	KeepAlive(m)
+	return ret
 }
 func pthread_mutex_unlock_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_cond_init(c *pthreadcond, attr *pthreadcondattr) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_init_trampoline)), unsafe.Pointer(&c))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_init_trampoline)), unsafe.Pointer(&c))
+	KeepAlive(c)
+	KeepAlive(attr)
+	return ret
 }
 func pthread_cond_init_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_cond_wait(c *pthreadcond, m *pthreadmutex) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_wait_trampoline)), unsafe.Pointer(&c))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_wait_trampoline)), unsafe.Pointer(&c))
+	KeepAlive(c)
+	KeepAlive(m)
+	return ret
 }
 func pthread_cond_wait_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_cond_timedwait_relative_np(c *pthreadcond, m *pthreadmutex, t *timespec) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_timedwait_relative_np_trampoline)), unsafe.Pointer(&c))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_timedwait_relative_np_trampoline)), unsafe.Pointer(&c))
+	KeepAlive(c)
+	KeepAlive(m)
+	KeepAlive(t)
+	return ret
 }
 func pthread_cond_timedwait_relative_np_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_cond_signal(c *pthreadcond) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_signal_trampoline)), unsafe.Pointer(&c))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_signal_trampoline)), unsafe.Pointer(&c))
+	KeepAlive(c)
+	return ret
 }
 func pthread_cond_signal_trampoline()
 
diff --git a/src/runtime/sys_darwin_arm64.go b/src/runtime/sys_darwin_arm64.go
index e6d4c1be48..6170f4fdda 100644
--- a/src/runtime/sys_darwin_arm64.go
+++ b/src/runtime/sys_darwin_arm64.go
@@ -15,7 +15,9 @@ import (
 //go:nosplit
 //go:cgo_unsafe_args
 func g0_pthread_key_create(k *pthreadkey, destructor uintptr) int32 {
-	return asmcgocall(unsafe.Pointer(abi.FuncPCABI0(pthread_key_create_trampoline)), unsafe.Pointer(&k))
+	ret := asmcgocall(unsafe.Pointer(abi.FuncPCABI0(pthread_key_create_trampoline)), unsafe.Pointer(&k))
+	KeepAlive(k)
+	return ret
 }
 func pthread_key_create_trampoline()
 
diff --git a/src/runtime/sys_openbsd.go b/src/runtime/sys_openbsd.go
index 9f3a25fcf8..c4b8489612 100644
--- a/src/runtime/sys_openbsd.go
+++ b/src/runtime/sys_openbsd.go
@@ -17,35 +17,47 @@ import (
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_attr_init(attr *pthreadattr) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_init_trampoline)), unsafe.Pointer(&attr))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_init_trampoline)), unsafe.Pointer(&attr))
+	KeepAlive(attr)
+	return ret
 }
 func pthread_attr_init_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_attr_destroy(attr *pthreadattr) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_destroy_trampoline)), unsafe.Pointer(&attr))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_destroy_trampoline)), unsafe.Pointer(&attr))
+	KeepAlive(attr)
+	return ret
 }
 func pthread_attr_destroy_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_attr_getstacksize(attr *pthreadattr, size *uintptr) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_getstacksize_trampoline)), unsafe.Pointer(&attr))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_getstacksize_trampoline)), unsafe.Pointer(&attr))
+	KeepAlive(attr)
+	KeepAlive(size)
+	return ret
 }
 func pthread_attr_getstacksize_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func pthread_attr_setdetachstate(attr *pthreadattr, state int) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_setdetachstate_trampoline)), unsafe.Pointer(&attr))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_setdetachstate_trampoline)), unsafe.Pointer(&attr))
+	KeepAlive(attr)
+	return ret
 }
 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(abi.FuncPCABI0(pthread_create_trampoline)), unsafe.Pointer(&attr))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_create_trampoline)), unsafe.Pointer(&attr))
+	KeepAlive(attr)
+	KeepAlive(arg) // Just for consistency. Arg of course needs to be kept alive for the start function.
+	return ret
 }
 func pthread_create_trampoline()
 
diff --git a/src/runtime/sys_openbsd1.go b/src/runtime/sys_openbsd1.go
index 4b80f60226..d852e3c58a 100644
--- a/src/runtime/sys_openbsd1.go
+++ b/src/runtime/sys_openbsd1.go
@@ -14,7 +14,10 @@ import (
 //go:nosplit
 //go:cgo_unsafe_args
 func thrsleep(ident uintptr, clock_id int32, tsp *timespec, lock uintptr, abort *uint32) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(thrsleep_trampoline)), unsafe.Pointer(&ident))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(thrsleep_trampoline)), unsafe.Pointer(&ident))
+	KeepAlive(tsp)
+	KeepAlive(abort)
+	return ret
 }
 func thrsleep_trampoline()
 
diff --git a/src/runtime/sys_openbsd2.go b/src/runtime/sys_openbsd2.go
index c936fbb494..a7786fe65a 100644
--- a/src/runtime/sys_openbsd2.go
+++ b/src/runtime/sys_openbsd2.go
@@ -56,6 +56,7 @@ func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (un
 		ret2            int
 	}{addr, n, prot, flags, fd, off, nil, 0}
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(mmap_trampoline)), unsafe.Pointer(&args))
+	KeepAlive(addr) // Just for consistency. Hopefully addr is not a Go address.
 	return args.ret1, args.ret2
 }
 func mmap_trampoline()
@@ -64,6 +65,7 @@ func mmap_trampoline()
 //go:cgo_unsafe_args
 func munmap(addr unsafe.Pointer, n uintptr) {
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(munmap_trampoline)), unsafe.Pointer(&addr))
+	KeepAlive(addr) // Just for consistency. Hopefully addr is not a Go address.
 }
 func munmap_trampoline()
 
@@ -71,13 +73,16 @@ func munmap_trampoline()
 //go:cgo_unsafe_args
 func madvise(addr unsafe.Pointer, n uintptr, flags int32) {
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(madvise_trampoline)), unsafe.Pointer(&addr))
+	KeepAlive(addr) // Just for consistency. Hopefully addr is not a Go address.
 }
 func madvise_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func open(name *byte, mode, perm int32) (ret int32) {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(open_trampoline)), unsafe.Pointer(&name))
+	ret = libcCall(unsafe.Pointer(abi.FuncPCABI0(open_trampoline)), unsafe.Pointer(&name))
+	KeepAlive(name)
+	return
 }
 func open_trampoline()
 
@@ -91,14 +96,18 @@ func close_trampoline()
 //go:nosplit
 //go:cgo_unsafe_args
 func read(fd int32, p unsafe.Pointer, n int32) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(read_trampoline)), unsafe.Pointer(&fd))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(read_trampoline)), unsafe.Pointer(&fd))
+	KeepAlive(p)
+	return ret
 }
 func read_trampoline()
 
 //go:nosplit
 //go:cgo_unsafe_args
 func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
-	return libcCall(unsafe.Pointer(abi.FuncPCABI0(write_trampoline)), unsafe.Pointer(&fd))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(write_trampoline)), unsafe.Pointer(&fd))
+	KeepAlive(p)
+	return ret
 }
 func write_trampoline()
 
@@ -121,6 +130,8 @@ func pipe2_trampoline()
 //go:cgo_unsafe_args
 func setitimer(mode int32, new, old *itimerval) {
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(setitimer_trampoline)), unsafe.Pointer(&mode))
+	KeepAlive(new)
+	KeepAlive(old)
 }
 func setitimer_trampoline()
 
@@ -140,7 +151,12 @@ func usleep_no_g(usec uint32) {
 //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(abi.FuncPCABI0(sysctl_trampoline)), unsafe.Pointer(&mib))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(sysctl_trampoline)), unsafe.Pointer(&mib))
+	KeepAlive(mib)
+	KeepAlive(out)
+	KeepAlive(size)
+	KeepAlive(dst)
+	return ret
 }
 func sysctl_trampoline()
 
@@ -184,7 +200,11 @@ 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(abi.FuncPCABI0(kevent_trampoline)), unsafe.Pointer(&kq))
+	ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(kevent_trampoline)), unsafe.Pointer(&kq))
+	KeepAlive(ch)
+	KeepAlive(ev)
+	KeepAlive(ts)
+	return ret
 }
 func kevent_trampoline()
 
@@ -192,6 +212,8 @@ func kevent_trampoline()
 //go:cgo_unsafe_args
 func sigaction(sig uint32, new *sigactiont, old *sigactiont) {
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(sigaction_trampoline)), unsafe.Pointer(&sig))
+	KeepAlive(new)
+	KeepAlive(old)
 }
 func sigaction_trampoline()
 
@@ -201,6 +223,8 @@ func sigprocmask(how uint32, new *sigset, old *sigset) {
 	// sigprocmask is called from sigsave, which is called from needm.
 	// As such, we have to be able to run with no g here.
 	asmcgocall_no_g(unsafe.Pointer(abi.FuncPCABI0(sigprocmask_trampoline)), unsafe.Pointer(&how))
+	KeepAlive(new)
+	KeepAlive(old)
 }
 func sigprocmask_trampoline()
 
@@ -208,6 +232,8 @@ func sigprocmask_trampoline()
 //go:cgo_unsafe_args
 func sigaltstack(new *stackt, old *stackt) {
 	libcCall(unsafe.Pointer(abi.FuncPCABI0(sigaltstack_trampoline)), unsafe.Pointer(&new))
+	KeepAlive(new)
+	KeepAlive(old)
 }
 func sigaltstack_trampoline()
 
diff --git a/src/runtime/syscall_solaris.go b/src/runtime/syscall_solaris.go
index 15be8e1c61..e270e271c0 100644
--- a/src/runtime/syscall_solaris.go
+++ b/src/runtime/syscall_solaris.go
@@ -312,6 +312,8 @@ func syscall_wait4(pid uintptr, wstatus *uint32, options uintptr, rusage unsafe.
 	entersyscallblock()
 	asmcgocall(unsafe.Pointer(&asmsysvicall6x), unsafe.Pointer(&call))
 	exitsyscall()
+	KeepAlive(wstatus)
+	KeepAlive(rusage)
 	return int(call.r1), call.err
 }
 
diff --git a/src/runtime/syscall_windows.go b/src/runtime/syscall_windows.go
index da181f2a8d..e76b403ade 100644
--- a/src/runtime/syscall_windows.go
+++ b/src/runtime/syscall_windows.go
@@ -422,6 +422,8 @@ func syscall_loadsystemlibrary(filename *uint16, absoluteFilepath *uint16) (hand
 	}
 
 	cgocall(asmstdcallAddr, unsafe.Pointer(c))
+	KeepAlive(filename)
+	KeepAlive(absoluteFilepath)
 	handle = c.r1
 	if handle == 0 {
 		err = c.err
@@ -441,6 +443,7 @@ func syscall_loadlibrary(filename *uint16) (handle, err uintptr) {
 	c.n = 1
 	c.args = uintptr(noescape(unsafe.Pointer(&filename)))
 	cgocall(asmstdcallAddr, unsafe.Pointer(c))
+	KeepAlive(filename)
 	handle = c.r1
 	if handle == 0 {
 		err = c.err
@@ -459,6 +462,7 @@ func syscall_getprocaddress(handle uintptr, procname *byte) (outhandle, err uint
 	c.n = 2
 	c.args = uintptr(noescape(unsafe.Pointer(&handle)))
 	cgocall(asmstdcallAddr, unsafe.Pointer(c))
+	KeepAlive(procname)
 	outhandle = c.r1
 	if outhandle == 0 {
 		err = c.err

From 18934e11ba6ef2b2f21f091ddf4ab6814dcf1959 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" 
Date: Mon, 29 Nov 2021 15:17:36 -0500
Subject: [PATCH 336/752] net/http: eliminate arbitrary timeout in
 TestClientWriteShutdown

This test occasionally hangs on the darwin-arm64-11_0-toothrot
builder. When it does, it fails with the unhelpful error message
"timeout" instead of a useful goroutine dump.

This change eliminates the use of an arbitrary timeout channel, so
that if (and probably when) the test hangs again we will get more
useful logs to diagnose the root cause.

For #49860

Change-Id: I23f6f1c81209f0b2dbe565e1dfb26b1b2eff0187
Reviewed-on: https://go-review.googlesource.com/c/go/+/367615
Trust: Bryan C. Mills 
Run-TryBot: Bryan C. Mills 
TryBot-Result: Go Bot 
Reviewed-by: Damien Neil 
---
 src/net/http/serve_test.go | 24 ++++++++----------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go
index 1156b187ae..82c1a6716f 100644
--- a/src/net/http/serve_test.go
+++ b/src/net/http/serve_test.go
@@ -3075,22 +3075,14 @@ func TestClientWriteShutdown(t *testing.T) {
 	if err != nil {
 		t.Fatalf("CloseWrite: %v", err)
 	}
-	donec := make(chan bool)
-	go func() {
-		defer close(donec)
-		bs, err := io.ReadAll(conn)
-		if err != nil {
-			t.Errorf("ReadAll: %v", err)
-		}
-		got := string(bs)
-		if got != "" {
-			t.Errorf("read %q from server; want nothing", got)
-		}
-	}()
-	select {
-	case <-donec:
-	case <-time.After(10 * time.Second):
-		t.Fatalf("timeout")
+
+	bs, err := io.ReadAll(conn)
+	if err != nil {
+		t.Errorf("ReadAll: %v", err)
+	}
+	got := string(bs)
+	if got != "" {
+		t.Errorf("read %q from server; want nothing", got)
 	}
 }
 

From 682435dd9991040073ae12021fac164b41376502 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" 
Date: Fri, 19 Nov 2021 16:33:42 -0600
Subject: [PATCH 337/752] misc/cgo/test: reduce likeliness of hang in Test9400

If a GC triggers while spinning in RewindAndSetgid, it may result in
this test hanging. Avoid it by disabling the collector before entering
the uninterruptable ASM conditional wait.

Fixes #49695

Change-Id: Ie0a03653481fb746f862469361b7840f4bfa8b67
Reviewed-on: https://go-review.googlesource.com/c/go/+/365836
Run-TryBot: Paul Murphy 
TryBot-Result: Go Bot 
Trust: Michael Knyszek 
Reviewed-by: Ian Lance Taylor 
---
 misc/cgo/test/testdata/issue9400_linux.go | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/misc/cgo/test/testdata/issue9400_linux.go b/misc/cgo/test/testdata/issue9400_linux.go
index e94a9bb45f..f521b1f49a 100644
--- a/misc/cgo/test/testdata/issue9400_linux.go
+++ b/misc/cgo/test/testdata/issue9400_linux.go
@@ -15,6 +15,7 @@ import "C"
 
 import (
 	"runtime"
+	"runtime/debug"
 	"sync/atomic"
 	"testing"
 
@@ -46,6 +47,10 @@ func test9400(t *testing.T) {
 		big[i] = pattern
 	}
 
+	// Disable GC for the duration of the test.
+	// This avoids a potential GC deadlock when spinning in uninterruptable ASM below #49695.
+	defer debug.SetGCPercent(debug.SetGCPercent(-1))
+
 	// Temporarily rewind the stack and trigger SIGSETXID
 	issue9400.RewindAndSetgid()
 

From 931d80ec17374e52dbc5f9f63120f8deb80b355d Mon Sep 17 00:00:00 2001
From: Russ Cox 
Date: Mon, 25 Oct 2021 16:02:07 -0400
Subject: [PATCH 338/752] cmd/go: adjust BuildInfo.Settings

Make Settings more closely align with command-line flags
and environment variables.

- Change command-line flags to begin with -

- Change syntax of build lines to use Key=Value instead of KeyValue.

- Change CGO_ENABLED to 0/1, matching environment variable,
  instead of false/true.

- Add GOOS and GOARCH.
  These are technically redundant, in that they can be extracted
  from the binary in other ways most of the time, but not always:
  GOOS=ios and GOOS=darwin may produce binaries that are
  difficult to tell apart. In any case, it's a lot easier to have them
  directly in the settings list than derive them from other parts
  of the binary.

- Add GOEXPERIMENT.
  These could be inferred from the tags list, but the experiments
  are being removed from the tags list.

- Change the tags list to match the -tags command-line argument.

- Add msan and race, echoing the -msan and -race arguments
  (always 'true' when present, omitted when false).

- Add GO$GOARCH when set.

Change-Id: Icb59ef4faa5c22407eadd94147b7e53cf4344ce6
Reviewed-on: https://go-review.googlesource.com/c/go/+/358539
Trust: Russ Cox 
Run-TryBot: Russ Cox 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
---
 src/cmd/go/internal/cfg/cfg.go                |  4 +-
 src/cmd/go/internal/load/pkg.go               | 53 ++++++++++++++-----
 src/cmd/go/internal/work/init.go              |  2 +-
 .../script/version_build_settings.txt         | 28 +++++-----
 .../testdata/script/version_buildvcs_git.txt  | 27 +++++-----
 .../testdata/script/version_buildvcs_hg.txt   | 16 +++---
 src/debug/buildinfo/buildinfo_test.go         |  4 +-
 src/runtime/debug/mod.go                      | 24 +++++----
 8 files changed, 97 insertions(+), 61 deletions(-)

diff --git a/src/cmd/go/internal/cfg/cfg.go b/src/cmd/go/internal/cfg/cfg.go
index 351c3ee6a5..5b84d8be92 100644
--- a/src/cmd/go/internal/cfg/cfg.go
+++ b/src/cmd/go/internal/cfg/cfg.go
@@ -63,6 +63,8 @@ var (
 	// GoPathError is set when GOPATH is not set. it contains an
 	// explanation why GOPATH is unset.
 	GoPathError string
+
+	GOEXPERIMENT = envOr("GOEXPERIMENT", buildcfg.DefaultGOEXPERIMENT)
 )
 
 func defaultContext() build.Context {
@@ -89,7 +91,7 @@ func defaultContext() build.Context {
 
 	// The experiments flags are based on GOARCH, so they may
 	// need to change.  TODO: This should be cleaned up.
-	buildcfg.UpdateExperiments(ctxt.GOOS, ctxt.GOARCH, envOr("GOEXPERIMENT", buildcfg.DefaultGOEXPERIMENT))
+	buildcfg.UpdateExperiments(ctxt.GOOS, ctxt.GOARCH, GOEXPERIMENT)
 	ctxt.ToolTags = nil
 	for _, exp := range buildcfg.EnabledExperiments() {
 		ctxt.ToolTags = append(ctxt.ToolTags, "goexperiment."+exp)
diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go
index 41afa42f0f..589bf9e729 100644
--- a/src/cmd/go/internal/load/pkg.go
+++ b/src/cmd/go/internal/load/pkg.go
@@ -2285,33 +2285,57 @@ func (p *Package) setBuildInfo() {
 		Deps: deps,
 	}
 	appendSetting := func(key, value string) {
+		value = strings.ReplaceAll(value, "\n", " ") // make value safe
 		info.Settings = append(info.Settings, debug.BuildSetting{Key: key, Value: value})
 	}
 
 	// Add command-line flags relevant to the build.
 	// This is informational, not an exhaustive list.
+	// Please keep the list sorted.
 	if cfg.BuildBuildinfo && !p.Standard {
-		appendSetting("compiler", cfg.BuildContext.Compiler)
+		if cfg.BuildASan {
+			appendSetting("-asan", "true")
+		}
 		if BuildAsmflags.present {
-			appendSetting("asmflags", BuildAsmflags.String())
+			appendSetting("-asmflags", BuildAsmflags.String())
+		}
+		appendSetting("-compiler", cfg.BuildContext.Compiler)
+		if BuildGccgoflags.present && cfg.BuildContext.Compiler == "gccgo" {
+			appendSetting("-gccgoflags", BuildGccgoflags.String())
 		}
 		if BuildGcflags.present && cfg.BuildContext.Compiler == "gc" {
-			appendSetting("gcflags", BuildGcflags.String())
-		}
-		if BuildGccgoflags.present && cfg.BuildContext.Compiler == "gccgo" {
-			appendSetting("gccgoflags", BuildGccgoflags.String())
+			appendSetting("-gcflags", BuildGcflags.String())
 		}
 		if BuildLdflags.present {
-			appendSetting("ldflags", BuildLdflags.String())
+			appendSetting("-ldflags", BuildLdflags.String())
 		}
-		tags := append(cfg.BuildContext.BuildTags, cfg.BuildContext.ToolTags...)
-		appendSetting("tags", strings.Join(tags, ","))
-		appendSetting("CGO_ENABLED", strconv.FormatBool(cfg.BuildContext.CgoEnabled))
+		if cfg.BuildMSan {
+			appendSetting("-msan", "true")
+		}
+		if cfg.BuildRace {
+			appendSetting("-race", "true")
+		}
+		if tags := cfg.BuildContext.BuildTags; len(tags) > 0 {
+			appendSetting("-tags", strings.Join(tags, ","))
+		}
+		cgo := "0"
 		if cfg.BuildContext.CgoEnabled {
-			for _, name := range []string{"CGO_CPPFLAGS", "CGO_CFLAGS", "CGO_CXXFLAGS", "CGO_LDFLAGS"} {
+			cgo = "1"
+		}
+		appendSetting("CGO_ENABLED", cgo)
+		if cfg.BuildContext.CgoEnabled {
+			for _, name := range []string{"CGO_CFLAGS", "CGO_CPPFLAGS", "CGO_CXXFLAGS", "CGO_LDFLAGS"} {
 				appendSetting(name, cfg.Getenv(name))
 			}
 		}
+		appendSetting("GOARCH", cfg.BuildContext.GOARCH)
+		if cfg.GOEXPERIMENT != "" {
+			appendSetting("GOEXPERIMENT", cfg.GOEXPERIMENT)
+		}
+		appendSetting("GOOS", cfg.BuildContext.GOOS)
+		if key, val := cfg.GetArchEnv(); key != "" && val != "" {
+			appendSetting(key, val)
+		}
 	}
 
 	// Add VCS status if all conditions are true:
@@ -2383,14 +2407,15 @@ func (p *Package) setBuildInfo() {
 		}
 		st := cached.Status
 
+		appendSetting("vcs", vcsCmd.Cmd)
 		if st.Revision != "" {
-			appendSetting(vcsCmd.Cmd+"revision", st.Revision)
+			appendSetting("vcs.revision", st.Revision)
 		}
 		if !st.CommitTime.IsZero() {
 			stamp := st.CommitTime.UTC().Format(time.RFC3339Nano)
-			appendSetting(vcsCmd.Cmd+"committime", stamp)
+			appendSetting("vcs.time", stamp)
 		}
-		appendSetting(vcsCmd.Cmd+"uncommitted", strconv.FormatBool(st.Uncommitted))
+		appendSetting("vcs.modified", strconv.FormatBool(st.Uncommitted))
 	}
 
 	text, err := info.MarshalText()
diff --git a/src/cmd/go/internal/work/init.go b/src/cmd/go/internal/work/init.go
index dc368de1c1..26192ecaed 100644
--- a/src/cmd/go/internal/work/init.go
+++ b/src/cmd/go/internal/work/init.go
@@ -138,7 +138,7 @@ func instrumentInit() {
 		cfg.BuildContext.InstallSuffix += "_"
 	}
 	cfg.BuildContext.InstallSuffix += mode
-	cfg.BuildContext.BuildTags = append(cfg.BuildContext.BuildTags, mode)
+	cfg.BuildContext.ToolTags = append(cfg.BuildContext.ToolTags, mode)
 }
 
 func buildModeInit() {
diff --git a/src/cmd/go/testdata/script/version_build_settings.txt b/src/cmd/go/testdata/script/version_build_settings.txt
index 1ced285ac3..dc9e67681e 100644
--- a/src/cmd/go/testdata/script/version_build_settings.txt
+++ b/src/cmd/go/testdata/script/version_build_settings.txt
@@ -3,22 +3,25 @@
 # Compiler name is always added.
 go build
 go version -m m$GOEXE
-stdout '^\tbuild\tcompiler\tgc$'
+stdout '^\tbuild\t-compiler=gc$'
+stdout '^\tbuild\tGOOS='
+stdout '^\tbuild\tGOARCH='
+[amd64] stdout '^\tbuild\tGOAMD64='
 ! stdout asmflags|gcflags|ldflags|gccgoflags
 
 # Toolchain flags are added if present.
 # The raw flags are included, with package patterns if specified.
 go build -asmflags=example.com/m=-D=FOO=bar
 go version -m m$GOEXE
-stdout '^\tbuild\tasmflags\texample\.com/m=-D=FOO=bar$'
+stdout '^\tbuild\t-asmflags=example\.com/m=-D=FOO=bar$'
 
 go build -gcflags=example.com/m=-N
 go version -m m$GOEXE
-stdout '^\tbuild\tgcflags\texample\.com/m=-N$'
+stdout '^\tbuild\t-gcflags=example\.com/m=-N$'
 
 go build -ldflags=example.com/m=-w
 go version -m m$GOEXE
-stdout '^\tbuild\tldflags\texample\.com/m=-w$'
+stdout '^\tbuild\t-ldflags=example\.com/m=-w$'
 
 # gccgoflags are not added when gc is used, and vice versa.
 # TODO: test gccgo.
@@ -30,10 +33,11 @@ go version -m m$GOEXE
 # "race" is included with build tags but not "cgo".
 go build -tags=a,b
 go version -m m$GOEXE
-stdout '^\tbuild\ttags\ta,b(,goexperiment\.[a-z0-9]+)*$'
+stdout '^\tbuild\t-tags=a,b$'
 [race] go build -race
 [race] go version -m m$GOEXE
-[race] stdout '^\tbuild\ttags\t.*race.*$'
+[race] ! stdout '^\tbuild\t-tags='
+[race] stdout '^\tbuild\t-race=true$'
 
 # CGO flags are separate settings.
 # CGO_ENABLED is always present.
@@ -41,7 +45,7 @@ stdout '^\tbuild\ttags\ta,b(,goexperiment\.[a-z0-9]+)*$'
 env CGO_ENABLED=0
 go build
 go version -m m$GOEXE
-stdout '^\tbuild\tCGO_ENABLED\tfalse$'
+stdout '^\tbuild\tCGO_ENABLED=0$'
 ! stdout CGO_CPPFLAGS|CGO_CFLAGS|CGO_CXXFLAGS|CGO_LDFLAGS
 [cgo] env CGO_ENABLED=1
 [cgo] env CGO_CPPFLAGS=-DFROM_CPPFLAGS=1
@@ -50,11 +54,11 @@ stdout '^\tbuild\tCGO_ENABLED\tfalse$'
 [cgo] env CGO_LDFLAGS=-L/extra/dir/does/not/exist
 [cgo] go build
 [cgo] go version -m m$GOEXE
-[cgo] stdout '^\tbuild\tCGO_ENABLED\ttrue$'
-[cgo] stdout '^\tbuild\tCGO_CPPFLAGS\t-DFROM_CPPFLAGS=1$'
-[cgo] stdout '^\tbuild\tCGO_CFLAGS\t-DFROM_CFLAGS=1$'
-[cgo] stdout '^\tbuild\tCGO_CXXFLAGS\t-DFROM_CXXFLAGS=1$'
-[cgo] stdout '^\tbuild\tCGO_LDFLAGS\t-L/extra/dir/does/not/exist$'
+[cgo] stdout '^\tbuild\tCGO_ENABLED=1$'
+[cgo] stdout '^\tbuild\tCGO_CPPFLAGS=-DFROM_CPPFLAGS=1$'
+[cgo] stdout '^\tbuild\tCGO_CFLAGS=-DFROM_CFLAGS=1$'
+[cgo] stdout '^\tbuild\tCGO_CXXFLAGS=-DFROM_CXXFLAGS=1$'
+[cgo] stdout '^\tbuild\tCGO_LDFLAGS=-L/extra/dir/does/not/exist$'
 
 -- go.mod --
 module example.com/m
diff --git a/src/cmd/go/testdata/script/version_buildvcs_git.txt b/src/cmd/go/testdata/script/version_buildvcs_git.txt
index 72cbe28285..86d1de06df 100644
--- a/src/cmd/go/testdata/script/version_buildvcs_git.txt
+++ b/src/cmd/go/testdata/script/version_buildvcs_git.txt
@@ -11,7 +11,7 @@ cd repo/a
 # If there's no local repository, there's no VCS info.
 go install
 go version -m $GOBIN/a$GOEXE
-! stdout gitrevision
+! stdout vcs.revision
 rm $GOBIN/a$GOEXE
 
 # If there is a repository, but it can't be used for some reason,
@@ -40,9 +40,10 @@ exec git config user.name 'J.R. Gopher'
 cd a
 go install
 go version -m $GOBIN/a$GOEXE
-! stdout gitrevision
-! stdout gitcommittime
-stdout '^\tbuild\tgituncommitted\ttrue$'
+stdout '^\tbuild\tvcs=git$'
+stdout '^\tbuild\tvcs.modified=true$'
+! stdout vcs.revision
+! stdout vcs.time
 rm $GOBIN/a$GOEXE
 
 # Revision and commit time are tagged for repositories with commits.
@@ -50,22 +51,22 @@ exec git add -A
 exec git commit -m 'initial commit'
 go install
 go version -m $GOBIN/a$GOEXE
-stdout '^\tbuild\tgitrevision\t'
-stdout '^\tbuild\tgitcommittime\t'
-stdout '^\tbuild\tgituncommitted\tfalse$'
+stdout '^\tbuild\tvcs.revision='
+stdout '^\tbuild\tvcs.time='
+stdout '^\tbuild\tvcs.modified=false$'
 rm $GOBIN/a$GOEXE
 
 # Building with -buildvcs=false suppresses the info.
 go install -buildvcs=false
 go version -m $GOBIN/a$GOEXE
-! stdout gitrevision
+! stdout vcs.revision
 rm $GOBIN/a$GOEXE
 
 # An untracked file is shown as uncommitted, even if it isn't part of the build.
 cp ../../outside/empty.txt .
 go install
 go version -m $GOBIN/a$GOEXE
-stdout '^\tbuild\tgituncommitted\ttrue$'
+stdout '^\tbuild\tvcs.modified=true$'
 rm empty.txt
 rm $GOBIN/a$GOEXE
 
@@ -73,7 +74,7 @@ rm $GOBIN/a$GOEXE
 cp ../../outside/empty.txt ../README
 go install
 go version -m $GOBIN/a$GOEXE
-stdout '^\tbuild\tgituncommitted\ttrue$'
+stdout '^\tbuild\tvcs.modified=true$'
 exec git checkout ../README
 rm $GOBIN/a$GOEXE
 
@@ -81,14 +82,14 @@ rm $GOBIN/a$GOEXE
 # there should be no VCS info.
 go install example.com/cmd/a@v1.0.0
 go version -m $GOBIN/a$GOEXE
-! stdout gitrevision
+! stdout vcs.revision
 rm $GOBIN/a$GOEXE
 
 go mod edit -require=example.com/c@v0.0.0
 go mod edit -replace=example.com/c@v0.0.0=../../outside/c
 go install example.com/c
 go version -m $GOBIN/c$GOEXE
-! stdout gitrevision
+! stdout vcs.revision
 rm $GOBIN/c$GOEXE
 exec git checkout go.mod
 
@@ -100,7 +101,7 @@ go mod edit -require=example.com/d@v0.0.0
 go mod edit -replace=example.com/d@v0.0.0=../../outside/d
 go install example.com/d
 go version -m $GOBIN/d$GOEXE
-! stdout gitrevision
+! stdout vcs.revision
 exec git checkout go.mod
 rm $GOBIN/d$GOEXE
 
diff --git a/src/cmd/go/testdata/script/version_buildvcs_hg.txt b/src/cmd/go/testdata/script/version_buildvcs_hg.txt
index df4938742d..fbbd886102 100644
--- a/src/cmd/go/testdata/script/version_buildvcs_hg.txt
+++ b/src/cmd/go/testdata/script/version_buildvcs_hg.txt
@@ -34,9 +34,9 @@ exec hg init
 cd a
 go install
 go version -m $GOBIN/a$GOEXE
-! stdout hgrevision
-! stdout hgcommittime
-stdout '^\tbuild\thguncommitted\ttrue$'
+! stdout vcs.revision
+! stdout vcs.time
+stdout '^\tbuild\tvcs.modified=true$'
 cd ..
 
 # Revision and commit time are tagged for repositories with commits.
@@ -45,9 +45,9 @@ exec hg commit -m 'initial commit'
 cd a
 go install
 go version -m $GOBIN/a$GOEXE
-stdout '^\tbuild\thgrevision\t'
-stdout '^\tbuild\thgcommittime\t'
-stdout '^\tbuild\thguncommitted\tfalse$'
+stdout '^\tbuild\tvcs.revision='
+stdout '^\tbuild\tvcs.time='
+stdout '^\tbuild\tvcs.modified=false$'
 rm $GOBIN/a$GOEXE
 
 # Building with -buildvcs=false suppresses the info.
@@ -60,7 +60,7 @@ rm $GOBIN/a$GOEXE
 cp ../../outside/empty.txt .
 go install
 go version -m $GOBIN/a$GOEXE
-stdout '^\tbuild\thguncommitted\ttrue$'
+stdout '^\tbuild\tvcs.modified=true$'
 rm empty.txt
 rm $GOBIN/a$GOEXE
 
@@ -68,7 +68,7 @@ rm $GOBIN/a$GOEXE
 cp ../../outside/empty.txt ../README
 go install
 go version -m $GOBIN/a$GOEXE
-stdout '^\tbuild\thguncommitted\ttrue$'
+stdout '^\tbuild\tvcs.modified=true$'
 exec hg revert ../README
 rm $GOBIN/a$GOEXE
 
diff --git a/src/debug/buildinfo/buildinfo_test.go b/src/debug/buildinfo/buildinfo_test.go
index 44d78a6be0..fd31caf135 100644
--- a/src/debug/buildinfo/buildinfo_test.go
+++ b/src/debug/buildinfo/buildinfo_test.go
@@ -124,7 +124,7 @@ func TestReadFile(t *testing.T) {
 		// build lines are included.
 		got = goVersionRe.ReplaceAllString(got, "go\tGOVERSION\n")
 		got = buildRe.ReplaceAllStringFunc(got, func(match string) string {
-			if strings.HasPrefix(match, "build\tcompiler\t") {
+			if strings.HasPrefix(match, "build\t-compiler=") {
 				return match
 			}
 			return ""
@@ -163,7 +163,7 @@ func TestReadFile(t *testing.T) {
 			want: "go\tGOVERSION\n" +
 				"path\texample.com/m\n" +
 				"mod\texample.com/m\t(devel)\t\n" +
-				"build\tcompiler\tgc\n",
+				"build\t-compiler=gc\n",
 		},
 		{
 			name: "invalid_modules",
diff --git a/src/runtime/debug/mod.go b/src/runtime/debug/mod.go
index 14b99f5735..14a496a8eb 100644
--- a/src/runtime/debug/mod.go
+++ b/src/runtime/debug/mod.go
@@ -57,8 +57,9 @@ type Module struct {
 // BuildSetting describes a setting that may be used to understand how the
 // binary was built. For example, VCS commit and dirty status is stored here.
 type BuildSetting struct {
-	// Key and Value describe the build setting. They must not contain tabs
-	// or newlines.
+	// Key and Value describe the build setting.
+	// Key must not contain an equals sign, space, tab, or newline.
+	// Value must not contain newlines ('\n').
 	Key, Value string
 }
 
@@ -97,10 +98,13 @@ func (bi *BuildInfo) MarshalText() ([]byte, error) {
 		formatMod("dep", *dep)
 	}
 	for _, s := range bi.Settings {
-		if strings.ContainsAny(s.Key, "\n\t") || strings.ContainsAny(s.Value, "\n\t") {
-			return nil, fmt.Errorf("build setting %q contains tab or newline", s.Key)
+		if strings.ContainsAny(s.Key, "= \t\n") {
+			return nil, fmt.Errorf("invalid build setting key %q", s.Key)
 		}
-		fmt.Fprintf(buf, "build\t%s\t%s\n", s.Key, s.Value)
+		if strings.Contains(s.Value, "\n") {
+			return nil, fmt.Errorf("invalid build setting value for key %q: contains newline", s.Value)
+		}
+		fmt.Fprintf(buf, "build\t%s=%s\n", s.Key, s.Value)
 	}
 
 	return buf.Bytes(), nil
@@ -185,14 +189,14 @@ func (bi *BuildInfo) UnmarshalText(data []byte) (err error) {
 			}
 			last = nil
 		case bytes.HasPrefix(line, buildLine):
-			elem := bytes.Split(line[len(buildLine):], tab)
-			if len(elem) != 2 {
-				return fmt.Errorf("expected 2 columns for build setting; got %d", len(elem))
+			key, val, ok := strings.Cut(string(line[len(buildLine):]), "=")
+			if !ok {
+				return fmt.Errorf("invalid build line")
 			}
-			if len(elem[0]) == 0 {
+			if key == "" {
 				return fmt.Errorf("empty key")
 			}
-			bi.Settings = append(bi.Settings, BuildSetting{Key: string(elem[0]), Value: string(elem[1])})
+			bi.Settings = append(bi.Settings, BuildSetting{Key: key, Value: val})
 		}
 		lineNum++
 	}

From 5f63f168daa9644bcc723077e9e2e1796639f6bb Mon Sep 17 00:00:00 2001
From: Chaoqun Han 
Date: Thu, 25 Nov 2021 21:16:28 +0800
Subject: [PATCH 339/752] runtime: add invalidptr=0 for TestGcZombieReporting

pointers in zombies slice may cross-span, add invalidptr=0 for avoiding the badPointer check

Fixes #49613

Change-Id: Ifb1931922170e87e799e2e6081dc85dab3890205
Reviewed-on: https://go-review.googlesource.com/c/go/+/367044
Trust: Emmanuel Odeke 
Run-TryBot: Emmanuel Odeke 
TryBot-Result: Go Bot 
Reviewed-by: Bryan C. Mills 
Reviewed-by: Emmanuel Odeke 
---
 src/runtime/gc_test.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/runtime/gc_test.go b/src/runtime/gc_test.go
index 7b979afd55..d81cb3a3d5 100644
--- a/src/runtime/gc_test.go
+++ b/src/runtime/gc_test.go
@@ -196,7 +196,10 @@ func TestPeriodicGC(t *testing.T) {
 
 func TestGcZombieReporting(t *testing.T) {
 	// This test is somewhat sensitive to how the allocator works.
-	got := runTestProg(t, "testprog", "GCZombie")
+	// Pointers in zombies slice may cross-span, thus we
+	// add invalidptr=0 for avoiding the badPointer check.
+	// See issue https://golang.org/issues/49613/
+	got := runTestProg(t, "testprog", "GCZombie", "GODEBUG=invalidptr=0")
 	want := "found pointer to free object"
 	if !strings.Contains(got, want) {
 		t.Fatalf("expected %q in output, but got %q", want, got)

From 7ccbcc90560468937f02609a43cb39a6e13ff797 Mon Sep 17 00:00:00 2001
From: "Paul E. Murphy" 
Date: Fri, 19 Nov 2021 16:33:42 -0600
Subject: [PATCH 340/752] misc/cgo/test: further reduce likeliness of hang in
 Test9400

As suggested by #49680, a GC could be in-progress when we
disable GC. Force a GC after we pause to ensure we don't
hang in this case.

For #49695

Change-Id: I4fc4c06ef2ac174217c3dcf7d58c7669226e2d24
Reviewed-on: https://go-review.googlesource.com/c/go/+/367874
Run-TryBot: Paul Murphy 
TryBot-Result: Go Bot 
Reviewed-by: Ian Lance Taylor 
Trust: Paul Murphy 
---
 misc/cgo/test/testdata/issue9400_linux.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/misc/cgo/test/testdata/issue9400_linux.go b/misc/cgo/test/testdata/issue9400_linux.go
index f521b1f49a..47f224dc4f 100644
--- a/misc/cgo/test/testdata/issue9400_linux.go
+++ b/misc/cgo/test/testdata/issue9400_linux.go
@@ -50,6 +50,8 @@ func test9400(t *testing.T) {
 	// Disable GC for the duration of the test.
 	// This avoids a potential GC deadlock when spinning in uninterruptable ASM below #49695.
 	defer debug.SetGCPercent(debug.SetGCPercent(-1))
+	// And finish any pending GC after we pause, if any.
+	runtime.GC()
 
 	// Temporarily rewind the stack and trigger SIGSETXID
 	issue9400.RewindAndSetgid()

From a412b5f0d803b261b8075289bf41599490f237cc Mon Sep 17 00:00:00 2001
From: Tobias Klauser 
Date: Tue, 30 Nov 2021 23:21:39 +0100
Subject: [PATCH 341/752] runtime: skip TestSignalIgnoreSIGTRAP on all OpenBSD
 builders

TestSignalIgnoreSIGTRAP is flaky on OpenBSD and the cause is suspected
to be a kernel bug. This test is currently only skipped on the previous
OpenBSD 6.2 and 6.4 builders for #17496. In the meantime the OpenBSD
builders were upgraded to more recent OpenBSD versions (currently 6.8
and 7.0). It seems the issue is still present in these OpenBSD versions
and there is no obvious workaround in Go. Thus, skip the flaky test on
OpenBSD in general.

Updates #17496
Updates #49725

Change-Id: I3577d287dcfaad7a81679db2e71540854fce065a
Reviewed-on: https://go-review.googlesource.com/c/go/+/367115
Trust: Tobias Klauser 
Run-TryBot: Tobias Klauser 
TryBot-Result: Go Bot 
Reviewed-by: Emmanuel Odeke 
Reviewed-by: Bryan C. Mills 
---
 src/runtime/crash_unix_test.go | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/runtime/crash_unix_test.go b/src/runtime/crash_unix_test.go
index 0930a1b365..b93a760276 100644
--- a/src/runtime/crash_unix_test.go
+++ b/src/runtime/crash_unix_test.go
@@ -14,7 +14,6 @@ import (
 	"os/exec"
 	"runtime"
 	"runtime/debug"
-	"strings"
 	"sync"
 	"syscall"
 	"testing"
@@ -250,9 +249,7 @@ func TestSignalExitStatus(t *testing.T) {
 
 func TestSignalIgnoreSIGTRAP(t *testing.T) {
 	if runtime.GOOS == "openbsd" {
-		if bn := testenv.Builder(); strings.HasSuffix(bn, "-62") || strings.HasSuffix(bn, "-64") {
-			testenv.SkipFlaky(t, 17496)
-		}
+		testenv.SkipFlaky(t, 49725)
 	}
 
 	output := runTestProg(t, "testprognet", "SignalIgnoreSIGTRAP")

From 0e1d553b4d98b71799b86b0ba9bc338de29b7dfe Mon Sep 17 00:00:00 2001
From: Cuong Manh Le 
Date: Tue, 30 Nov 2021 16:58:36 +0700
Subject: [PATCH 342/752] cmd/compile: fix identical to recognize any and
 interface{}

Currently, identical handles any and interface{} by checking against
Types[TINTER]. This is not always true, since when two generated
interface{} types may not use the same *Type instance.

Instead, we must check whether Type is empty interface or not.

Fixes #49875

Change-Id: I28fe4fc0100041a01bb03da795cfe8232b515fc4
Reviewed-on: https://go-review.googlesource.com/c/go/+/367754
Trust: Cuong Manh Le 
Run-TryBot: Cuong Manh Le 
TryBot-Result: Go Bot 
Reviewed-by: Keith Randall 
Reviewed-by: Matthew Dempsky 
---
 src/cmd/compile/internal/types/identity.go |  3 ++-
 src/cmd/compile/internal/types/type.go     |  3 ++-
 test/typeparam/issue49875.go               | 14 ++++++++++++++
 3 files changed, 18 insertions(+), 2 deletions(-)
 create mode 100644 test/typeparam/issue49875.go

diff --git a/src/cmd/compile/internal/types/identity.go b/src/cmd/compile/internal/types/identity.go
index 89343b8419..f99e50a1c3 100644
--- a/src/cmd/compile/internal/types/identity.go
+++ b/src/cmd/compile/internal/types/identity.go
@@ -59,7 +59,8 @@ func identical(t1, t2 *Type, flags int, assumedEqual map[typePair]struct{}) bool
 		case TINT32:
 			return (t1 == Types[TINT32] || t1 == RuneType) && (t2 == Types[TINT32] || t2 == RuneType)
 		case TINTER:
-			return (t1 == Types[TINTER] || t1 == AnyType) && (t2 == Types[TINTER] || t2 == AnyType)
+			// Make sure named any type matches any empty interface.
+			return t1 == AnyType && t2.IsEmptyInterface() || t2 == AnyType && t1.IsEmptyInterface()
 		default:
 			return false
 		}
diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index b1194fa196..7d22e2da23 100644
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -1211,7 +1211,8 @@ func (t *Type) cmp(x *Type) Cmp {
 			}
 
 		case TINTER:
-			if (t == Types[AnyType.kind] || t == AnyType) && (x == Types[AnyType.kind] || x == AnyType) {
+			// Make sure named any type matches any empty interface.
+			if t == AnyType && x.IsEmptyInterface() || x == AnyType && t.IsEmptyInterface() {
 				return CMPeq
 			}
 		}
diff --git a/test/typeparam/issue49875.go b/test/typeparam/issue49875.go
new file mode 100644
index 0000000000..aece7deab1
--- /dev/null
+++ b/test/typeparam/issue49875.go
@@ -0,0 +1,14 @@
+// compile -G=3
+
+// 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(args ...interface{}) {}
+
+func g() {
+	var args []any
+	f(args...)
+}

From ab7905540bf83b85cdbd6574e54319126df9dae8 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" 
Date: Mon, 29 Nov 2021 14:26:44 -0500
Subject: [PATCH 343/752] cmd/go/internal/modload: fix up main-module checks
 from CL 334932

Some critical Version == "" checks were missing in mvs.go, causing
mvs.Req to fail to retain requirements provided by older versions of
main modules.

A few checks also ought to be rotated to put the less expensive
string-equality checks before the more expensive map lookups.

Fixes #48511

Change-Id: Ib8de9d49a6413660792c003866bfcf9ab7f82ee2
Reviewed-on: https://go-review.googlesource.com/c/go/+/368136
Trust: Bryan C. Mills 
Run-TryBot: Bryan C. Mills 
TryBot-Result: Go Bot 
Reviewed-by: Russ Cox 
---
 src/cmd/go/internal/modget/get.go             |  2 +-
 src/cmd/go/internal/modload/buildlist.go      |  2 +-
 src/cmd/go/internal/modload/edit.go           |  4 +-
 src/cmd/go/internal/modload/load.go           |  2 +-
 src/cmd/go/internal/modload/mvs.go            |  6 +-
 .../go/testdata/script/mod_get_issue48511.txt | 68 +++++++++++++++++++
 6 files changed, 76 insertions(+), 8 deletions(-)
 create mode 100644 src/cmd/go/testdata/script/mod_get_issue48511.txt

diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go
index 2c48c3c444..893cc92e39 100644
--- a/src/cmd/go/internal/modget/get.go
+++ b/src/cmd/go/internal/modget/get.go
@@ -1124,7 +1124,7 @@ func (r *resolver) loadPackages(ctx context.Context, patterns []string, findPack
 	}
 
 	opts.AllowPackage = func(ctx context.Context, path string, m module.Version) error {
-		if m.Path == "" || m.Version == "" && modload.MainModules.Contains(m.Path) {
+		if m.Path == "" || m.Version == "" {
 			// Packages in the standard library and main modules are already at their
 			// latest (and only) available versions.
 			return nil
diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go
index f4c1311af5..4ce71fef5b 100644
--- a/src/cmd/go/internal/modload/buildlist.go
+++ b/src/cmd/go/internal/modload/buildlist.go
@@ -45,7 +45,7 @@ type Requirements struct {
 	pruning modPruning
 
 	// rootModules is the set of root modules of the graph, sorted and capped to
-	// length. It may contain duplicates, and may  contain multiple versions for a
+	// length. It may contain duplicates, and may contain multiple versions for a
 	// given module path. The root modules of the groph are the set of main
 	// modules in workspace mode, and the main module's direct requirements
 	// outside workspace mode.
diff --git a/src/cmd/go/internal/modload/edit.go b/src/cmd/go/internal/modload/edit.go
index 023983caed..0f37e3b2e9 100644
--- a/src/cmd/go/internal/modload/edit.go
+++ b/src/cmd/go/internal/modload/edit.go
@@ -76,7 +76,7 @@ func editRequirements(ctx context.Context, rs *Requirements, tryUpgrade, mustSel
 		// requirements.
 		var rootPaths []string
 		for _, m := range mustSelect {
-			if !MainModules.Contains(m.Path) && m.Version != "none" {
+			if m.Version != "none" && !MainModules.Contains(m.Path) {
 				rootPaths = append(rootPaths, m.Path)
 			}
 		}
@@ -370,7 +370,7 @@ func selectPotentiallyImportedModules(ctx context.Context, limiter *versionLimit
 		if err != nil {
 			return nil, false, err
 		}
-		initial = mg.BuildList()[1:]
+		initial = mg.BuildList()[MainModules.Len():]
 	} else {
 		initial = rs.rootModules
 	}
diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go
index 27bbfb7832..5e7075da4e 100644
--- a/src/cmd/go/internal/modload/load.go
+++ b/src/cmd/go/internal/modload/load.go
@@ -1091,7 +1091,7 @@ func loadFromRoots(ctx context.Context, params loaderParams) *loader {
 			break
 		}
 		if changed {
-			// Don't resolve missing imports until the module graph have stabilized.
+			// Don't resolve missing imports until the module graph has stabilized.
 			// If the roots are still changing, they may turn out to specify a
 			// requirement on the missing package(s), and we would rather use a
 			// version specified by a new root than add a new dependency on an
diff --git a/src/cmd/go/internal/modload/mvs.go b/src/cmd/go/internal/modload/mvs.go
index 40224d534b..588bcf4bdc 100644
--- a/src/cmd/go/internal/modload/mvs.go
+++ b/src/cmd/go/internal/modload/mvs.go
@@ -42,7 +42,7 @@ type mvsReqs struct {
 }
 
 func (r *mvsReqs) Required(mod module.Version) ([]module.Version, error) {
-	if MainModules.Contains(mod.Path) {
+	if mod.Version == "" && MainModules.Contains(mod.Path) {
 		// Use the build list as it existed when r was constructed, not the current
 		// global build list.
 		return r.roots, nil
@@ -108,12 +108,12 @@ func versions(ctx context.Context, path string, allowed AllowedFunc) ([]string,
 // previousVersion returns the tagged version of m.Path immediately prior to
 // m.Version, or version "none" if no prior version is tagged.
 //
-// Since the version of Target is not found in the version list,
+// Since the version of a main module is not found in the version list,
 // it has no previous version.
 func previousVersion(m module.Version) (module.Version, error) {
 	// TODO(golang.org/issue/38714): thread tracing context through MVS.
 
-	if MainModules.Contains(m.Path) {
+	if m.Version == "" && MainModules.Contains(m.Path) {
 		return module.Version{Path: m.Path, Version: "none"}, nil
 	}
 
diff --git a/src/cmd/go/testdata/script/mod_get_issue48511.txt b/src/cmd/go/testdata/script/mod_get_issue48511.txt
new file mode 100644
index 0000000000..0ba486d35b
--- /dev/null
+++ b/src/cmd/go/testdata/script/mod_get_issue48511.txt
@@ -0,0 +1,68 @@
+# Regression test for https://golang.org/issue/48511:
+# requirement minimization was accidentally replacing previous
+# versions of the main module, causing dependencies to be
+# spuriously dropping during requirement minimization and
+# leading to an infinite loop.
+
+cp go.mod go.mod.orig
+go mod tidy
+cmp go.mod go.mod.orig
+
+go get -u=patch ./...
+cmp go.mod go.mod.want
+
+-- go.mod --
+module example.net/m
+
+go 1.16
+
+replace (
+	example.net/a v0.1.0 => ./a
+	example.net/b v0.1.0 => ./b
+	example.net/b v0.1.1 => ./b
+	example.net/m v0.1.0 => ./m1
+)
+
+require example.net/a v0.1.0
+-- go.mod.want --
+module example.net/m
+
+go 1.16
+
+replace (
+	example.net/a v0.1.0 => ./a
+	example.net/b v0.1.0 => ./b
+	example.net/b v0.1.1 => ./b
+	example.net/m v0.1.0 => ./m1
+)
+
+require (
+	example.net/a v0.1.0
+	example.net/b v0.1.1 // indirect
+)
+-- m.go --
+package m
+
+import "example.net/a"
+-- m1/go.mod --
+module example.net/m
+
+go 1.16
+
+require example.net/b v0.1.0
+-- a/go.mod --
+module example.net/a
+
+go 1.16
+
+require example.net/m v0.1.0
+-- a/a.go --
+package a
+
+import "example.net/b"
+-- b/go.mod --
+module example.net/b
+
+go 1.16
+-- b/b.go --
+package b

From 029dfbcc83123cb62e52f2aaedc46397815e3fa6 Mon Sep 17 00:00:00 2001
From: Cherry Mui 
Date: Tue, 30 Nov 2021 17:30:57 -0500
Subject: [PATCH 344/752] net: do not use sendfile on iOS

Apparently, on the iOS builder sendfile causes a SIGSYS signal
(instead of returning ENOSYS). Disabling it for now so we can
make progress on iOS. We can revisit if sendfile is actually
broken on iOS and whether it is beneficial.

Updates #49616.

Change-Id: I3883fad0ce35e3f0aa352301eb499a1afa0225a1
Reviewed-on: https://go-review.googlesource.com/c/go/+/368054
Trust: Cherry Mui 
Reviewed-by: Emmanuel Odeke 
Reviewed-by: Michael Knyszek 
Reviewed-by: Changkun Ou 
Reviewed-by: Roland Shoemaker 
---
 src/net/sendfile_stub.go     | 2 +-
 src/net/sendfile_unix_alt.go | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/net/sendfile_stub.go b/src/net/sendfile_stub.go
index 4ddae852e1..7428da3127 100644
--- a/src/net/sendfile_stub.go
+++ b/src/net/sendfile_stub.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.
 
-//go:build aix || (js && wasm) || netbsd || openbsd
+//go:build aix || (js && wasm) || netbsd || openbsd || ios
 
 package net
 
diff --git a/src/net/sendfile_unix_alt.go b/src/net/sendfile_unix_alt.go
index 8845a981f5..f99af92bc8 100644
--- a/src/net/sendfile_unix_alt.go
+++ b/src/net/sendfile_unix_alt.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.
 
-//go:build darwin || dragonfly || freebsd || solaris
+//go:build (darwin && !ios) || dragonfly || freebsd || solaris
 
 package net
 

From 2c5d2083e41371aa4f5aab9e86921002c1f9b504 Mon Sep 17 00:00:00 2001
From: Rhys Hiltner 
Date: Mon, 29 Nov 2021 16:48:34 -0800
Subject: [PATCH 345/752] runtime: fix riscv64 sigaction mask field offset

The Linux kernel for riscv64 does not include an sa_restorer field on
its sigaction struct, and expects sa_mask to come immediately after the
sa_flags field. Arrange the fields of the sigaction struct that are
known to the kernel so they appear at the correct byte offsets, and so
they agree with the output of "go tool cgo -godefs".

Follow the example set by the mips/mipsle port to leave the sa_restorer
field in place, but at an offset where it won't hurt anything.

Fixes #49709

Change-Id: I9bb0d7dbd7439d07e3a204461c7d790f33fd4977
Reviewed-on: https://go-review.googlesource.com/c/go/+/367635
Run-TryBot: Rhys Hiltner 
Reviewed-by: Cherry Mui 
Reviewed-by: Joel Sing 
Trust: Ian Lance Taylor 
---
 src/runtime/defs_linux_riscv64.go | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/runtime/defs_linux_riscv64.go b/src/runtime/defs_linux_riscv64.go
index 332720a8c8..747e26bc4b 100644
--- a/src/runtime/defs_linux_riscv64.go
+++ b/src/runtime/defs_linux_riscv64.go
@@ -122,10 +122,12 @@ func (tv *timeval) set_usec(x int32) {
 }
 
 type sigactiont struct {
-	sa_handler  uintptr
-	sa_flags    uint64
+	sa_handler uintptr
+	sa_flags   uint64
+	sa_mask    uint64
+	// Linux on riscv64 does not have the sa_restorer field, but the setsig
+	// function references it (for x86). Not much harm to include it at the end.
 	sa_restorer uintptr
-	sa_mask     uint64
 }
 
 type siginfoFields struct {

From 8ebb8c9ecba4069cc4defffffbbcdde0ba22ced1 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" 
Date: Tue, 30 Nov 2021 16:10:47 -0500
Subject: [PATCH 346/752] runtime: give the subprocess more time in
 TestSpuriousWakeupsNeverHangSemasleep

Issue #27250 reproduced readily enough to keep the subprocess hung
indefinitely when it occurred, so the timeout does not need to be
short to maintain test fidelity. On the other hand, on heavily loaded
systems it might take a while for the kernel to actually start the
subprocess, and it might also take a while for control flow to return
to the test after the subprocess exits.

We can reduce noise from this test in two ways:

1. Measure the timeout from closer to when the subprocess actually
starts sleeping, instead of when we started creating the subprocess.

2. Use a longer timeout, since it doesn't actually need to be short.

Fixes #38921
Updates #27250

Change-Id: I01c11ae82d0cdc6e7def2da6544b4d07201b35e8
Reviewed-on: https://go-review.googlesource.com/c/go/+/367849
Trust: Bryan C. Mills 
Run-TryBot: Bryan C. Mills 
TryBot-Result: Go Bot 
Reviewed-by: Keith Randall 
---
 src/runtime/semasleep_test.go | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/src/runtime/semasleep_test.go b/src/runtime/semasleep_test.go
index 0057b0729e..d56733c0cf 100644
--- a/src/runtime/semasleep_test.go
+++ b/src/runtime/semasleep_test.go
@@ -28,19 +28,24 @@ func TestSpuriousWakeupsNeverHangSemasleep(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	start := time.Now()
 	cmd := exec.Command(exe, "After1")
 	stdout, err := cmd.StdoutPipe()
 	if err != nil {
 		t.Fatalf("StdoutPipe: %v", err)
 	}
+	beforeStart := time.Now()
 	if err := cmd.Start(); err != nil {
 		t.Fatalf("Failed to start command: %v", err)
 	}
 	doneCh := make(chan error, 1)
 	go func() {
 		doneCh <- cmd.Wait()
+		close(doneCh)
 	}()
+	t.Cleanup(func() {
+		cmd.Process.Kill()
+		<-doneCh
+	})
 
 	// Wait for After1 to close its stdout so that we know the runtime's SIGIO
 	// handler is registered.
@@ -52,6 +57,19 @@ func TestSpuriousWakeupsNeverHangSemasleep(t *testing.T) {
 		t.Fatalf("error reading from testprog: %v", err)
 	}
 
+	// Wait for an arbitrary timeout longer than one second. The subprocess itself
+	// attempts to sleep for one second, but if the machine running the test is
+	// heavily loaded that subprocess may not schedule very quickly even if the
+	// bug remains fixed. (This is fine, because if the bug really is unfixed we
+	// can keep the process hung indefinitely, as long as we signal it often
+	// enough.)
+	timeout := 10 * time.Second
+
+	// The subprocess begins sleeping for 1s after it writes to stdout, so measure
+	// the timeout from here (not from when we started creating the process).
+	// That should reduce noise from process startup overhead.
+	ready := time.Now()
+
 	// With the repro running, we can continuously send to it
 	// a signal that the runtime considers non-terminal,
 	// such as SIGIO, to spuriously wake up
@@ -61,10 +79,11 @@ func TestSpuriousWakeupsNeverHangSemasleep(t *testing.T) {
 	for {
 		select {
 		case now := <-ticker.C:
-			if now.Sub(start) > 2*time.Second {
+			if now.Sub(ready) > timeout {
 				t.Error("Program failed to return on time and has to be killed, issue #27520 still exists")
-				cmd.Process.Signal(syscall.SIGKILL)
-				<-doneCh
+				// Send SIGQUIT to get a goroutine dump.
+				// Stop sending SIGIO so that the program can clean up and actually terminate.
+				cmd.Process.Signal(syscall.SIGQUIT)
 				return
 			}
 
@@ -76,7 +95,7 @@ func TestSpuriousWakeupsNeverHangSemasleep(t *testing.T) {
 			if err != nil {
 				t.Fatalf("The program returned but unfortunately with an error: %v", err)
 			}
-			if time.Since(start) < 1*time.Second {
+			if time.Since(beforeStart) < 1*time.Second {
 				// The program was supposed to sleep for a full (monotonic) second;
 				// it should not return before that has elapsed.
 				t.Fatalf("The program stopped too quickly.")

From 08ecdf7c2e9e9ecc4e2d7c6d9438faeed2338140 Mon Sep 17 00:00:00 2001
From: Austin Clements 
Date: Wed, 1 Dec 2021 08:56:19 -0500
Subject: [PATCH 347/752] runtime: fix racy allgs access on weak memory
 architectures

Currently, markroot is very clever about accessing the allgs slice to
find stack roots. Unfortunately, on weak memory architectures, it's a
little too clever and can sometimes read a nil g, causing a fatal
panic.

Specifically, gcMarkRootPrepare snapshots the length of allgs during
STW and then markroot accesses allgs up to this length during
concurrent marking. During concurrent marking, allgadd can append to
allgs *without synchronizing with markroot*, but the argument is that
the markroot access should be safe because allgs only grows
monotonically and existing entries in allgs never change.

This reasoning is insufficient on weak memory architectures. Suppose
thread 1 calls allgadd during concurrent marking and that allgs is
already at capacity. On thread 1, append will allocate a new slice
that initially consists of all nils, then copy the old backing store
to the new slice (write A), then allgadd will publish the new slice to
the allgs global (write B). Meanwhile, on thread 2, markroot reads the
allgs slice base pointer (read A), computes an offset from that base
pointer, and reads the value at that offset (read B). On a weak memory
machine, thread 2 can observe write B *before* write A. If the order
of events from thread 2's perspective is write B, read A, read B,
write A, then markroot on thread 2 will read a nil g and then panic.

Fix this by taking a snapshot of the allgs slice header in
gcMarkRootPrepare while the world is stopped and using that snapshot
as the list of stack roots in markroot. This eliminates all read/write
concurrency around the access in markroot.

Alternatively, we could make markroot use the atomicAllGs API to
atomically access the allgs list, but in my opinion it's much less
subtle to just eliminate all of the interesting concurrency around the
allgs access.

Fixes #49686.
Fixes #48845.
Fixes #43824.
(These are all just different paths to the same ultimate issue.)

Change-Id: I472b4934a637bbe88c8a080a280aa30212acf984
Reviewed-on: https://go-review.googlesource.com/c/go/+/368134
Trust: Austin Clements 
Trust: Bryan C. Mills 
Run-TryBot: Austin Clements 
TryBot-Result: Go Bot 
Reviewed-by: Michael Knyszek 
Reviewed-by: Cherry Mui 
---
 src/runtime/mgc.go     | 14 ++++++++++++++
 src/runtime/mgcmark.go | 14 ++++++--------
 src/runtime/proc.go    | 14 ++++++++++++++
 3 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index d75893dc43..8c8f7d936b 100644
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -320,11 +320,20 @@ var work struct {
 	nwait  uint32
 
 	// Number of roots of various root types. Set by gcMarkRootPrepare.
+	//
+	// nStackRoots == len(stackRoots), but we have nStackRoots for
+	// consistency.
 	nDataRoots, nBSSRoots, nSpanRoots, nStackRoots int
 
 	// Base indexes of each root type. Set by gcMarkRootPrepare.
 	baseData, baseBSS, baseSpans, baseStacks, baseEnd uint32
 
+	// stackRoots is a snapshot of all of the Gs that existed
+	// before the beginning of concurrent marking. The backing
+	// store of this must not be modified because it might be
+	// shared with allgs.
+	stackRoots []*g
+
 	// Each type of GC state transition is protected by a lock.
 	// Since multiple threads can simultaneously detect the state
 	// transition condition, any thread that detects a transition
@@ -1368,6 +1377,11 @@ func gcMark(startTime int64) {
 		throw("work.full != 0")
 	}
 
+	// Drop allg snapshot. allgs may have grown, in which case
+	// this is the only reference to the old backing store and
+	// there's no need to keep it around.
+	work.stackRoots = nil
+
 	// Clear out buffers and double-check that all gcWork caches
 	// are empty. This should be ensured by gcMarkDone before we
 	// enter mark termination.
diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go
index a5129bd1ee..a15c62cc49 100644
--- a/src/runtime/mgcmark.go
+++ b/src/runtime/mgcmark.go
@@ -102,7 +102,8 @@ func gcMarkRootPrepare() {
 	// 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 caught by the write barrier.
-	work.nStackRoots = int(atomic.Loaduintptr(&allglen))
+	work.stackRoots = allGsSnapshot()
+	work.nStackRoots = len(work.stackRoots)
 
 	work.markrootNext = 0
 	work.markrootJobs = uint32(fixedRootCount + work.nDataRoots + work.nBSSRoots + work.nSpanRoots + work.nStackRoots)
@@ -194,15 +195,12 @@ func markroot(gcw *gcWork, i uint32, flushBgCredit bool) int64 {
 	default:
 		// the rest is scanning goroutine stacks
 		workCounter = &gcController.stackScanWork
-		var gp *g
-		if work.baseStacks <= i && i < work.baseEnd {
-			// N.B. Atomic read of allglen in gcMarkRootPrepare
-			// acts as a barrier to ensure that allgs must be large
-			// enough to contain all relevant Gs.
-			gp = allgs[i-work.baseStacks]
-		} else {
+		if i < work.baseStacks || work.baseEnd <= i {
+			printlock()
+			print("runtime: markroot index ", i, " not in stack roots range [", work.baseStacks, ", ", work.baseEnd, ")\n")
 			throw("markroot: bad index")
 		}
+		gp := work.stackRoots[i-work.baseStacks]
 
 		// remember when we've first observed the G blocked
 		// needed only to output in traceback
diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index a238ea77f3..f375b67981 100644
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -547,6 +547,20 @@ func allgadd(gp *g) {
 	unlock(&allglock)
 }
 
+// allGsSnapshot returns a snapshot of the slice of all Gs.
+//
+// The world must be stopped or allglock must be held.
+func allGsSnapshot() []*g {
+	assertWorldStoppedOrLockHeld(&allglock)
+
+	// Because the world is stopped or allglock is held, allgadd
+	// cannot happen concurrently with this. allgs grows
+	// monotonically and existing entries never change, so we can
+	// simply return a copy of the slice header. For added safety,
+	// we trim everything past len because that can still change.
+	return allgs[:len(allgs):len(allgs)]
+}
+
 // atomicAllG returns &allgs[0] and len(allgs) for use with atomicAllGIndex.
 func atomicAllG() (**g, uintptr) {
 	length := atomic.Loaduintptr(&allglen)

From 6c4bf8fb8a2216a09d22ae0c87a04b7865f794c8 Mon Sep 17 00:00:00 2001
From: Baokun Lee 
Date: Wed, 1 Dec 2021 17:48:55 +0800
Subject: [PATCH 348/752] cmd/go/internal/modfetch: remove legacy code

ReadFileRevs function is no longer used.

Change-Id: Ibac6319dca4cf8010195e7c2fb502655494fb728
Reviewed-on: https://go-review.googlesource.com/c/go/+/367756
Run-TryBot: Baokun Lee 
Reviewed-by: Bryan C. Mills 
TryBot-Result: Go Bot 
Trust: Baokun Lee 
---
 .../go/internal/modfetch/codehost/codehost.go |  15 --
 src/cmd/go/internal/modfetch/codehost/git.go  | 134 ------------------
 src/cmd/go/internal/modfetch/codehost/vcs.go  |  13 --
 3 files changed, 162 deletions(-)

diff --git a/src/cmd/go/internal/modfetch/codehost/codehost.go b/src/cmd/go/internal/modfetch/codehost/codehost.go
index 378fbae34f..5063f8616a 100644
--- a/src/cmd/go/internal/modfetch/codehost/codehost.go
+++ b/src/cmd/go/internal/modfetch/codehost/codehost.go
@@ -55,21 +55,6 @@ type Repo interface {
 	// os.IsNotExist(err) returns true.
 	ReadFile(rev, file string, maxSize int64) (data []byte, err error)
 
-	// ReadFileRevs reads a single file at multiple versions.
-	// It should refuse to read more than maxSize bytes.
-	// The result is a map from each requested rev strings
-	// to the associated FileRev. The map must have a non-nil
-	// entry for every requested rev (unless ReadFileRevs returned an error).
-	// A file simply being missing or even corrupted in revs[i]
-	// should be reported only in files[revs[i]].Err, not in the error result
-	// from ReadFileRevs.
-	// The overall call should return an error (and no map) only
-	// in the case of a problem with obtaining the data, such as
-	// a network failure.
-	// Implementations may assume that revs only contain tags,
-	// not direct commit hashes.
-	ReadFileRevs(revs []string, file string, maxSize int64) (files map[string]*FileRev, err error)
-
 	// ReadZip downloads a zip file for the subdir subdirectory
 	// of the given revision to a new file in a given temporary directory.
 	// It should refuse to read more than maxSize bytes.
diff --git a/src/cmd/go/internal/modfetch/codehost/git.go b/src/cmd/go/internal/modfetch/codehost/git.go
index a782de56ff..2a5255f115 100644
--- a/src/cmd/go/internal/modfetch/codehost/git.go
+++ b/src/cmd/go/internal/modfetch/codehost/git.go
@@ -523,140 +523,6 @@ func (r *gitRepo) ReadFile(rev, file string, maxSize int64) ([]byte, error) {
 	return out, nil
 }
 
-func (r *gitRepo) ReadFileRevs(revs []string, file string, maxSize int64) (map[string]*FileRev, error) {
-	// Create space to hold results.
-	files := make(map[string]*FileRev)
-	for _, rev := range revs {
-		f := &FileRev{Rev: rev}
-		files[rev] = f
-	}
-
-	// Collect locally-known revs.
-	need, err := r.readFileRevs(revs, file, files)
-	if err != nil {
-		return nil, err
-	}
-	if len(need) == 0 {
-		return files, nil
-	}
-
-	// Build list of known remote refs that might help.
-	var redo []string
-	refs, err := r.loadRefs()
-	if err != nil {
-		return nil, err
-	}
-	for _, tag := range need {
-		if refs["refs/tags/"+tag] != "" {
-			redo = append(redo, tag)
-		}
-	}
-	if len(redo) == 0 {
-		return files, nil
-	}
-
-	// Protect r.fetchLevel and the "fetch more and more" sequence.
-	// See stat method above.
-	unlock, err := r.mu.Lock()
-	if err != nil {
-		return nil, err
-	}
-	defer unlock()
-
-	if err := r.fetchRefsLocked(); err != nil {
-		return nil, err
-	}
-
-	if _, err := r.readFileRevs(redo, file, files); err != nil {
-		return nil, err
-	}
-
-	return files, nil
-}
-
-func (r *gitRepo) readFileRevs(tags []string, file string, fileMap map[string]*FileRev) (missing []string, err error) {
-	var stdin bytes.Buffer
-	for _, tag := range tags {
-		fmt.Fprintf(&stdin, "refs/tags/%s\n", tag)
-		fmt.Fprintf(&stdin, "refs/tags/%s:%s\n", tag, file)
-	}
-
-	data, err := RunWithStdin(r.dir, &stdin, "git", "cat-file", "--batch")
-	if err != nil {
-		return nil, err
-	}
-
-	next := func() (typ string, body []byte, ok bool) {
-		var line string
-		i := bytes.IndexByte(data, '\n')
-		if i < 0 {
-			return "", nil, false
-		}
-		line, data = string(bytes.TrimSpace(data[:i])), data[i+1:]
-		if strings.HasSuffix(line, " missing") {
-			return "missing", nil, true
-		}
-		f := strings.Fields(line)
-		if len(f) != 3 {
-			return "", nil, false
-		}
-		n, err := strconv.Atoi(f[2])
-		if err != nil || n > len(data) {
-			return "", nil, false
-		}
-		body, data = data[:n], data[n:]
-		if len(data) > 0 && data[0] == '\r' {
-			data = data[1:]
-		}
-		if len(data) > 0 && data[0] == '\n' {
-			data = data[1:]
-		}
-		return f[1], body, true
-	}
-
-	badGit := func() ([]string, error) {
-		return nil, fmt.Errorf("malformed output from git cat-file --batch")
-	}
-
-	for _, tag := range tags {
-		commitType, _, ok := next()
-		if !ok {
-			return badGit()
-		}
-		fileType, fileData, ok := next()
-		if !ok {
-			return badGit()
-		}
-		f := fileMap[tag]
-		f.Data = nil
-		f.Err = nil
-		switch commitType {
-		default:
-			f.Err = fmt.Errorf("unexpected non-commit type %q for rev %s", commitType, tag)
-
-		case "missing":
-			// Note: f.Err must not satisfy os.IsNotExist. That's reserved for the file not existing in a valid commit.
-			f.Err = fmt.Errorf("no such rev %s", tag)
-			missing = append(missing, tag)
-
-		case "tag", "commit":
-			switch fileType {
-			default:
-				f.Err = &fs.PathError{Path: tag + ":" + file, Op: "read", Err: fmt.Errorf("unexpected non-blob type %q", fileType)}
-			case "missing":
-				f.Err = &fs.PathError{Path: tag + ":" + file, Op: "read", Err: fs.ErrNotExist}
-			case "blob":
-				f.Data = fileData
-			}
-		}
-	}
-	if len(bytes.TrimSpace(data)) != 0 {
-		return badGit()
-	}
-
-	return missing, nil
-}
-
 func (r *gitRepo) RecentTag(rev, prefix string, allowed func(string) bool) (tag string, err error) {
 	info, err := r.Stat(rev)
 	if err != nil {
diff --git a/src/cmd/go/internal/modfetch/codehost/vcs.go b/src/cmd/go/internal/modfetch/codehost/vcs.go
index c2cca084e3..c8449ccdcc 100644
--- a/src/cmd/go/internal/modfetch/codehost/vcs.go
+++ b/src/cmd/go/internal/modfetch/codehost/vcs.go
@@ -382,19 +382,6 @@ func (r *vcsRepo) ReadFile(rev, file string, maxSize int64) ([]byte, error) {
 	return out, nil
 }
 
-func (r *vcsRepo) ReadFileRevs(revs []string, file string, maxSize int64) (map[string]*FileRev, error) {
-	// We don't technically need to lock here since we're returning an error
-	// uncondititonally, but doing so anyway will help to avoid baking in
-	// lock-inversion bugs.
-	unlock, err := r.mu.Lock()
-	if err != nil {
-		return nil, err
-	}
-	defer unlock()
-
-	return nil, vcsErrorf("ReadFileRevs not implemented")
-}
-
 func (r *vcsRepo) RecentTag(rev, prefix string, allowed func(string) bool) (tag string, err error) {
 	// We don't technically need to lock here since we're returning an error
 	// uncondititonally, but doing so anyway will help to avoid baking in

From 0103fd2b8b3e57ead47a65501eb5ce5f444e0077 Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Tue, 30 Nov 2021 17:48:51 -0500
Subject: [PATCH 349/752] gcimporters: allow reusing empty interfaces on the
 RHS of type decls

We guard against caching or reusing interfaces on the RHS of a type
declaration, because for such interfaces the base type is used as the
interface method receiver type. However, we don't need to do this for
empty interfaces. By refining our guard, we can allow importing the
predeclared 'any' type on the RHS of a type declaration.

Update tests to add more coverage for importing generic export data.
Some accomodation had to be made for the unified builder, which does not
yet fully support generics in export data.

Fixes #49888

Change-Id: I51f329de464fc7309f95991b839ab55868c2924f
Reviewed-on: https://go-review.googlesource.com/c/go/+/367851
Trust: Robert Findley 
Run-TryBot: Robert Findley 
TryBot-Result: Go Bot 
Reviewed-by: Robert Griesemer 
---
 .../internal/importer/gcimporter_test.go      | 39 +++++++++++--------
 src/cmd/compile/internal/importer/iimport.go  | 22 ++++++++++-
 .../internal/importer/testdata/exports.go     | 19 +++++----
 .../internal/importer/testdata/generics.go    | 29 ++++++++++++++
 src/go/internal/gcimporter/gcimporter_test.go | 38 ++++++++++--------
 src/go/internal/gcimporter/iimport.go         | 22 ++++++++++-
 .../internal/gcimporter/testdata/exports.go   | 19 +++++----
 .../internal/gcimporter/testdata/generics.go  | 29 ++++++++++++++
 8 files changed, 163 insertions(+), 54 deletions(-)
 create mode 100644 src/cmd/compile/internal/importer/testdata/generics.go
 create mode 100644 src/go/internal/gcimporter/testdata/generics.go

diff --git a/src/cmd/compile/internal/importer/gcimporter_test.go b/src/cmd/compile/internal/importer/gcimporter_test.go
index 44c5e06cd6..e097507f69 100644
--- a/src/cmd/compile/internal/importer/gcimporter_test.go
+++ b/src/cmd/compile/internal/importer/gcimporter_test.go
@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"cmd/compile/internal/types2"
 	"fmt"
+	"internal/goexperiment"
 	"internal/testenv"
 	"os"
 	"os/exec"
@@ -107,25 +108,29 @@ func TestImportTestdata(t *testing.T) {
 		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
 	}
 
-	tmpdir := mktmpdir(t)
-	defer os.RemoveAll(tmpdir)
+	testfiles := map[string][]string{
+		"exports.go": {"go/ast", "go/token"},
+	}
+	if !goexperiment.Unified {
+		testfiles["generics.go"] = nil
+	}
 
-	compile(t, "testdata", "exports.go", filepath.Join(tmpdir, "testdata"))
+	for testfile, wantImports := range testfiles {
+		tmpdir := mktmpdir(t)
+		defer os.RemoveAll(tmpdir)
 
-	if pkg := testPath(t, "./testdata/exports", tmpdir); pkg != nil {
-		// The package's Imports list must include all packages
-		// explicitly imported by exports.go, plus all packages
-		// referenced indirectly via exported objects in exports.go.
-		// With the textual export format, the list may also include
-		// additional packages that are not strictly required for
-		// import processing alone (they are exported to err "on
-		// the safe side").
-		// TODO(gri) update the want list to be precise, now that
-		// the textual export data is gone.
-		got := fmt.Sprint(pkg.Imports())
-		for _, want := range []string{"go/ast", "go/token"} {
-			if !strings.Contains(got, want) {
-				t.Errorf(`Package("exports").Imports() = %s, does not contain %s`, got, want)
+		compile(t, "testdata", testfile, filepath.Join(tmpdir, "testdata"))
+		path := "./testdata/" + strings.TrimSuffix(testfile, ".go")
+
+		if pkg := testPath(t, path, tmpdir); pkg != nil {
+			// The package's Imports list must include all packages
+			// explicitly imported by testfile, plus all packages
+			// referenced indirectly via exported objects in testfile.
+			got := fmt.Sprint(pkg.Imports())
+			for _, want := range wantImports {
+				if !strings.Contains(got, want) {
+					t.Errorf(`Package("exports").Imports() = %s, does not contain %s`, got, want)
+				}
 			}
 		}
 	}
diff --git a/src/cmd/compile/internal/importer/iimport.go b/src/cmd/compile/internal/importer/iimport.go
index 23d6ca350e..7c51d3b16f 100644
--- a/src/cmd/compile/internal/importer/iimport.go
+++ b/src/cmd/compile/internal/importer/iimport.go
@@ -259,7 +259,7 @@ func (p *iimporter) posBaseAt(off uint64) *syntax.PosBase {
 }
 
 func (p *iimporter) typAt(off uint64, base *types2.Named) types2.Type {
-	if t, ok := p.typCache[off]; ok && (base == nil || !isInterface(t)) {
+	if t, ok := p.typCache[off]; ok && canReuse(base, t) {
 		return t
 	}
 
@@ -274,12 +274,30 @@ func (p *iimporter) typAt(off uint64, base *types2.Named) types2.Type {
 	r.declReader = *strings.NewReader(p.declData[off-predeclReserved:])
 	t := r.doType(base)
 
-	if base == nil || !isInterface(t) {
+	if canReuse(base, t) {
 		p.typCache[off] = t
 	}
 	return t
 }
 
+// canReuse reports whether the type rhs on the RHS of the declaration for def
+// may be re-used.
+//
+// Specifically, if def is non-nil and rhs is an interface type with methods, it
+// may not be re-used because we have a convention of setting the receiver type
+// for interface methods to def.
+func canReuse(def *types2.Named, rhs types2.Type) bool {
+	if def == nil {
+		return true
+	}
+	iface, _ := rhs.(*types2.Interface)
+	if iface == nil {
+		return true
+	}
+	// Don't use iface.Empty() here as iface may not be complete.
+	return iface.NumEmbeddeds() == 0 && iface.NumExplicitMethods() == 0
+}
+
 type importReader struct {
 	p           *iimporter
 	declReader  strings.Reader
diff --git a/src/cmd/compile/internal/importer/testdata/exports.go b/src/cmd/compile/internal/importer/testdata/exports.go
index 8ba3242102..91598c03e3 100644
--- a/src/cmd/compile/internal/importer/testdata/exports.go
+++ b/src/cmd/compile/internal/importer/testdata/exports.go
@@ -15,14 +15,17 @@ const init1 = 0
 func init() {}
 
 const (
-	C0 int = 0
-	C1     = 3.14159265
-	C2     = 2.718281828i
-	C3     = -123.456e-789
-	C4     = +123.456e+789
-	C5     = 1234i
-	C6     = "foo\n"
-	C7     = `bar\n`
+	C0  int     = 0
+	C1          = 3.14159265
+	C2          = 2.718281828i
+	C3          = -123.456e-789
+	C4          = +123.456e+789
+	C5          = 1234i
+	C6          = "foo\n"
+	C7          = `bar\n`
+	C8          = 42
+	C9  int     = 42
+	C10 float64 = 42
 )
 
 type (
diff --git a/src/cmd/compile/internal/importer/testdata/generics.go b/src/cmd/compile/internal/importer/testdata/generics.go
new file mode 100644
index 0000000000..00bf04000f
--- /dev/null
+++ b/src/cmd/compile/internal/importer/testdata/generics.go
@@ -0,0 +1,29 @@
+// 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.
+
+// This file is used to generate an object file which
+// serves as test file for gcimporter_test.go.
+
+package generics
+
+type Any any
+
+var x any
+
+type T[A, B any] struct {
+	Left  A
+	Right B
+}
+
+var X T[int, string] = T[int, string]{1, "hi"}
+
+func ToInt[P interface{ ~int }](p P) int { return int(p) }
+
+var IntID = ToInt[int]
+
+type G[C comparable] int
+
+func ImplicitFunc[T ~int]() {}
+
+type ImplicitType[T ~int] int
diff --git a/src/go/internal/gcimporter/gcimporter_test.go b/src/go/internal/gcimporter/gcimporter_test.go
index 3a9ed79df6..c0f4e3934b 100644
--- a/src/go/internal/gcimporter/gcimporter_test.go
+++ b/src/go/internal/gcimporter/gcimporter_test.go
@@ -118,25 +118,29 @@ func TestImportTestdata(t *testing.T) {
 		t.Skipf("gc-built packages not available (compiler = %s)", runtime.Compiler)
 	}
 
-	tmpdir := mktmpdir(t)
-	defer os.RemoveAll(tmpdir)
+	testfiles := map[string][]string{
+		"exports.go": {"go/ast", "go/token"},
+	}
+	if !goexperiment.Unified {
+		testfiles["generics.go"] = nil
+	}
 
-	compile(t, "testdata", "exports.go", filepath.Join(tmpdir, "testdata"))
+	for testfile, wantImports := range testfiles {
+		tmpdir := mktmpdir(t)
+		defer os.RemoveAll(tmpdir)
 
-	if pkg := testPath(t, "./testdata/exports", tmpdir); pkg != nil {
-		// The package's Imports list must include all packages
-		// explicitly imported by exports.go, plus all packages
-		// referenced indirectly via exported objects in exports.go.
-		// With the textual export format, the list may also include
-		// additional packages that are not strictly required for
-		// import processing alone (they are exported to err "on
-		// the safe side").
-		// TODO(gri) update the want list to be precise, now that
-		// the textual export data is gone.
-		got := fmt.Sprint(pkg.Imports())
-		for _, want := range []string{"go/ast", "go/token"} {
-			if !strings.Contains(got, want) {
-				t.Errorf(`Package("exports").Imports() = %s, does not contain %s`, got, want)
+		compile(t, "testdata", testfile, filepath.Join(tmpdir, "testdata"))
+		path := "./testdata/" + strings.TrimSuffix(testfile, ".go")
+
+		if pkg := testPath(t, path, tmpdir); pkg != nil {
+			// The package's Imports list must include all packages
+			// explicitly imported by testfile, plus all packages
+			// referenced indirectly via exported objects in testfile.
+			got := fmt.Sprint(pkg.Imports())
+			for _, want := range wantImports {
+				if !strings.Contains(got, want) {
+					t.Errorf(`Package("exports").Imports() = %s, does not contain %s`, got, want)
+				}
 			}
 		}
 	}
diff --git a/src/go/internal/gcimporter/iimport.go b/src/go/internal/gcimporter/iimport.go
index d7fc3ee7a9..c5b89aa042 100644
--- a/src/go/internal/gcimporter/iimport.go
+++ b/src/go/internal/gcimporter/iimport.go
@@ -255,7 +255,7 @@ func (p *iimporter) pkgAt(off uint64) *types.Package {
 }
 
 func (p *iimporter) typAt(off uint64, base *types.Named) types.Type {
-	if t, ok := p.typCache[off]; ok && (base == nil || !isInterface(t)) {
+	if t, ok := p.typCache[off]; ok && canReuse(base, t) {
 		return t
 	}
 
@@ -267,12 +267,30 @@ func (p *iimporter) typAt(off uint64, base *types.Named) types.Type {
 	r.declReader.Reset(p.declData[off-predeclReserved:])
 	t := r.doType(base)
 
-	if base == nil || !isInterface(t) {
+	if canReuse(base, t) {
 		p.typCache[off] = t
 	}
 	return t
 }
 
+// canReuse reports whether the type rhs on the RHS of the declaration for def
+// may be re-used.
+//
+// Specifically, if def is non-nil and rhs is an interface type with methods, it
+// may not be re-used because we have a convention of setting the receiver type
+// for interface methods to def.
+func canReuse(def *types.Named, rhs types.Type) bool {
+	if def == nil {
+		return true
+	}
+	iface, _ := rhs.(*types.Interface)
+	if iface == nil {
+		return true
+	}
+	// Don't use iface.Empty() here as iface may not be complete.
+	return iface.NumEmbeddeds() == 0 && iface.NumExplicitMethods() == 0
+}
+
 type importReader struct {
 	p          *iimporter
 	declReader bytes.Reader
diff --git a/src/go/internal/gcimporter/testdata/exports.go b/src/go/internal/gcimporter/testdata/exports.go
index 8ba3242102..91598c03e3 100644
--- a/src/go/internal/gcimporter/testdata/exports.go
+++ b/src/go/internal/gcimporter/testdata/exports.go
@@ -15,14 +15,17 @@ const init1 = 0
 func init() {}
 
 const (
-	C0 int = 0
-	C1     = 3.14159265
-	C2     = 2.718281828i
-	C3     = -123.456e-789
-	C4     = +123.456e+789
-	C5     = 1234i
-	C6     = "foo\n"
-	C7     = `bar\n`
+	C0  int     = 0
+	C1          = 3.14159265
+	C2          = 2.718281828i
+	C3          = -123.456e-789
+	C4          = +123.456e+789
+	C5          = 1234i
+	C6          = "foo\n"
+	C7          = `bar\n`
+	C8          = 42
+	C9  int     = 42
+	C10 float64 = 42
 )
 
 type (
diff --git a/src/go/internal/gcimporter/testdata/generics.go b/src/go/internal/gcimporter/testdata/generics.go
new file mode 100644
index 0000000000..00bf04000f
--- /dev/null
+++ b/src/go/internal/gcimporter/testdata/generics.go
@@ -0,0 +1,29 @@
+// 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.
+
+// This file is used to generate an object file which
+// serves as test file for gcimporter_test.go.
+
+package generics
+
+type Any any
+
+var x any
+
+type T[A, B any] struct {
+	Left  A
+	Right B
+}
+
+var X T[int, string] = T[int, string]{1, "hi"}
+
+func ToInt[P interface{ ~int }](p P) int { return int(p) }
+
+var IntID = ToInt[int]
+
+type G[C comparable] int
+
+func ImplicitFunc[T ~int]() {}
+
+type ImplicitType[T ~int] int

From c3a7fb207409a77b2ad644fe777db04d7df8e08c Mon Sep 17 00:00:00 2001
From: Cherry Mui 
Date: Wed, 1 Dec 2021 11:39:51 -0500
Subject: [PATCH 350/752] doc/go1.18: mention stack trace change

For #47694.

Change-Id: I06cac88d5328c8c0e38212ad801d70bc36cdfc6f
Reviewed-on: https://go-review.googlesource.com/c/go/+/368234
Trust: Cherry Mui 
Reviewed-by: Austin Clements 
---
 doc/go1.18.html | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 022541b83d..d9da160ab5 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -221,12 +221,15 @@ proposal.
   Go 1.17 release notes for more details.
 
    
 
-
    
-  TODO: https://golang.org/cl/298611: cmd/compile: add -asan option
+
    
+  Go 1.17 generally improved the formatting of arguments in stack traces,
+  but could print inaccurate values for arguments passed in registers.
+  This is improved in Go 1.18 by printing a question mark (?)
+  after each value that may be inaccurate.
 
    
 
-
    
-  TODO: https://golang.org/cl/352057: cmd/compile, runtime: track argument stack slot liveness
+
    
+  TODO: https://golang.org/cl/298611: cmd/compile: add -asan option
 
    
 
 
    Linker
    

From 00dbcb33f8c20ce51de558cbc9de811b1ba0f70c Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" 
Date: Wed, 1 Dec 2021 14:15:08 -0500
Subject: [PATCH 351/752] os/exec: in TestContextCancel, dump goroutines on
 failure

If this test fails, we want to know exactly what the os/exec
goroutines are doing. Panicking gives us a goroutine dump,
whereas t.Fatal does not.

While we're here, use exponential backoff instead of a hard-coded 1ms
sleep. We want to give the OS enough time to actually terminate the
subprocess.

For #42061

Change-Id: I3d50a71ac314853c68a935218e7f97ce18b08b5b
Reviewed-on: https://go-review.googlesource.com/c/go/+/368317
Trust: Bryan C. Mills 
Run-TryBot: Bryan C. Mills 
TryBot-Result: Go Bot 
Reviewed-by: Ian Lance Taylor 
---
 src/os/exec/exec_test.go | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/os/exec/exec_test.go b/src/os/exec/exec_test.go
index 6172c78dd4..81de018e09 100644
--- a/src/os/exec/exec_test.go
+++ b/src/os/exec/exec_test.go
@@ -954,6 +954,10 @@ func TestContext(t *testing.T) {
 }
 
 func TestContextCancel(t *testing.T) {
+	// To reduce noise in the final goroutine dump,
+	// let other parallel tests complete if possible.
+	t.Parallel()
+
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	c := helperCommandContext(t, ctx, "cat")
@@ -978,14 +982,25 @@ func TestContextCancel(t *testing.T) {
 	// Calling cancel should have killed the process, so writes
 	// should now fail.  Give the process a little while to die.
 	start := time.Now()
+	delay := 1 * time.Millisecond
 	for {
 		if _, err := io.WriteString(stdin, "echo"); err != nil {
 			break
 		}
+
 		if time.Since(start) > time.Minute {
-			t.Fatal("canceling context did not stop program")
+			// Panic instead of calling t.Fatal so that we get a goroutine dump.
+			// We want to know exactly what the os/exec goroutines got stuck on.
+			panic("canceling context did not stop program")
 		}
-		time.Sleep(time.Millisecond)
+
+		// Back off exponentially (up to 1-second sleeps) to give the OS time to
+		// terminate the process.
+		delay *= 2
+		if delay > 1*time.Second {
+			delay = 1 * time.Second
+		}
+		time.Sleep(delay)
 	}
 
 	if err := c.Wait(); err == nil {

From 1b2930d70c8bad5ecae08275e56e228e0f424b02 Mon Sep 17 00:00:00 2001
From: "Bryan C. Mills" 
Date: Wed, 1 Dec 2021 11:04:39 -0500
Subject: [PATCH 352/752] net: remove arbitrary deadlines in PacketConn tests
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

When TestPacketConn was added (in CL 6501057) it included arbitrary
100ms deadlines. Those deadlines were arbitrarily increased to 500ms
in CL 4922.

If the test is actually provoking a deadlock, allowing it to deadlock
will give us a more useful goroutine dump. Otherwise, the deadlines
don't seem all that useful — they appear to increase code coverage,
but have no effect on the test in the typical case, and can only
cause flakes on particularly-slow machines.

For #43627

Change-Id: I83de5217c54c743b83adddf51d4f6f2bd5b91732
Reviewed-on: https://go-review.googlesource.com/c/go/+/368215
Trust: Bryan C. Mills 
Run-TryBot: Bryan C. Mills 
TryBot-Result: Go Bot 
Reviewed-by: Ian Lance Taylor 
---
 src/net/packetconn_test.go | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/src/net/packetconn_test.go b/src/net/packetconn_test.go
index b3b1715655..487912efab 100644
--- a/src/net/packetconn_test.go
+++ b/src/net/packetconn_test.go
@@ -12,7 +12,6 @@ package net
 import (
 	"os"
 	"testing"
-	"time"
 )
 
 // The full stack test cases for IPConn have been moved to the
@@ -60,9 +59,6 @@ func TestPacketConn(t *testing.T) {
 		}
 		defer closer(c1, tt.net, tt.addr1, tt.addr2)
 		c1.LocalAddr()
-		c1.SetDeadline(time.Now().Add(500 * time.Millisecond))
-		c1.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
-		c1.SetWriteDeadline(time.Now().Add(500 * time.Millisecond))
 
 		c2, err := ListenPacket(tt.net, tt.addr2)
 		if err != nil {
@@ -70,9 +66,6 @@ func TestPacketConn(t *testing.T) {
 		}
 		defer closer(c2, tt.net, tt.addr1, tt.addr2)
 		c2.LocalAddr()
-		c2.SetDeadline(time.Now().Add(500 * time.Millisecond))
-		c2.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
-		c2.SetWriteDeadline(time.Now().Add(500 * time.Millisecond))
 		rb2 := make([]byte, 128)
 
 		if _, err := c1.WriteTo(wb, c2.LocalAddr()); err != nil {
@@ -115,9 +108,6 @@ func TestConnAndPacketConn(t *testing.T) {
 		}
 		defer closer(c1, tt.net, tt.addr1, tt.addr2)
 		c1.LocalAddr()
-		c1.SetDeadline(time.Now().Add(500 * time.Millisecond))
-		c1.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
-		c1.SetWriteDeadline(time.Now().Add(500 * time.Millisecond))
 
 		c2, err := Dial(tt.net, c1.LocalAddr().String())
 		if err != nil {
@@ -126,9 +116,6 @@ func TestConnAndPacketConn(t *testing.T) {
 		defer c2.Close()
 		c2.LocalAddr()
 		c2.RemoteAddr()
-		c2.SetDeadline(time.Now().Add(500 * time.Millisecond))
-		c2.SetReadDeadline(time.Now().Add(500 * time.Millisecond))
-		c2.SetWriteDeadline(time.Now().Add(500 * time.Millisecond))
 
 		if _, err := c2.Write(wb); err != nil {
 			t.Fatal(err)

From d34051bf16d86a88e6c5764aa076219069702045 Mon Sep 17 00:00:00 2001
From: Dan Scales 
Date: Wed, 1 Dec 2021 10:53:17 -0800
Subject: [PATCH 353/752] cmd/compile: fix case where g.curDecl should be
 saved/restored

When we set g.curDecl for the type params created during fillinMethods
for an instantiated type, we need to save/restore its value, because
fillinMethods() may be called while processing a typeDecl. We want the
value of g.curDecl to continue to be correct for type params created in
the typeDecl. Because of ordering issues, not restoring g.curDecl
happens to cause problems (which don't always show up visibly) exactly
when a type param is not actually used in a type declaration.

Cleared g.curDecl to "" at the later points in typeDecl() and
funcDecl(). This allows adding asserts that g.curDecl is always empty
("") when we set it in typeDecl() and funcDecl(), and always non-empty
when we use it in typ0().

Fixes #49893

Change-Id: Ic2fb1df791585bd257f2b86ffaae0453c31705c5
Reviewed-on: https://go-review.googlesource.com/c/go/+/368454
Trust: Dan Scales 
Run-TryBot: Dan Scales 
TryBot-Result: Go Bot 
Reviewed-by: Robert Findley 
---
 src/cmd/compile/internal/noder/decl.go  |  6 ++++++
 src/cmd/compile/internal/noder/types.go |  7 ++++++-
 test/typeparam/issue49893.dir/a.go      | 15 +++++++++++++++
 test/typeparam/issue49893.dir/b.go      | 15 +++++++++++++++
 test/typeparam/issue49893.dir/main.go   | 15 +++++++++++++++
 test/typeparam/issue49893.go            |  7 +++++++
 6 files changed, 64 insertions(+), 1 deletion(-)
 create mode 100644 test/typeparam/issue49893.dir/a.go
 create mode 100644 test/typeparam/issue49893.dir/b.go
 create mode 100644 test/typeparam/issue49893.dir/main.go
 create mode 100644 test/typeparam/issue49893.go

diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go
index 0143fd3d45..027c8598fd 100644
--- a/src/cmd/compile/internal/noder/decl.go
+++ b/src/cmd/compile/internal/noder/decl.go
@@ -86,6 +86,7 @@ func (g *irgen) constDecl(out *ir.Nodes, decl *syntax.ConstDecl) {
 }
 
 func (g *irgen) funcDecl(out *ir.Nodes, decl *syntax.FuncDecl) {
+	assert(g.curDecl == "")
 	// Set g.curDecl to the function name, as context for the type params declared
 	// during types2-to-types1 translation if this is a generic function.
 	g.curDecl = decl.Name.Value
@@ -133,6 +134,7 @@ func (g *irgen) funcDecl(out *ir.Nodes, decl *syntax.FuncDecl) {
 	}
 
 	haveEmbed := g.haveEmbed
+	g.curDecl = ""
 	g.later(func() {
 		defer func(b bool) { g.haveEmbed = b }(g.haveEmbed)
 
@@ -158,6 +160,7 @@ func (g *irgen) funcDecl(out *ir.Nodes, decl *syntax.FuncDecl) {
 }
 
 func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
+	assert(g.curDecl == "")
 	// Set g.curDecl to the type name, as context for the type params declared
 	// during types2-to-types1 translation if this is a generic type.
 	g.curDecl = decl.Name.Value
@@ -167,6 +170,7 @@ func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
 		assert(name.Alias()) // should be set by irgen.obj
 
 		out.Append(ir.NewDecl(g.pos(decl), ir.ODCLTYPE, name))
+		g.curDecl = ""
 		return
 	}
 
@@ -219,6 +223,7 @@ func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
 	}
 	types.ResumeCheckSize()
 
+	g.curDecl = ""
 	if otyp, ok := otyp.(*types2.Named); ok && otyp.NumMethods() != 0 {
 		methods := make([]*types.Field, otyp.NumMethods())
 		for i := range methods {
@@ -229,6 +234,7 @@ func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
 			meth := g.obj(m)
 			methods[i] = types.NewField(meth.Pos(), g.selector(m), meth.Type())
 			methods[i].Nname = meth
+			g.curDecl = ""
 		}
 		ntyp.Methods().Set(methods)
 	}
diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go
index fa24ab1844..4f6d828720 100644
--- a/src/cmd/compile/internal/noder/types.go
+++ b/src/cmd/compile/internal/noder/types.go
@@ -229,6 +229,7 @@ func (g *irgen) typ0(typ types2.Type) *types.Type {
 		pkg := g.tpkg(typ)
 		// Create the unique types1 name for a type param, using its context with a
 		// function, type, or method declaration.
+		assert(g.curDecl != "")
 		nm := g.curDecl + "." + typ.Obj().Name()
 		sym := pkg.Lookup(nm)
 		if sym.Def != nil {
@@ -331,11 +332,15 @@ func (g *irgen) fillinMethods(typ *types2.Named, ntyp *types.Type) {
 				tparams := make([]*types.Type, rparams.Len())
 				// Set g.curDecl to be the method context, so type
 				// params in the receiver of the method that we are
-				// translating gets the right unique name.
+				// translating gets the right unique name. We could
+				// be in a top-level typeDecl, so save and restore
+				// the current contents of g.curDecl.
+				savedCurDecl := g.curDecl
 				g.curDecl = typ.Obj().Name() + "." + m.Name()
 				for i := range tparams {
 					tparams[i] = g.typ1(rparams.At(i))
 				}
+				g.curDecl = savedCurDecl
 				assert(len(tparams) == len(targs))
 				ts := typecheck.Tsubster{
 					Tparams: tparams,
diff --git a/test/typeparam/issue49893.dir/a.go b/test/typeparam/issue49893.dir/a.go
new file mode 100644
index 0000000000..bc810cd3dd
--- /dev/null
+++ b/test/typeparam/issue49893.dir/a.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.
+
+package a
+
+type Option[T any] interface {
+	ToSeq() Seq[T]
+}
+
+type Seq[T any] []T
+
+func (r Seq[T]) Find(p func(v T) bool) Option[T] {
+	panic("")
+}
diff --git a/test/typeparam/issue49893.dir/b.go b/test/typeparam/issue49893.dir/b.go
new file mode 100644
index 0000000000..b36f6bddf0
--- /dev/null
+++ b/test/typeparam/issue49893.dir/b.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.
+
+package b
+
+import "a"
+
+type Ap1[A, B any] struct {
+	opt a.Option[A]
+}
+
+type Ap2[A, B any] struct {
+	opt a.Option[A]
+}
diff --git a/test/typeparam/issue49893.dir/main.go b/test/typeparam/issue49893.dir/main.go
new file mode 100644
index 0000000000..8b5b3bdad7
--- /dev/null
+++ b/test/typeparam/issue49893.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.
+
+package main
+
+import (
+	"b"
+	"fmt"
+)
+
+func main() {
+	opt := b.Ap1[string, string]{}
+	fmt.Println(opt)
+}
diff --git a/test/typeparam/issue49893.go b/test/typeparam/issue49893.go
new file mode 100644
index 0000000000..87b4ff46c1
--- /dev/null
+++ b/test/typeparam/issue49893.go
@@ -0,0 +1,7 @@
+// compiledir -G=3
+
+// 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

From 28ec0fdeb500b4d0ab5c0ac07cba2f5ebc12ae32 Mon Sep 17 00:00:00 2001
From: Austin Clements 
Date: Wed, 1 Dec 2021 13:41:45 -0500
Subject: [PATCH 354/752] runtime: print errno on clock_gettime failure on
 OpenBSD

For #49532.

Change-Id: I5afc64c987f0519903128550a7dac3a0f5e592cf
Reviewed-on: https://go-review.googlesource.com/c/go/+/368334
Trust: Austin Clements 
Run-TryBot: Austin Clements 
Reviewed-by: Joel Sing 
Reviewed-by: Cherry Mui 
---
 src/runtime/sys_openbsd2.go     | 16 ++++++++++++++--
 src/runtime/sys_openbsd_386.s   |  7 +++++--
 src/runtime/sys_openbsd_amd64.s |  7 +++++--
 src/runtime/sys_openbsd_arm.s   |  8 +++++---
 src/runtime/sys_openbsd_arm64.s |  8 +++++---
 5 files changed, 34 insertions(+), 12 deletions(-)

diff --git a/src/runtime/sys_openbsd2.go b/src/runtime/sys_openbsd2.go
index a7786fe65a..4d50b4f6b1 100644
--- a/src/runtime/sys_openbsd2.go
+++ b/src/runtime/sys_openbsd2.go
@@ -174,7 +174,13 @@ func nanotime1() int64 {
 		clock_id int32
 		tp       unsafe.Pointer
 	}{_CLOCK_MONOTONIC, unsafe.Pointer(&ts)}
-	libcCall(unsafe.Pointer(abi.FuncPCABI0(clock_gettime_trampoline)), unsafe.Pointer(&args))
+	if errno := libcCall(unsafe.Pointer(abi.FuncPCABI0(clock_gettime_trampoline)), unsafe.Pointer(&args)); errno < 0 {
+		// Avoid growing the nosplit stack.
+		systemstack(func() {
+			println("runtime: errno", -errno)
+			throw("clock_gettime failed")
+		})
+	}
 	return ts.tv_sec*1e9 + int64(ts.tv_nsec)
 }
 func clock_gettime_trampoline()
@@ -186,7 +192,13 @@ func walltime() (int64, int32) {
 		clock_id int32
 		tp       unsafe.Pointer
 	}{_CLOCK_REALTIME, unsafe.Pointer(&ts)}
-	libcCall(unsafe.Pointer(abi.FuncPCABI0(clock_gettime_trampoline)), unsafe.Pointer(&args))
+	if errno := libcCall(unsafe.Pointer(abi.FuncPCABI0(clock_gettime_trampoline)), unsafe.Pointer(&args)); errno < 0 {
+		// Avoid growing the nosplit stack.
+		systemstack(func() {
+			println("runtime: errno", -errno)
+			throw("clock_gettime failed")
+		})
+	}
 	return ts.tv_sec, int32(ts.tv_nsec)
 }
 
diff --git a/src/runtime/sys_openbsd_386.s b/src/runtime/sys_openbsd_386.s
index 7830b61b7d..890b96b673 100644
--- a/src/runtime/sys_openbsd_386.s
+++ b/src/runtime/sys_openbsd_386.s
@@ -520,8 +520,11 @@ TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
 	MOVL	BX, 4(SP)		// arg 2 - clock_id
 	CALL	libc_clock_gettime(SB)
 	CMPL	AX, $-1
-	JNE	2(PC)
-	MOVL	$0xf1, 0xf1		// crash on failure
+	JNE	noerr
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX
+	NEGL	AX			// caller expects negative errno
+noerr:
 	MOVL	BP, SP
 	POPL	BP
 	RET
diff --git a/src/runtime/sys_openbsd_amd64.s b/src/runtime/sys_openbsd_amd64.s
index fc89ee6cbb..fc6d5dc387 100644
--- a/src/runtime/sys_openbsd_amd64.s
+++ b/src/runtime/sys_openbsd_amd64.s
@@ -369,8 +369,11 @@ TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
 	MOVL	0(DI), DI		// arg 1 clock_id
 	CALL	libc_clock_gettime(SB)
 	TESTL	AX, AX
-	JEQ	2(PC)
-	MOVL	$0xf1, 0xf1  // crash
+	JEQ	noerr
+	CALL	libc_errno(SB)
+	MOVL	(AX), AX		// errno
+	NEGL	AX			// caller expects negative errno value
+noerr:
 	POPQ	BP
 	RET
 
diff --git a/src/runtime/sys_openbsd_arm.s b/src/runtime/sys_openbsd_arm.s
index 143fcf0518..a9cb1fbafe 100644
--- a/src/runtime/sys_openbsd_arm.s
+++ b/src/runtime/sys_openbsd_arm.s
@@ -407,9 +407,11 @@ TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
 	MOVW	0(R0), R0		// arg 1 clock_id
 	BL	libc_clock_gettime(SB)
 	CMP	$-1, R0
-	BNE	3(PC)
-	MOVW	$0, R8			// crash on failure
-	MOVW	R8, (R8)
+	BNE	noerr
+	BL	libc_errno(SB)
+	MOVW	(R0), R0		// errno
+	RSB.CS	$0, R0			// caller expects negative errno
+noerr:
 	MOVW	R9, R13
 	RET
 
diff --git a/src/runtime/sys_openbsd_arm64.s b/src/runtime/sys_openbsd_arm64.s
index 9b4acc90a5..3fa7e1ede2 100644
--- a/src/runtime/sys_openbsd_arm64.s
+++ b/src/runtime/sys_openbsd_arm64.s
@@ -359,9 +359,11 @@ TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
 	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)
+	BNE	noerr
+	CALL	libc_errno(SB)
+	MOVW	(R0), R0		// errno
+	NEG	R0, R0			// caller expects negative errno value
+noerr:
 	RET
 
 TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0

From 36be0beb05043e8ef3b8d108e9f8977b5eac0c87 Mon Sep 17 00:00:00 2001
From: Changkun Ou 
Date: Thu, 2 Dec 2021 16:01:09 +0100
Subject: [PATCH 355/752] misc/ios: bump min version

For #48076

Change-Id: I5edaa43af82c3478555c309a001a3d1b16de3d64
Reviewed-on: https://go-review.googlesource.com/c/go/+/368615
Run-TryBot: Cherry Mui 
Reviewed-by: Cherry Mui 
Reviewed-by: Dmitri Shuralyov 
Reviewed-by: Roland Shoemaker 
TryBot-Result: Gopher Robot 
---
 misc/ios/clangwrap.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/misc/ios/clangwrap.sh b/misc/ios/clangwrap.sh
index dca3fcc904..8f7b439315 100755
--- a/misc/ios/clangwrap.sh
+++ b/misc/ios/clangwrap.sh
@@ -17,4 +17,4 @@ export IPHONEOS_DEPLOYMENT_TARGET=5.1
 # cmd/cgo doesn't support llvm-gcc-4.2, so we have to use clang.
 CLANG=`xcrun --sdk $SDK --find clang`
 
-exec "$CLANG" -arch $CLANGARCH -isysroot "$SDK_PATH" -m${PLATFORM}-version-min=10.0 "$@"
+exec "$CLANG" -arch $CLANGARCH -isysroot "$SDK_PATH" -m${PLATFORM}-version-min=12.0 "$@"

From c5c1955077cb94736b0f311b3a02419d166f45ac Mon Sep 17 00:00:00 2001
From: Michael Anthony Knyszek 
Date: Wed, 1 Dec 2021 15:26:31 +0000
Subject: [PATCH 356/752] runtime: break out new minimum heap size into a
 goexperiment

The new minimum heap of 512 KiB has been the cause of some build
slowdown (~1%) and microbenchmark slowdown (usually ~0%, up to ~50%)
because of two reasons:
1. Applications with lots of small short-lived processes execute many
   more GC cycles.
2. Applications with heaps <4 MiB GC up to 8x more often.

In many ways these consequences are inevitable given how GOGC works,
however we need to investigate more as to whether the apparent slowdowns
are indeed unavoidable or if the GC has issues scaling down, which it's
too late for for this release.

Given that this release is already huge, it's OK to push this back.
We'll take a closer look at it next cycle, so place block it behind a
new goexperiment to allow users and ourselves to easily experiment with
it.

Fixes #49744.
Updates #44167.

Change-Id: Ibad51f7873de7517490c89802f3c593834e77ff0
Reviewed-on: https://go-review.googlesource.com/c/go/+/368137
Trust: Michael Knyszek 
Run-TryBot: Michael Knyszek 
TryBot-Result: Gopher Robot 
Reviewed-by: Austin Clements 
Reviewed-by: David Chase 
---
 src/internal/goexperiment/exp_heapminimum512kib_off.go | 9 +++++++++
 src/internal/goexperiment/exp_heapminimum512kib_on.go  | 9 +++++++++
 src/internal/goexperiment/flags.go                     | 7 +++++++
 src/runtime/mgcpacer.go                                | 4 ++--
 4 files changed, 27 insertions(+), 2 deletions(-)
 create mode 100644 src/internal/goexperiment/exp_heapminimum512kib_off.go
 create mode 100644 src/internal/goexperiment/exp_heapminimum512kib_on.go

diff --git a/src/internal/goexperiment/exp_heapminimum512kib_off.go b/src/internal/goexperiment/exp_heapminimum512kib_off.go
new file mode 100644
index 0000000000..09da431b40
--- /dev/null
+++ b/src/internal/goexperiment/exp_heapminimum512kib_off.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build !goexperiment.heapminimum512kib
+// +build !goexperiment.heapminimum512kib
+
+package goexperiment
+
+const HeapMinimum512KiB = false
+const HeapMinimum512KiBInt = 0
diff --git a/src/internal/goexperiment/exp_heapminimum512kib_on.go b/src/internal/goexperiment/exp_heapminimum512kib_on.go
new file mode 100644
index 0000000000..bab684b5e6
--- /dev/null
+++ b/src/internal/goexperiment/exp_heapminimum512kib_on.go
@@ -0,0 +1,9 @@
+// Code generated by mkconsts.go. DO NOT EDIT.
+
+//go:build goexperiment.heapminimum512kib
+// +build goexperiment.heapminimum512kib
+
+package goexperiment
+
+const HeapMinimum512KiB = true
+const HeapMinimum512KiBInt = 1
diff --git a/src/internal/goexperiment/flags.go b/src/internal/goexperiment/flags.go
index 3bf19222e1..6d935edc2b 100644
--- a/src/internal/goexperiment/flags.go
+++ b/src/internal/goexperiment/flags.go
@@ -89,4 +89,11 @@ type Flags struct {
 	// Details regarding the new pacer may be found at
 	// https://golang.org/design/44167-gc-pacer-redesign
 	PacerRedesign bool
+
+	// HeapMinimum512KiB reduces the minimum heap size to 512 KiB.
+	//
+	// This was originally reduced as part of PacerRedesign, but
+	// has been broken out to its own experiment that is disabled
+	// by default.
+	HeapMinimum512KiB bool
 }
diff --git a/src/runtime/mgcpacer.go b/src/runtime/mgcpacer.go
index 868666036c..6df8af45a8 100644
--- a/src/runtime/mgcpacer.go
+++ b/src/runtime/mgcpacer.go
@@ -53,8 +53,8 @@ const (
 	gcOverAssistWork = 64 << 10
 
 	// defaultHeapMinimum is the value of heapMinimum for GOGC==100.
-	defaultHeapMinimum = goexperiment.PacerRedesignInt*(512<<10) +
-		(1-goexperiment.PacerRedesignInt)*(4<<20)
+	defaultHeapMinimum = (goexperiment.HeapMinimum512KiBInt)*(512<<10) +
+		(1-goexperiment.HeapMinimum512KiBInt)*(4<<20)
 
 	// scannableStackSizeSlack is the bytes of stack space allocated or freed
 	// that can accumulate on a P before updating gcController.stackSize.

From 469f030dcaad765b3a40b2e0a88f4000357e61be Mon Sep 17 00:00:00 2001
From: Robert Findley 
Date: Thu, 2 Dec 2021 12:36:28 -0500
Subject: [PATCH 357/752] all: update vendored golang.org/x/tools

Update the vendored x/tools to pick up CL 364678, which updates vet
analyzers following a change to the underlying of type parameters.

This also pulls in significant changes to the typeutil package to
support new constructs in typeutil.Map, but this is not used by vet.

The following commands were used:

  go get -d golang.org/x/tools@e212aff8fd146c44ddb0167c1dfbd5531d6c9213
  go mod tidy
  go mod vendor

Fixes #49855

Change-Id: I3ffc59f3693710c83b81d390999aeabc8043723b
Reviewed-on: https://go-review.googlesource.com/c/go/+/368774
Trust: Robert Findley 
Reviewed-by: Dmitri Shuralyov 
Reviewed-by: Robert Griesemer 
Run-TryBot: Dmitri Shuralyov 
TryBot-Result: Gopher Robot 
---
 src/cmd/go.mod                                |   2 +-
 src/cmd/go.sum                                |   4 +-
 .../tools/go/analysis/passes/printf/printf.go |   8 +-
 .../tools/go/analysis/passes/printf/types.go  |   6 +-
 .../x/tools/go/types/typeutil/map.go          | 138 +++++++++++++++++-
 .../x/tools/internal/typeparams/common.go     |   7 +
 .../x/tools/internal/typeparams/normalize.go  |  38 ++++-
 .../internal/typeparams/typeparams_go117.go   |   1 +
 src/cmd/vendor/modules.txt                    |   2 +-
 9 files changed, 187 insertions(+), 19 deletions(-)

diff --git a/src/cmd/go.mod b/src/cmd/go.mod
index 75a93e6bd1..833c7d7b1f 100644
--- a/src/cmd/go.mod
+++ b/src/cmd/go.mod
@@ -8,7 +8,7 @@ require (
 	golang.org/x/mod v0.6.0-dev.0.20211102181907-3a5865c02020
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
 	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211
-	golang.org/x/tools v0.1.8-0.20211116011028-4adea5033c5c
+	golang.org/x/tools v0.1.8-0.20211202032535-e212aff8fd14
 )
 
 require (
diff --git a/src/cmd/go.sum b/src/cmd/go.sum
index 62619b8d01..0d39656a1d 100644
--- a/src/cmd/go.sum
+++ b/src/cmd/go.sum
@@ -18,7 +18,7 @@ golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e h1:i6Vklmyu+fZMFYpum+sR4ZWAB
 golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/tools v0.1.8-0.20211116011028-4adea5033c5c h1:EftGXIEk7/EwE5R+/azXJzSbzwNumuLeH9oupAN7YV0=
-golang.org/x/tools v0.1.8-0.20211116011028-4adea5033c5c/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
+golang.org/x/tools v0.1.8-0.20211202032535-e212aff8fd14 h1:KPFD5zp3T4bZL/kdosp4tGDJ6DKwUmYSWM0twy7w/bg=
+golang.org/x/tools v0.1.8-0.20211202032535-e212aff8fd14/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
index 0206073578..dee37d78ae 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/printf/printf.go
@@ -25,6 +25,7 @@ import (
 	"golang.org/x/tools/go/analysis/passes/internal/analysisutil"
 	"golang.org/x/tools/go/ast/inspector"
 	"golang.org/x/tools/go/types/typeutil"
+	"golang.org/x/tools/internal/typeparams"
 )
 
 func init() {
@@ -520,7 +521,12 @@ func printfNameAndKind(pass *analysis.Pass, call *ast.CallExpr) (fn *types.Func,
 func isFormatter(typ types.Type) bool {
 	// If the type is an interface, the value it holds might satisfy fmt.Formatter.
 	if _, ok := typ.Underlying().(*types.Interface); ok {
-		return true
+		// Don't assume type parameters could be formatters. With the greater
+		// expressiveness of constraint interface syntax we expect more type safety
+		// when using type parameters.
+		if !typeparams.IsTypeParam(typ) {
+			return true
+		}
 	}
 	obj, _, _ := types.LookupFieldOrMethod(typ, false, nil, "Format")
 	fn, ok := obj.(*types.Func)
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 81bf36e1ee..270e917c80 100644
--- 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
@@ -178,10 +178,12 @@ func (m *argMatcher) match(typ types.Type, topLevel bool) bool {
 			return true
 		}
 
+		if typeparams.IsTypeParam(typ.Elem()) {
+			return true // We don't know whether the logic below applies. Give up.
+		}
+
 		under := typ.Elem().Underlying()
 		switch under.(type) {
-		case *typeparams.TypeParam:
-			return true // We don't know whether the logic below applies. Give up.
 		case *types.Struct: // see below
 		case *types.Array: // see below
 		case *types.Slice: // see below
diff --git a/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/map.go b/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/map.go
index c7f7545006..490ee904a6 100644
--- a/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/map.go
+++ b/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/map.go
@@ -11,6 +11,8 @@ import (
 	"fmt"
 	"go/types"
 	"reflect"
+
+	"golang.org/x/tools/internal/typeparams"
 )
 
 // Map is a hash-table-based mapping from types (types.Type) to
@@ -211,11 +213,29 @@ func (m *Map) KeysString() string {
 // Call MakeHasher to create a Hasher.
 type Hasher struct {
 	memo map[types.Type]uint32
+
+	// ptrMap records pointer identity.
+	ptrMap map[interface{}]uint32
+
+	// sigTParams holds type parameters from the signature being hashed.
+	// Signatures are considered identical modulo renaming of type parameters, so
+	// within the scope of a signature type the identity of the signature's type
+	// parameters is just their index.
+	//
+	// Since the language does not currently support referring to uninstantiated
+	// generic types or functions, and instantiated signatures do not have type
+	// parameter lists, we should never encounter a second non-empty type
+	// parameter list when hashing a generic signature.
+	sigTParams *typeparams.TypeParamList
 }
 
 // MakeHasher returns a new Hasher instance.
 func MakeHasher() Hasher {
-	return Hasher{make(map[types.Type]uint32)}
+	return Hasher{
+		memo:       make(map[types.Type]uint32),
+		ptrMap:     make(map[interface{}]uint32),
+		sigTParams: nil,
+	}
 }
 
 // Hash computes a hash value for the given type t such that
@@ -273,17 +293,62 @@ func (h Hasher) hashFor(t types.Type) uint32 {
 		if t.Variadic() {
 			hash *= 8863
 		}
+
+		// Use a separate hasher for types inside of the signature, where type
+		// parameter identity is modified to be (index, constraint). We must use a
+		// new memo for this hasher as type identity may be affected by this
+		// masking. For example, in func[T any](*T), the identity of *T depends on
+		// whether we are mapping the argument in isolation, or recursively as part
+		// of hashing the signature.
+		//
+		// We should never encounter a generic signature while hashing another
+		// generic signature, but defensively set sigTParams only if h.mask is
+		// unset.
+		tparams := typeparams.ForSignature(t)
+		if h.sigTParams == nil && tparams.Len() != 0 {
+			h = Hasher{
+				// There may be something more efficient than discarding the existing
+				// memo, but it would require detecting whether types are 'tainted' by
+				// references to type parameters.
+				memo: make(map[types.Type]uint32),
+				// Re-using ptrMap ensures that pointer identity is preserved in this
+				// hasher.
+				ptrMap:     h.ptrMap,
+				sigTParams: tparams,
+			}
+		}
+
+		for i := 0; i < tparams.Len(); i++ {
+			tparam := tparams.At(i)
+			hash += 7 * h.Hash(tparam.Constraint())
+		}
+
 		return hash + 3*h.hashTuple(t.Params()) + 5*h.hashTuple(t.Results())
 
+	case *typeparams.Union:
+		return h.hashUnion(t)
+
 	case *types.Interface:
+		// Interfaces are identical if they have the same set of methods, with
+		// identical names and types, and they have the same set of type
+		// restrictions. See go/types.identical for more details.
 		var hash uint32 = 9103
+
+		// Hash methods.
 		for i, n := 0, t.NumMethods(); i < n; i++ {
-			// See go/types.identicalMethods for rationale.
 			// Method order is not significant.
 			// Ignore m.Pkg().
 			m := t.Method(i)
 			hash += 3*hashString(m.Name()) + 5*h.Hash(m.Type())
 		}
+
+		// Hash type restrictions.
+		terms, err := typeparams.InterfaceTermSet(t)
+		// if err != nil t has invalid type restrictions.
+		if err == nil {
+			hash += h.hashTermSet(terms)
+		}
+
 		return hash
 
 	case *types.Map:
@@ -293,13 +358,22 @@ func (h Hasher) hashFor(t types.Type) uint32 {
 		return 9127 + 2*uint32(t.Dir()) + 3*h.Hash(t.Elem())
 
 	case *types.Named:
-		// Not safe with a copying GC; objects may move.
-		return uint32(reflect.ValueOf(t.Obj()).Pointer())
+		hash := h.hashPtr(t.Obj())
+		targs := typeparams.NamedTypeArgs(t)
+		for i := 0; i < targs.Len(); i++ {
+			targ := targs.At(i)
+			hash += 2 * h.Hash(targ)
+		}
+		return hash
+
+	case *typeparams.TypeParam:
+		return h.hashTypeParam(t)
 
 	case *types.Tuple:
 		return h.hashTuple(t)
 	}
-	panic(t)
+
+	panic(fmt.Sprintf("%T: %v", t, t))
 }
 
 func (h Hasher) hashTuple(tuple *types.Tuple) uint32 {
@@ -311,3 +385,57 @@ func (h Hasher) hashTuple(tuple *types.Tuple) uint32 {
 	}
 	return hash
 }
+
+func (h Hasher) hashUnion(t *typeparams.Union) uint32 {
+	// Hash type restrictions.
+	terms, err := typeparams.UnionTermSet(t)
+	// if err != nil t has invalid type restrictions. Fall back on a non-zero
+	// hash.
+	if err != nil {
+		return 9151
+	}
+	return h.hashTermSet(terms)
+}
+
+func (h Hasher) hashTermSet(terms []*typeparams.Term) uint32 {
+	var hash uint32 = 9157 + 2*uint32(len(terms))
+	for _, term := range terms {
+		// term order is not significant.
+		termHash := h.Hash(term.Type())
+		if term.Tilde() {
+			termHash *= 9161
+		}
+		hash += 3 * termHash
+	}
+	return hash
+}
+
+// hashTypeParam returns a hash of the type parameter t, with a hash value
+// depending on whether t is contained in h.sigTParams.
+//
+// If h.sigTParams is set and contains t, then we are in the process of hashing
+// a signature, and the hash value of t must depend only on t's index and
+// constraint: signatures are considered identical modulo type parameter
+// renaming.
+//
+// Otherwise the hash of t depends only on t's pointer identity.
+func (h Hasher) hashTypeParam(t *typeparams.TypeParam) uint32 {
+	if h.sigTParams != nil {
+		i := t.Index()
+		if i >= 0 && i < h.sigTParams.Len() && t == h.sigTParams.At(i) {
+			return 9173 + 2*h.Hash(t.Constraint()) + 3*uint32(i)
+		}
+	}
+	return h.hashPtr(t.Obj())
+}
+
+// hashPtr hashes the pointer identity of ptr. It uses h.ptrMap to ensure that
+// pointers values are not dependent on the GC.
+func (h Hasher) hashPtr(ptr interface{}) uint32 {
+	if hash, ok := h.ptrMap[ptr]; ok {
+		return hash
+	}
+	hash := uint32(reflect.ValueOf(ptr).Pointer())
+	h.ptrMap[ptr] = hash
+	return hash
+}
diff --git a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/common.go b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/common.go
index 9fc6b4beb8..961d036fdb 100644
--- a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/common.go
+++ b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/common.go
@@ -13,6 +13,7 @@ package typeparams
 import (
 	"go/ast"
 	"go/token"
+	"go/types"
 )
 
 // A IndexExprData holds data from both ast.IndexExpr and the new
@@ -23,3 +24,9 @@ type IndexExprData struct {
 	Indices []ast.Expr // index expressions
 	Rbrack  token.Pos  // position of "]"
 }
+
+// IsTypeParam reports whether t is a type parameter.
+func IsTypeParam(t types.Type) bool {
+	_, ok := t.(*TypeParam)
+	return ok
+}
diff --git a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/normalize.go b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/normalize.go
index f41ec6ec0b..090f142a5f 100644
--- a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/normalize.go
+++ b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/normalize.go
@@ -23,9 +23,9 @@ var ErrEmptyTypeSet = errors.New("empty type set")
 //
 // Structural type restrictions of a type parameter are created via
 // non-interface types embedded in its constraint interface (directly, or via a
-// chain of interface embeddings). For example, in the declaration `type T[P
-// interface{~int; m()}] int`, the structural restriction of the type parameter
-// P is ~int.
+// chain of interface embeddings). For example, in the declaration
+//  type T[P interface{~int; m()}] int
+// the structural restriction of the type parameter P is ~int.
 //
 // With interface embedding and unions, the specification of structural type
 // restrictions may be arbitrarily complex. For example, consider the
@@ -67,7 +67,31 @@ func StructuralTerms(tparam *TypeParam) ([]*Term, error) {
 	if iface == nil {
 		return nil, fmt.Errorf("constraint is %T, not *types.Interface", constraint.Underlying())
 	}
-	tset, err := computeTermSet(iface, make(map[types.Type]*termSet), 0)
+	return InterfaceTermSet(iface)
+}
+
+// InterfaceTermSet computes the normalized terms for a constraint interface,
+// returning an error if the term set cannot be computed or is empty. In the
+// latter case, the error will be ErrEmptyTypeSet.
+//
+// See the documentation of StructuralTerms for more information on
+// normalization.
+func InterfaceTermSet(iface *types.Interface) ([]*Term, error) {
+	return computeTermSet(iface)
+}
+
+// UnionTermSet computes the normalized terms for a union, returning an error
+// if the term set cannot be computed or is empty. In the latter case, the
+// error will be ErrEmptyTypeSet.
+//
+// See the documentation of StructuralTerms for more information on
+// normalization.
+func UnionTermSet(union *Union) ([]*Term, error) {
+	return computeTermSet(union)
+}
+
+func computeTermSet(typ types.Type) ([]*Term, error) {
+	tset, err := computeTermSetInternal(typ, make(map[types.Type]*termSet), 0)
 	if err != nil {
 		return nil, err
 	}
@@ -98,7 +122,7 @@ func indentf(depth int, format string, args ...interface{}) {
 	fmt.Fprintf(os.Stderr, strings.Repeat(".", depth)+format+"\n", args...)
 }
 
-func computeTermSet(t types.Type, seen map[types.Type]*termSet, depth int) (res *termSet, err error) {
+func computeTermSetInternal(t types.Type, seen map[types.Type]*termSet, depth int) (res *termSet, err error) {
 	if t == nil {
 		panic("nil type")
 	}
@@ -139,7 +163,7 @@ func computeTermSet(t types.Type, seen map[types.Type]*termSet, depth int) (res
 			if _, ok := embedded.Underlying().(*TypeParam); ok {
 				return nil, fmt.Errorf("invalid embedded type %T", embedded)
 			}
-			tset2, err := computeTermSet(embedded, seen, depth+1)
+			tset2, err := computeTermSetInternal(embedded, seen, depth+1)
 			if err != nil {
 				return nil, err
 			}
@@ -153,7 +177,7 @@ func computeTermSet(t types.Type, seen map[types.Type]*termSet, depth int) (res
 			var terms termlist
 			switch t.Type().Underlying().(type) {
 			case *types.Interface:
-				tset2, err := computeTermSet(t.Type(), seen, depth+1)
+				tset2, err := computeTermSetInternal(t.Type(), seen, depth+1)
 				if err != nil {
 					return nil, err
 				}
diff --git a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go117.go b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go117.go
index 6ad3a43a2c..e509daf7be 100644
--- a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go117.go
+++ b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go117.go
@@ -75,6 +75,7 @@ func ForFuncType(*ast.FuncType) *ast.FieldList {
 // this Go version. Its methods panic on use.
 type TypeParam struct{ types.Type }
 
+func (*TypeParam) Index() int             { unsupported(); return 0 }
 func (*TypeParam) Constraint() types.Type { unsupported(); return nil }
 func (*TypeParam) Obj() *types.TypeName   { unsupported(); return nil }
 
diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt
index fd955a6932..0c107cd5ea 100644
--- a/src/cmd/vendor/modules.txt
+++ b/src/cmd/vendor/modules.txt
@@ -51,7 +51,7 @@ golang.org/x/sys/windows
 # golang.org/x/term v0.0.0-20210927222741-03fcf44c2211
 ## explicit; go 1.17
 golang.org/x/term
-# golang.org/x/tools v0.1.8-0.20211116011028-4adea5033c5c
+# golang.org/x/tools v0.1.8-0.20211202032535-e212aff8fd14
 ## explicit; go 1.17
 golang.org/x/tools/cover
 golang.org/x/tools/go/analysis

From 3c6295d272d09e6c7be912510e4b62afc0ef8ffc Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Fri, 19 Nov 2021 16:51:47 -0500
Subject: [PATCH 358/752] doc/go1.18: add short-circuit evaluation for
 text/template

This description is based on https://golang.org/cl/321490.

Updates #47694

Change-Id: I48656cd487d2fccf0b0d3390f350f1bc6f2b0080
Reviewed-on: https://go-review.googlesource.com/c/go/+/365738
Trust: Jeremy Faller 
Trust: Dmitri Shuralyov 
Run-TryBot: Jeremy Faller 
TryBot-Result: Gopher Robot 
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Dmitri Shuralyov 
---
 doc/go1.18.html | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index d9da160ab5..74d0e0c23e 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -290,7 +290,7 @@ proposal.
 
    bufio
    
   
    
     
    
-      The new Writer.AvailableBuffer
+      The new Writer.AvailableBuffer
       method returns an empty buffer with a possibly non-empty capacity for use
       with append-like APIs. After appending, the buffer can be provided to a
 			succeeding Write call and possibly avoid any copying.
@@ -517,7 +517,11 @@ proposal.
 
    text/template
    
   
    
     
    
-      TODO: https://golang.org/cl/321490: implement short-circuit and, or
+      The and function no longer always evaluates all arguments; it
+      stops evaluating arguments after the first argument that evaluates to
+      false.  Similarly, the or function now stops evaluating
+      arguments after the first argument that evaluates to true. This makes a
+      difference if any of the arguments is a function call.
     
    
   
    
 
    

From bbe1be5c19f04816f5f9162c2be75351480c92a0 Mon Sep 17 00:00:00 2001
From: Dan Scales 
Date: Mon, 29 Nov 2021 11:45:17 -0800
Subject: [PATCH 359/752] cmd/compile: report channel size errors correctly for
 -G=3

First, we need to set base.Pos in varDecl() and typeDecl(), so it will
be correct if we need to report type size errors while converting types.
Changed error calls in types/sizes.go to use Errorf, not ErrorfAt, since
we want to use base.Pos (which will set from t.Pos(), if that is
available).

Second, we need to add an extra call CalcSize(t1.Elem()) in the
TCHANARGS case of CalcSize(). We can use CalcSize() rather than
CheckSize(), since we know the top-level recursive type will have been
calculated by the time we process the fake TCHANARGS type. In -G=0 mode,
the size of the channel element has often been calculated because of
some other processing (but not in the case of #49767). But in -G=3 mode,
we just calculate sizes during the single noder2 pass, so we are more
likely to have not gotten to calculating the size of the element yet,
depending on the order of processing of the deferredTypeStack.

Fixes the tests fixedbugs/issue{42058a,42058b}.go that were
disabled for -G=3 mode.

Had to add exceptions in stdlib_test.go for go/types and types2, because
the types2 typechecker does not know about type size limits.

Fixes #49814
Fixes #49771
Updates #49767

Change-Id: I77d058e8ceff68a58c4c386a8cf46799c54b04c3
Reviewed-on: https://go-review.googlesource.com/c/go/+/367955
Trust: Dan Scales 
Run-TryBot: Dan Scales 
TryBot-Result: Gopher Robot 
Reviewed-by: Keith Randall 
---
 src/cmd/compile/internal/noder/decl.go         |  4 ++++
 src/cmd/compile/internal/types/size.go         | 15 ++++++++++-----
 src/cmd/compile/internal/types2/stdlib_test.go |  2 ++
 src/go/types/stdlib_test.go                    |  2 ++
 test/fixedbugs/issue49767.go                   | 12 ++++++++++++
 test/fixedbugs/issue49814.go                   | 14 ++++++++++++++
 test/run.go                                    | 15 ++++++++-------
 7 files changed, 52 insertions(+), 12 deletions(-)
 create mode 100644 test/fixedbugs/issue49767.go
 create mode 100644 test/fixedbugs/issue49814.go

diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go
index 027c8598fd..b7fd95e2e8 100644
--- a/src/cmd/compile/internal/noder/decl.go
+++ b/src/cmd/compile/internal/noder/decl.go
@@ -160,6 +160,8 @@ func (g *irgen) funcDecl(out *ir.Nodes, decl *syntax.FuncDecl) {
 }
 
 func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
+	// Set the position for any error messages we might print (e.g. too large types).
+	base.Pos = g.pos(decl)
 	assert(g.curDecl == "")
 	// Set g.curDecl to the type name, as context for the type params declared
 	// during types2-to-types1 translation if this is a generic type.
@@ -244,6 +246,8 @@ func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
 
 func (g *irgen) varDecl(out *ir.Nodes, decl *syntax.VarDecl) {
 	pos := g.pos(decl)
+	// Set the position for any error messages we might print (e.g. too large types).
+	base.Pos = pos
 	names := make([]*ir.Name, len(decl.NameList))
 	for i, name := range decl.NameList {
 		names[i], _ = g.def(name)
diff --git a/src/cmd/compile/internal/types/size.go b/src/cmd/compile/internal/types/size.go
index 0f3db06c1d..fb6accdc64 100644
--- a/src/cmd/compile/internal/types/size.go
+++ b/src/cmd/compile/internal/types/size.go
@@ -450,16 +450,21 @@ func CalcSize(t *Type) {
 
 		CheckSize(t.Elem())
 
-		// make fake type to check later to
-		// trigger channel argument check.
+		// Make fake type to trigger channel element size check after
+		// any top-level recursive type has been completed.
 		t1 := NewChanArgs(t)
 		CheckSize(t1)
 
 	case TCHANARGS:
 		t1 := t.ChanArgs()
 		CalcSize(t1) // just in case
+		// Make sure size of t1.Elem() is calculated at this point. We can
+		// use CalcSize() here rather than CheckSize(), because the top-level
+		// (possibly recursive) type will have been calculated before the fake
+		// chanargs is handled.
+		CalcSize(t1.Elem())
 		if t1.Elem().width >= 1<<16 {
-			base.ErrorfAt(typePos(t1), "channel element type too large (>64kB)")
+			base.Errorf("channel element type too large (>64kB)")
 		}
 		w = 1 // anything will do
 
@@ -492,7 +497,7 @@ func CalcSize(t *Type) {
 		if t.Elem().width != 0 {
 			cap := (uint64(MaxWidth) - 1) / uint64(t.Elem().width)
 			if uint64(t.NumElem()) > cap {
-				base.ErrorfAt(typePos(t), "type %L larger than address space", t)
+				base.Errorf("type %L larger than address space", t)
 			}
 		}
 		w = t.NumElem() * t.Elem().width
@@ -539,7 +544,7 @@ func CalcSize(t *Type) {
 	}
 
 	if PtrSize == 4 && w != int64(int32(w)) {
-		base.ErrorfAt(typePos(t), "type %v too large", t)
+		base.Errorf("type %v too large", t)
 	}
 
 	t.width = w
diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go
index 9c22f01673..5ac01ac253 100644
--- a/src/cmd/compile/internal/types2/stdlib_test.go
+++ b/src/cmd/compile/internal/types2/stdlib_test.go
@@ -194,6 +194,8 @@ func TestStdFixed(t *testing.T) {
 		"issue42058b.go", // types2 does not have constraints on channel element size
 		"issue48097.go",  // go/types doesn't check validity of //go:xxx directives, and non-init bodyless function
 		"issue48230.go",  // go/types doesn't check validity of //go:xxx directives
+		"issue49767.go",  // go/types does not have constraints on channel element size
+		"issue49814.go",  // go/types does not have constraints on array size
 	)
 }
 
diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go
index b0d7fdd3d9..c56e0ba428 100644
--- a/src/go/types/stdlib_test.go
+++ b/src/go/types/stdlib_test.go
@@ -196,6 +196,8 @@ func TestStdFixed(t *testing.T) {
 		"issue42058b.go", // go/types does not have constraints on channel element size
 		"issue48097.go",  // go/types doesn't check validity of //go:xxx directives, and non-init bodyless function
 		"issue48230.go",  // go/types doesn't check validity of //go:xxx directives
+		"issue49767.go",  // go/types does not have constraints on channel element size
+		"issue49814.go",  // go/types does not have constraints on array size
 	)
 }
 
diff --git a/test/fixedbugs/issue49767.go b/test/fixedbugs/issue49767.go
new file mode 100644
index 0000000000..e25081dc93
--- /dev/null
+++ b/test/fixedbugs/issue49767.go
@@ -0,0 +1,12 @@
+// 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 main
+
+func main() {
+	ch := make(chan struct{ v [65536]byte }) // ERROR "channel element type too large"
+	close(ch)
+}
diff --git a/test/fixedbugs/issue49814.go b/test/fixedbugs/issue49814.go
new file mode 100644
index 0000000000..fd487d8ccb
--- /dev/null
+++ b/test/fixedbugs/issue49814.go
@@ -0,0 +1,14 @@
+// errorcheck -G=3
+
+// 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
+
+// "must be integer" error is for 32-bit architectures
+type V [1 << 50]byte // ERROR "larger than address space|must be integer"
+
+var X [1 << 50]byte // ERROR "larger than address space|must be integer"
+
+func main() {}
diff --git a/test/run.go b/test/run.go
index bdc2f0a277..c6e82891da 100644
--- a/test/run.go
+++ b/test/run.go
@@ -2153,8 +2153,6 @@ var types2Failures = setOf(
 	"fixedbugs/issue28268.go",  // types2 reports follow-on errors
 	"fixedbugs/issue31053.go",  // types2 reports "unknown field" instead of "cannot refer to unexported field"
 	"fixedbugs/issue33460.go",  // types2 reports alternative positions in separate error
-	"fixedbugs/issue42058a.go", // types2 doesn't report "channel element type too large"
-	"fixedbugs/issue42058b.go", // types2 doesn't report "channel element type too large"
 	"fixedbugs/issue4232.go",   // types2 reports (correct) extra errors
 	"fixedbugs/issue4452.go",   // types2 reports (correct) extra errors
 	"fixedbugs/issue4510.go",   // types2 reports different (but ok) line numbers
@@ -2171,7 +2169,6 @@ var types2Failures32Bit = setOf(
 	"printbig.go",             // large untyped int passed to print (32-bit)
 	"fixedbugs/bug114.go",     // large untyped int passed to println (32-bit)
 	"fixedbugs/issue23305.go", // large untyped int passed to println (32-bit)
-	"fixedbugs/bug385_32.go",  // types2 doesn't produce missing error "type .* too large" (32-bit specific)
 )
 
 var g3Failures = setOf(
@@ -2183,10 +2180,14 @@ var unifiedFailures = setOf(
 	"escape4.go",  // unified IR can inline f5 and f6; test doesn't expect this
 	"inline.go",   // unified IR reports function literal diagnostics on different lines than -d=inlfuncswithclosures
 
-	"fixedbugs/issue42284.go", // prints "T(0) does not escape", but test expects "a.I(a.T(0)) does not escape"
-	"fixedbugs/issue7921.go",  // prints "… escapes to heap", but test expects "string(…) escapes to heap"
-	"typeparam/issue48538.go", // assertion failure, interprets struct key as closure variable
-	"typeparam/issue47631.go", // unified IR can handle local type declarations
+	"fixedbugs/issue42284.go",  // prints "T(0) does not escape", but test expects "a.I(a.T(0)) does not escape"
+	"fixedbugs/issue7921.go",   // prints "… escapes to heap", but test expects "string(…) escapes to heap"
+	"typeparam/issue48538.go",  // assertion failure, interprets struct key as closure variable
+	"typeparam/issue47631.go",  // unified IR can handle local type declarations
+	"fixedbugs/issue42058a.go", // unified IR doesn't report channel element too large
+	"fixedbugs/issue42058b.go", // unified IR doesn't report channel element too large
+	"fixedbugs/issue49767.go",  // unified IR doesn't report channel element too large
+	"fixedbugs/issue49814.go",  // unified IR doesn't report array type too large
 )
 
 func setOf(keys ...string) map[string]bool {

From d514411625bdd437c7d1997b92685bb03bfbf2a8 Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Wed, 1 Dec 2021 12:44:04 -0500
Subject: [PATCH 360/752] doc/go1.18: add information on new pacer.

This is based off Michael's notes.

Updates #47694

Change-Id: I6e7944f85b776e8481829a2fafd177a49557c6ca
Reviewed-on: https://go-review.googlesource.com/c/go/+/368156
Trust: Jeremy Faller 
Run-TryBot: Jeremy Faller 
TryBot-Result: Gopher Robot 
Reviewed-by: Michael Knyszek 
---
 doc/go1.18.html | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 74d0e0c23e..285b44946e 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -200,6 +200,21 @@ proposal.
   into Win32 functions that block for extended periods of time.
 
    
 
+
    
+  The garbage collector now includes non-heap sources of garbage collector work
+  (e.g., stack scanning) when determining how frequently to run. As a result,
+  garbage collector overhead is more predictable when these sources are
+  significant. For most applications these changes will be negligible; however,
+  some Go applications may now use less memory and spend more time on garbage
+  collection, or vice versa, than before. The intended workaround is to tweak
+  GOGC where necessary.
+
    
+
+
    
+  The runtime now returns memory to the operating system more efficiently and has
+  been tuned to work more aggressively as a result.
+
    
+
 
    Compiler
    
 
 
    

From d3bf627bc1e1a4959ecff797754e4a636aa6be1c Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Wed, 1 Dec 2021 13:41:10 -0500
Subject: [PATCH 361/752] doc/go1.18: add constraints package documentation

Updates #47694

Change-Id: I3239023dad194c317e271e6093eff2cfbed1a4b9
Reviewed-on: https://go-review.googlesource.com/c/go/+/368314
Trust: Jeremy Faller 
Run-TryBot: Jeremy Faller 
TryBot-Result: Gopher Robot 
Reviewed-by: Ian Lance Taylor 
---
 doc/go1.18.html | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 285b44946e..6c246b8b7b 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -258,7 +258,9 @@ proposal.
 
    New constraints package
    
 
 
    
-  TODO: https://golang.org/cl/349709: constraints: new package
+  The new constraints package
+  defines a set of useful constraints that can be used with type parameters of
+  generic functions.
 
    
 
 
    New net/netip package
    

From 94e22fa03eb5eb678689e05b8e309cd23f874698 Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Wed, 1 Dec 2021 13:48:22 -0500
Subject: [PATCH 362/752] doc/go1.18: add Conn.NetConn documentation to
 crypto/tls section

Updates #47694

Change-Id: Iead44baa8b2a06ecf7b92d343ed9117f0fc0793e
Reviewed-on: https://go-review.googlesource.com/c/go/+/368315
Trust: Jeremy Faller 
Trust: Katie Hockman 
Run-TryBot: Jeremy Faller 
TryBot-Result: Gopher Robot 
Reviewed-by: Katie Hockman 
Reviewed-by: Ian Lance Taylor 
Reviewed-by: Agniva De Sarker 
---
 doc/go1.18.html | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 6c246b8b7b..31aa17209f 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -341,7 +341,9 @@ proposal.
 
    crypto/tls
    
   
    
     
    
-      TODO: https://golang.org/cl/325250: add Conn.NetConn method
+      The new Conn.NetConn
+      method allows access to the underlying
+      net.Conn.
     
    
   
    
 
    

From 25f06cb71f06406bd38de0a37967edc6ec8ca120 Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Wed, 1 Dec 2021 13:56:53 -0500
Subject: [PATCH 363/752] doc/go1.18: add deprecation note for
 net.Error.Temporary

Updates #47694

Change-Id: Ia25ad49f688efa3d60d83290095648711704b478
Reviewed-on: https://go-review.googlesource.com/c/go/+/368316
Trust: Jeremy Faller 
Run-TryBot: Jeremy Faller 
TryBot-Result: Gopher Robot 
Reviewed-by: Ian Lance Taylor 
---
 doc/go1.18.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 31aa17209f..fb4d03151e 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -377,7 +377,7 @@ proposal.
 
    net
    
   
    
     
    
-      TODO: https://golang.org/cl/340261: deprecate (net.Error).Temporary
+      net.Error.Temporary has been deprecated.
     
    
   
    
 
    

From c8c89d20ce206969ea48819af3ef0309299f9f6c Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Wed, 1 Dec 2021 16:27:55 -0500
Subject: [PATCH 364/752] doc/go1.18: add docs on Cookie.Valid

Updates #47694

Change-Id: Ibf3e25fbccf82e4abd7bd76b2ea6ceb4b05d4664
Reviewed-on: https://go-review.googlesource.com/c/go/+/368357
Trust: Jeremy Faller 
Run-TryBot: Jeremy Faller 
TryBot-Result: Gopher Robot 
Reviewed-by: Ian Lance Taylor 
---
 doc/go1.18.html | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index fb4d03151e..a142115c22 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -390,8 +390,11 @@ proposal.
       Transport
       will now be correctly used, if specified, for making HTTP requests.
     
    
+
     
    
-      TODO: https://golang.org/cl/338590: add Cookie.Valid method
+      The new
+      Cookie.Valid
+      method reports whether the cookie is valid.
     
    
   
    
 
    

From bcb98f126bc3a12a63333069b669cb8aaf251b89 Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Wed, 1 Dec 2021 16:33:33 -0500
Subject: [PATCH 365/752] doc/go1.18: add docs on User.GroupIds

Cobbled up some release notes from:

https://go-review.googlesource.com/c/go/+/330753/

Updates #47694

Change-Id: I249e4b96b7d51185b07c11a734505677e9e36315
Reviewed-on: https://go-review.googlesource.com/c/go/+/368358
Trust: Jeremy Faller 
Run-TryBot: Jeremy Faller 
Reviewed-by: Kirill Kolyshkin 
Reviewed-by: Ian Lance Taylor 
TryBot-Result: Gopher Robot 
---
 doc/go1.18.html | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index a142115c22..b02bac13ba 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -402,7 +402,8 @@ proposal.
 
    os/user
    
   
    
     
    
-      TODO: https://golang.org/cl/330753: implement go native GroupIds
+      User.GroupIds.
+      now uses a Go native implementation when cgo is not available.
     
    
   
    
 
    

From f9b2733e3a8b4911b932671b0bd9fc4190cf59aa Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Wed, 1 Dec 2021 16:43:47 -0500
Subject: [PATCH 366/752] doc/go1.18: add docs on MapIter.Reset

From:

https://go-review.googlesource.com/c/go/+/321891

Updates #47694

Change-Id: I2cdd5d9f3da62a5690cd2ef921ed48957c602d64
Reviewed-on: https://go-review.googlesource.com/c/go/+/368360
Trust: Jeremy Faller 
Run-TryBot: Jeremy Faller 
TryBot-Result: Gopher Robot 
Reviewed-by: Ian Lance Taylor 
---
 doc/go1.18.html | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index b02bac13ba..193ee16fb6 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -433,7 +433,13 @@ proposal.
     
    
 
     
    
-      TODO: https://golang.org/cl/321891: add MapIter.Reset
+      The new
+      MapIter.Reset
+      method changes its receiver to iterate over a
+      different map. The use of
+      MapIter.Reset
+      allows allocation-free iteration
+      over many maps.
     
    
 
     
    

From e533b5793f43ed44f1562a10d974cb3bc3688226 Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Wed, 1 Dec 2021 16:55:37 -0500
Subject: [PATCH 367/752] doc/go1.18: add docs on new reflect.Value methods

From:

https://go-review.googlesource.com/c/go/+/352131/

Updates #47694

Change-Id: I7c7811c49900049f5ef7fc906fe25d2ffd73c7b9
Reviewed-on: https://go-review.googlesource.com/c/go/+/368363
Trust: Jeremy Faller 
Run-TryBot: Jeremy Faller 
Reviewed-by: Keith Randall 
Reviewed-by: Fabio Falzoi 
Reviewed-by: Ian Lance Taylor 
TryBot-Result: Gopher Robot 
---
 doc/go1.18.html | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 193ee16fb6..5692a068ab 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -447,7 +447,15 @@ proposal.
     
    
 
     
    
-      TODO: https://golang.org/cl/352131: add Value.{CanInt, CanUint, CanFloat, CanComplex}
+      A number of methods (
+      Value.CanInt,
+      Value.CanUint,
+      Value.CanFloat,
+      Value.CanComplex
+      )
+      have been added to
+      Value
+      to test if a conversion is safe.
     
    
 
     
    

From 48e4284e551fceee7a45c11af791813782ca7e82 Mon Sep 17 00:00:00 2001
From: Jeremy Faller 
Date: Wed, 1 Dec 2021 17:03:15 -0500
Subject: [PATCH 368/752] doc/go1.18: add docs on FieldByIndexErr

From:
https://go-review.googlesource.com/c/go/+/357962/

Updates #47694

Change-Id: I2d43dcbd28c03457b55eada26e87f7710a113b0c
Reviewed-on: https://go-review.googlesource.com/c/go/+/368364
Trust: Jeremy Faller 
Run-TryBot: Jeremy Faller 
TryBot-Result: Gopher Robot 
Reviewed-by: Ian Lance Taylor 
---
 doc/go1.18.html | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 5692a068ab..8f0fc1fb71 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -459,7 +459,10 @@ proposal.
     
    
 
     
    
-      TODO: https://golang.org/cl/357962: add FieldByIndexErr
+      Value.FieldByIndexErr
+      has been added to avoid the panic that occurs in
+      Value.FieldByIndex
+      when stepping through a nil pointer to an embedded struct.
    From 06dbf6121ad77e9ea3288df99bfe4e94f8776f38 Mon Sep 17 00:00:00 2001 From: Jeremy Faller Date: Thu, 2 Dec 2021 13:18:33 -0500 Subject: [PATCH 369/752] doc/go1.18: remove some TODOs for changes we aren't mentioning Updates #47694 Change-Id: I8fdbded4aaf974425ee317a1cdd940a5ac88c0b3 Reviewed-on: https://go-review.googlesource.com/c/go/+/368794 Trust: Jeremy Faller Run-TryBot: Jeremy Faller TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 8 -------- 1 file changed, 8 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 8f0fc1fb71..8dc6a88ef3 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -428,10 +428,6 @@ proposal. to eliminate the need to perform uintptr to unsafe.Pointer conversions at the callsite (as unsafe.Pointer rules require).

    -

    - TODO: https://golang.org/cl/321889: allocate hiter as part of MapIter -

    -

    The new MapIter.Reset @@ -442,10 +438,6 @@ proposal. over many maps.

    -

    - TODO: https://golang.org/cl/345486: optimize for maps with string keys -

    -

    A number of methods ( Value.CanInt, From fd4b391849dcd3ac0e90d3a86b0ee7df00b9b269 Mon Sep 17 00:00:00 2001 From: Shang Jian Ding Date: Tue, 5 Oct 2021 19:52:20 -0500 Subject: [PATCH 370/752] crypto/x509: fix comments on certDirectories CL 205237 allowed SSL_CERT_DIR to be a colon delimited list of directories. In the case that SSL_CERT_DIR is unset, the change also made certDirectories to all be loaded rather than stopping after successfully reading at least one file from a directory. This update fixes code comments on the certDirectories package level variables to reflect current behavior. Fixes #48808 Change-Id: Id92f875545272fc6205d9955d03ea7bf844f15eb Reviewed-on: https://go-review.googlesource.com/c/go/+/354140 Reviewed-by: Emmanuel Odeke Reviewed-by: Katie Hockman Run-TryBot: Emmanuel Odeke TryBot-Result: Gopher Robot Trust: Katie Hockman --- src/crypto/x509/root_aix.go | 3 +-- src/crypto/x509/root_bsd.go | 3 +-- src/crypto/x509/root_js.go | 3 +-- src/crypto/x509/root_linux.go | 3 +-- src/crypto/x509/root_solaris.go | 3 +-- 5 files changed, 5 insertions(+), 10 deletions(-) diff --git a/src/crypto/x509/root_aix.go b/src/crypto/x509/root_aix.go index 4d50a13473..99b7463a2a 100644 --- a/src/crypto/x509/root_aix.go +++ b/src/crypto/x509/root_aix.go @@ -9,8 +9,7 @@ var certFiles = []string{ "/var/ssl/certs/ca-bundle.crt", } -// Possible directories with certificate files; stop after successfully -// reading at least one file from a directory. +// Possible directories with certificate files; all will be read. var certDirectories = []string{ "/var/ssl/certs", } diff --git a/src/crypto/x509/root_bsd.go b/src/crypto/x509/root_bsd.go index 8ac205faa9..a76aef8659 100644 --- a/src/crypto/x509/root_bsd.go +++ b/src/crypto/x509/root_bsd.go @@ -14,8 +14,7 @@ var certFiles = []string{ "/etc/openssl/certs/ca-certificates.crt", // NetBSD } -// Possible directories with certificate files; stop after successfully -// reading at least one file from a directory. +// Possible directories with certificate files; all will be read. var certDirectories = []string{ "/etc/ssl/certs", // FreeBSD 12.2+ "/usr/local/share/certs", // FreeBSD diff --git a/src/crypto/x509/root_js.go b/src/crypto/x509/root_js.go index 9593038517..7b3f1e486f 100644 --- a/src/crypto/x509/root_js.go +++ b/src/crypto/x509/root_js.go @@ -9,6 +9,5 @@ package x509 // Possible certificate files; stop after finding one. var certFiles = []string{} -// Possible directories with certificate files; stop after successfully -// reading at least one file from a directory. +// Possible directories with certificate files; all will be read. var certDirectories = []string{} diff --git a/src/crypto/x509/root_linux.go b/src/crypto/x509/root_linux.go index ad6ce5cae7..e32989b999 100644 --- a/src/crypto/x509/root_linux.go +++ b/src/crypto/x509/root_linux.go @@ -14,8 +14,7 @@ var certFiles = []string{ "/etc/ssl/cert.pem", // Alpine Linux } -// Possible directories with certificate files; stop after successfully -// reading at least one file from a directory. +// Possible directories with certificate files; all will be read. var certDirectories = []string{ "/etc/ssl/certs", // SLES10/SLES11, https://golang.org/issue/12139 "/etc/pki/tls/certs", // Fedora/RHEL diff --git a/src/crypto/x509/root_solaris.go b/src/crypto/x509/root_solaris.go index 97c19139e3..617f26961f 100644 --- a/src/crypto/x509/root_solaris.go +++ b/src/crypto/x509/root_solaris.go @@ -11,8 +11,7 @@ var certFiles = []string{ "/etc/ssl/cacert.pem", // OmniOS } -// Possible directories with certificate files; stop after successfully -// reading at least one file from a directory. +// Possible directories with certificate files; all will be read. var certDirectories = []string{ "/etc/certs/CA", } From 8835343280029eaf86e0612d600ae7af5c68b092 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Thu, 2 Dec 2021 11:39:38 -0800 Subject: [PATCH 371/752] doc/go1.18: mention new -asan option For #44853 For #47694 Change-Id: Ia76246218b1361d8bdf510bbfc5178c83cdd3eec Reviewed-on: https://go-review.googlesource.com/c/go/+/368834 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Jeremy Faller Reviewed-by: Cherry Mui --- doc/go1.18.html | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 8dc6a88ef3..2ea8e08423 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -183,6 +183,13 @@ proposal. third-party tools that need to collect package source code.)

    +

    + The go build command and related commands + now support an -asan flag that enables interoperation + with C (or C++) code compiled with the address sanitizer (C compiler + option -fsanitize=address). +

    +

    gofmt

    @@ -244,13 +251,15 @@ proposal.

    - TODO: https://golang.org/cl/298611: cmd/compile: add -asan option + The new compiler -asan option supports the + new go command -asan option.

    Linker

    - TODO: https://golang.org/cl/298610: cmd/link: add -asan option + The new linker -asan option supports the + new go command -asan option.

    Core library

    From 5f6552018d1ec920c3ca3d459691528f48363c3c Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Tue, 30 Nov 2021 18:58:53 -0500 Subject: [PATCH 372/752] runtime/race: rebuild darwin syso to work around macOS 12 malloc reserved address On macOS 12 a new malloc implementation (nano) is used by default, and apparently it reserves address range 0x600000000000-0x600020000000, which conflicts with the address range that TSAN uses for Go. Work around the issue by changing the address range slightly. The actual change is made on LLVM at https://reviews.llvm.org/D114825 . This CL includes syso's built with the patch applied. Fixes #49138. Change-Id: I7b367d6e042b0db39a691c71601c98e4f8728a70 Reviewed-on: https://go-review.googlesource.com/c/go/+/367916 Trust: Cherry Mui Reviewed-by: Austin Clements --- src/runtime/race/README | 4 ++-- src/runtime/race/race_darwin_amd64.syso | Bin 451280 -> 455944 bytes src/runtime/race/race_darwin_arm64.syso | Bin 438936 -> 438560 bytes 3 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/runtime/race/README b/src/runtime/race/README index 3b188a0361..d3c55182ef 100644 --- a/src/runtime/race/README +++ b/src/runtime/race/README @@ -4,12 +4,12 @@ the LLVM project (https://github.com/llvm/llvm-project/tree/main/compiler-rt). To update the .syso files use golang.org/x/build/cmd/racebuild. -race_darwin_amd64.syso built with LLVM 89f7ccea6f6488c443655880229c54db1f180153 and Go f62d3202bf9dbb3a00ad2a2c63ff4fa4188c5d3b. +race_darwin_amd64.syso built with LLVM 89f7ccea6f6488c443655880229c54db1f180153 with https://reviews.llvm.org/D114825 applied and Go 7ccbcc90560468937f02609a43cb39a6e13ff797. race_freebsd_amd64.syso built with LLVM 89f7ccea6f6488c443655880229c54db1f180153 and Go f62d3202bf9dbb3a00ad2a2c63ff4fa4188c5d3b. race_linux_amd64.syso built with LLVM 89f7ccea6f6488c443655880229c54db1f180153 and Go f62d3202bf9dbb3a00ad2a2c63ff4fa4188c5d3b. race_linux_ppc64le.syso built with LLVM 89f7ccea6f6488c443655880229c54db1f180153 and Go f62d3202bf9dbb3a00ad2a2c63ff4fa4188c5d3b. race_netbsd_amd64.syso built with LLVM 89f7ccea6f6488c443655880229c54db1f180153 and Go f62d3202bf9dbb3a00ad2a2c63ff4fa4188c5d3b. race_windows_amd64.syso built with LLVM 89f7ccea6f6488c443655880229c54db1f180153 and Go f62d3202bf9dbb3a00ad2a2c63ff4fa4188c5d3b. race_linux_arm64.syso built with LLVM 89f7ccea6f6488c443655880229c54db1f180153 and Go f62d3202bf9dbb3a00ad2a2c63ff4fa4188c5d3b. -race_darwin_arm64.syso built with LLVM 00da38ce2d36c07f12c287dc515d37bb7bc410e9 and Go fe70a3a0fd31441bcbb9932ecab11a6083cf2119. +race_darwin_arm64.syso built with LLVM 00da38ce2d36c07f12c287dc515d37bb7bc410e9 with https://reviews.llvm.org/D114825 applied and Go 7ccbcc90560468937f02609a43cb39a6e13ff797. race_openbsd_amd64.syso built with LLVM fcf6ae2f070eba73074b6ec8d8281e54d29dbeeb and Go 8f2db14cd35bbd674cb2988a508306de6655e425. diff --git a/src/runtime/race/race_darwin_amd64.syso b/src/runtime/race/race_darwin_amd64.syso index 3f95ecc8eef955f005a017f3820ae1f3556f9826..6fbe140026f0a8391d3dfb4581d37a16dacbd375 100644 GIT binary patch literal 455944 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

    Sap{MQ6vAN-~P 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 z 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

    R=vuE?Zht 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

    cq^TAZ$02hJg94BT)&Vcr2&zC0*aCKdTJSii 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 z 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 z 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�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 a5FODH4N)pA0{o=lKy*Y)G(>dgU;ZCpS;n0J From 8da66a35cab2de4f7ce0215c47929be624eeb03d Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Thu, 2 Dec 2021 19:05:27 -0500 Subject: [PATCH 373/752] cmd/compile: set PPC64's MAXWIDTH as other architectures PPC64's MAXWIDTH is set as 1<<60 whereas on other 64-bit architetures it is set as 1<<50. Set to 1<<50 for consistency. The toolchain cannot handle such large program anyway. May fix PPC64 build. Change-Id: Ic3972a089b2f14a96e4ded57ef218d763c924a6a Reviewed-on: https://go-review.googlesource.com/c/go/+/368955 Trust: Cherry Mui Trust: Dan Scales Run-TryBot: Cherry Mui TryBot-Result: Gopher Robot Reviewed-by: Dan Scales --- src/cmd/compile/internal/ppc64/galign.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cmd/compile/internal/ppc64/galign.go b/src/cmd/compile/internal/ppc64/galign.go index 6f9d1407d6..20fd8cec54 100644 --- a/src/cmd/compile/internal/ppc64/galign.go +++ b/src/cmd/compile/internal/ppc64/galign.go @@ -16,7 +16,7 @@ func Init(arch *ssagen.ArchInfo) { arch.LinkArch = &ppc64.Linkppc64le } arch.REGSP = ppc64.REGSP - arch.MAXWIDTH = 1 << 60 + arch.MAXWIDTH = 1 << 50 arch.ZeroRange = zerorange arch.Ginsnop = ginsnop From 098599003ba78225152d22984f82f78892221dad Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Thu, 2 Dec 2021 14:52:31 -0800 Subject: [PATCH 374/752] builtin: document "any" and "comparable" Fixes #49927 Change-Id: I8b34cf13b3bc6338309f005648ca3ee6852927f0 Reviewed-on: https://go-review.googlesource.com/c/go/+/368954 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/builtin/builtin.go | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/builtin/builtin.go b/src/builtin/builtin.go index 01190e9900..9a94c7357d 100644 --- a/src/builtin/builtin.go +++ b/src/builtin/builtin.go @@ -91,6 +91,16 @@ type byte = uint8 // used, by convention, to distinguish character values from integer values. type rune = int32 +// any is an alias for interface{} and is equivalent to interface{} in all ways. +type any = interface{} + +// comparable is an interface that is implemented by all comparable types +// (booleans, numbers, strings, pointers, channels, interfaces, +// arrays of comparable types, structs whose fields are all comparable types). +// The comparable interface may only be used as a type parameter constraint, +// not as the type of a variable. +type comparable comparable + // iota is a predeclared identifier representing the untyped integer ordinal // number of the current const specification in a (usually parenthesized) // const declaration. It is zero-indexed. From a174638a5cc88eb4fccaaa699990f5626fbb0e30 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Tue, 30 Nov 2021 16:33:51 -0500 Subject: [PATCH 375/752] os: test that LookupEnv reports all keys found in Environ For #49886 Change-Id: Ie3a7f12a0d30ec719caf375e7be30cc4a5796c3f Reviewed-on: https://go-review.googlesource.com/c/go/+/367850 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Ian Lance Taylor TryBot-Result: Gopher Robot --- src/os/env_test.go | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/src/os/env_test.go b/src/os/env_test.go index 4b860157b4..11b3b89725 100644 --- a/src/os/env_test.go +++ b/src/os/env_test.go @@ -166,3 +166,39 @@ func TestLookupEnv(t *testing.T) { t.Errorf("smallpox release failed; world remains safe but LookupEnv is broken") } } + +// On Windows, Environ was observed to report keys with a single leading "=". +// Check that they are properly reported by LookupEnv and can be set by SetEnv. +// See https://golang.org/issue/49886. +func TestEnvironConsistency(t *testing.T) { + for _, kv := range Environ() { + i := strings.Index(kv, "=") + if i == 0 { + // We observe in practice keys with a single leading "=" on Windows. + // TODO(#49886): Should we consume only the first leading "=" as part + // of the key, or parse through arbitrarily many of them until a non-=, + // or try each possible key/value boundary until LookupEnv succeeds? + i = strings.Index(kv[1:], "=") + 1 + } + if i < 0 { + t.Errorf("Environ entry missing '=': %q", kv) + } + + k := kv[:i] + v := kv[i+1:] + v2, ok := LookupEnv(k) + if ok && v == v2 { + t.Logf("LookupEnv(%q) = %q, %t", k, v2, ok) + } else { + t.Errorf("Environ contains %q, but LookupEnv(%q) = %q, %t", kv, k, v2, ok) + } + + // Since k=v is already present in the environment, + // setting it should be a no-op. + if err := Setenv(k, v); err == nil { + t.Logf("Setenv(%q, %q)", k, v) + } else { + t.Errorf("Environ contains %q, but SetEnv(%q, %q) = %q", kv, k, v, err) + } + } +} From 9b0de0854d5a5655890ef0b2b9052da2541182a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Felix=20Geisend=C3=B6rfer?= Date: Mon, 20 Sep 2021 16:09:47 +0200 Subject: [PATCH 376/752] runtime: fix missing pprof labels Use gp.m.curg instead of the gp when recording cpu profiler stack traces. This ensures profiler labels are captured when systemstack or similar is executing on behalf of the current goroutine. After this there are still rare cases of samples containing the labelHog function, so more work might be needed. This patch should fix ~99% of the problem. Also change testCPUProfile interface a little to allow the new test to re-run with a longer duration if it fails during a -short run. Fixes #48577. Change-Id: I3dbc9fd5af3c513544e822acaa43055b2e00dfa9 Reviewed-on: https://go-review.googlesource.com/c/go/+/367200 Trust: Michael Pratt Trust: Bryan Mills Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot Reviewed-by: Michael Pratt --- src/runtime/cpuprof.go | 11 +- src/runtime/pprof/pprof_test.go | 229 +++++++++++++++++++++++--------- src/runtime/proc.go | 9 +- 3 files changed, 178 insertions(+), 71 deletions(-) diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go index c81ab710c2..6076564716 100644 --- a/src/runtime/cpuprof.go +++ b/src/runtime/cpuprof.go @@ -89,7 +89,7 @@ func SetCPUProfileRate(hz int) { // held at the time of the signal, nor can it use substantial amounts // of stack. //go:nowritebarrierrec -func (p *cpuProfile) add(gp *g, stk []uintptr) { +func (p *cpuProfile) add(tagPtr *unsafe.Pointer, stk []uintptr) { // Simple cas-lock to coordinate with setcpuprofilerate. for !atomic.Cas(&prof.signalLock, 0, 1) { osyield() @@ -104,15 +104,6 @@ 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. - // - // 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) } diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index d9be00d030..e32928b347 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -93,14 +93,16 @@ func avoidFunctions() []string { } func TestCPUProfile(t *testing.T) { - testCPUProfile(t, stackContains, []string{"runtime/pprof.cpuHog1"}, avoidFunctions(), func(dur time.Duration) { + matches := matchAndAvoidStacks(stackContains, []string{"runtime/pprof.cpuHog1"}, avoidFunctions()) + testCPUProfile(t, matches, func(dur time.Duration) { cpuHogger(cpuHog1, &salt1, dur) }) } func TestCPUProfileMultithreaded(t *testing.T) { defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2)) - testCPUProfile(t, stackContains, []string{"runtime/pprof.cpuHog1", "runtime/pprof.cpuHog2"}, avoidFunctions(), func(dur time.Duration) { + matches := matchAndAvoidStacks(stackContains, []string{"runtime/pprof.cpuHog1", "runtime/pprof.cpuHog2"}, avoidFunctions()) + testCPUProfile(t, matches, func(dur time.Duration) { c := make(chan int) go func() { cpuHogger(cpuHog1, &salt1, dur) @@ -167,7 +169,8 @@ func TestCPUProfileMultithreadMagnitude(t *testing.T) { runtime.GC() var cpuTime1, cpuTimeN time.Duration - p := testCPUProfile(t, stackContains, []string{"runtime/pprof.cpuHog1", "runtime/pprof.cpuHog3"}, avoidFunctions(), func(dur time.Duration) { + matches := matchAndAvoidStacks(stackContains, []string{"runtime/pprof.cpuHog1", "runtime/pprof.cpuHog3"}, avoidFunctions()) + p := testCPUProfile(t, matches, func(dur time.Duration) { cpuTime1 = diffCPUTime(t, func() { // Consume CPU in one goroutine cpuHogger(cpuHog1, &salt1, dur) @@ -272,7 +275,8 @@ func TestCPUProfileInlining(t *testing.T) { t.Skip("Can't determine whether inlinedCallee was inlined into inlinedCaller.") } - p := testCPUProfile(t, stackContains, []string{"runtime/pprof.inlinedCallee", "runtime/pprof.inlinedCaller"}, avoidFunctions(), func(dur time.Duration) { + matches := matchAndAvoidStacks(stackContains, []string{"runtime/pprof.inlinedCallee", "runtime/pprof.inlinedCaller"}, avoidFunctions()) + p := testCPUProfile(t, matches, func(dur time.Duration) { cpuHogger(inlinedCaller, &salt1, dur) }) @@ -322,7 +326,8 @@ func inlinedCalleeDump(pcs []uintptr) { } func TestCPUProfileRecursion(t *testing.T) { - p := testCPUProfile(t, stackContains, []string{"runtime/pprof.inlinedCallee", "runtime/pprof.recursionCallee", "runtime/pprof.recursionCaller"}, avoidFunctions(), func(dur time.Duration) { + matches := matchAndAvoidStacks(stackContains, []string{"runtime/pprof.inlinedCallee", "runtime/pprof.recursionCallee", "runtime/pprof.recursionCaller"}, avoidFunctions()) + p := testCPUProfile(t, matches, func(dur time.Duration) { cpuHogger(recursionCaller, &salt1, dur) }) @@ -407,7 +412,7 @@ func cpuProfilingBroken() bool { // testCPUProfile runs f under the CPU profiler, checking for some conditions specified by need, // as interpreted by matches, and returns the parsed profile. -func testCPUProfile(t *testing.T, matches matchFunc, need []string, avoid []string, f func(dur time.Duration)) *profile.Profile { +func testCPUProfile(t *testing.T, matches profileMatchFunc, f func(dur time.Duration)) *profile.Profile { switch runtime.GOOS { case "darwin": out, err := exec.Command("uname", "-a").CombinedOutput() @@ -448,7 +453,7 @@ func testCPUProfile(t *testing.T, matches matchFunc, need []string, avoid []stri f(duration) StopCPUProfile() - if p, ok := profileOk(t, matches, need, avoid, prof, duration); ok { + if p, ok := profileOk(t, matches, prof, duration); ok { return p } @@ -504,15 +509,11 @@ func stackContains(spec string, count uintptr, stk []*profile.Location, labels m return false } -type matchFunc func(spec string, count uintptr, stk []*profile.Location, labels map[string][]string) bool +type sampleMatchFunc func(spec string, count uintptr, stk []*profile.Location, labels map[string][]string) bool -func profileOk(t *testing.T, matches matchFunc, need []string, avoid []string, prof bytes.Buffer, duration time.Duration) (_ *profile.Profile, ok bool) { +func profileOk(t *testing.T, matches profileMatchFunc, prof bytes.Buffer, duration time.Duration) (_ *profile.Profile, ok bool) { ok = true - // Check that profile is well formed, contains 'need', and does not contain - // anything from 'avoid'. - have := make([]uintptr, len(need)) - avoidSamples := make([]uintptr, len(avoid)) var samples uintptr var buf bytes.Buffer p := parseProfile(t, prof.Bytes(), func(count uintptr, stk []*profile.Location, labels map[string][]string) { @@ -520,20 +521,6 @@ func profileOk(t *testing.T, matches matchFunc, need []string, avoid []string, p fprintStack(&buf, stk) fmt.Fprintf(&buf, " labels: %v\n", labels) samples += count - for i, spec := range need { - if matches(spec, count, stk, labels) { - have[i] += count - } - } - for i, name := range avoid { - for _, loc := range stk { - for _, line := range loc.Line { - if strings.Contains(line.Function.Name, name) { - avoidSamples[i] += count - } - } - } - } fmt.Fprintf(&buf, "\n") }) t.Logf("total %d CPU profile samples collected:\n%s", samples, buf.String()) @@ -556,39 +543,77 @@ func profileOk(t *testing.T, matches matchFunc, need []string, avoid []string, p ok = false } - for i, name := range avoid { - bad := avoidSamples[i] - if bad != 0 { - t.Logf("found %d samples in avoid-function %s\n", bad, name) - ok = false - } - } - - if len(need) == 0 { - return p, ok - } - - var total uintptr - for i, name := range need { - total += have[i] - t.Logf("%s: %d\n", name, have[i]) - } - if total == 0 { - t.Logf("no samples in expected functions") + if matches != nil && !matches(t, p) { ok = false } - // We'd like to check a reasonable minimum, like - // total / len(have) / smallconstant, but this test is - // pretty flaky (see bug 7095). So we'll just test to - // make sure we got at least one sample. - min := uintptr(1) - for i, name := range need { - if have[i] < min { - t.Logf("%s has %d samples out of %d, want at least %d, ideally %d", name, have[i], total, min, total/uintptr(len(have))) + + return p, ok +} + +type profileMatchFunc func(*testing.T, *profile.Profile) bool + +func matchAndAvoidStacks(matches sampleMatchFunc, need []string, avoid []string) profileMatchFunc { + return func(t *testing.T, p *profile.Profile) (ok bool) { + ok = true + + // Check that profile is well formed, contains 'need', and does not contain + // anything from 'avoid'. + have := make([]uintptr, len(need)) + avoidSamples := make([]uintptr, len(avoid)) + + for _, sample := range p.Sample { + count := uintptr(sample.Value[0]) + for i, spec := range need { + if matches(spec, count, sample.Location, sample.Label) { + have[i] += count + } + } + for i, name := range avoid { + for _, loc := range sample.Location { + for _, line := range loc.Line { + if strings.Contains(line.Function.Name, name) { + avoidSamples[i] += count + } + } + } + } + } + + for i, name := range avoid { + bad := avoidSamples[i] + if bad != 0 { + t.Logf("found %d samples in avoid-function %s\n", bad, name) + ok = false + } + } + + if len(need) == 0 { + return + } + + var total uintptr + for i, name := range need { + total += have[i] + t.Logf("%s: %d\n", name, have[i]) + } + if total == 0 { + t.Logf("no samples in expected functions") ok = false } + + // We'd like to check a reasonable minimum, like + // total / len(have) / smallconstant, but this test is + // pretty flaky (see bug 7095). So we'll just test to + // make sure we got at least one sample. + min := uintptr(1) + for i, name := range need { + if have[i] < min { + t.Logf("%s has %d samples out of %d, want at least %d, ideally %d", name, have[i], total, min, total/uintptr(len(have))) + ok = false + } + } + return } - return p, ok } // Fork can hang if preempted with signals frequently enough (see issue 5517). @@ -704,7 +729,7 @@ func fprintStack(w io.Writer, stk []*profile.Location) { // Test that profiling of division operations is okay, especially on ARM. See issue 6681. func TestMathBigDivide(t *testing.T) { - testCPUProfile(t, nil, nil, nil, func(duration time.Duration) { + testCPUProfile(t, nil, func(duration time.Duration) { t := time.After(duration) pi := new(big.Int) for { @@ -733,7 +758,8 @@ func stackContainsAll(spec string, count uintptr, stk []*profile.Location, label } func TestMorestack(t *testing.T) { - testCPUProfile(t, stackContainsAll, []string{"runtime.newstack,runtime/pprof.growstack"}, avoidFunctions(), func(duration time.Duration) { + matches := matchAndAvoidStacks(stackContainsAll, []string{"runtime.newstack,runtime/pprof.growstack"}, avoidFunctions()) + testCPUProfile(t, matches, func(duration time.Duration) { t := time.After(duration) c := make(chan bool) for { @@ -1364,7 +1390,8 @@ func stackContainsLabeled(spec string, count uintptr, stk []*profile.Location, l } func TestCPUProfileLabel(t *testing.T) { - testCPUProfile(t, stackContainsLabeled, []string{"runtime/pprof.cpuHogger;key=value"}, avoidFunctions(), func(dur time.Duration) { + matches := matchAndAvoidStacks(stackContainsLabeled, []string{"runtime/pprof.cpuHogger;key=value"}, avoidFunctions()) + testCPUProfile(t, matches, func(dur time.Duration) { Do(context.Background(), Labels("key", "value"), func(context.Context) { cpuHogger(cpuHog1, &salt1, dur) }) @@ -1375,7 +1402,8 @@ func TestLabelRace(t *testing.T) { // Test the race detector annotations for synchronization // between settings labels and consuming them from the // profile. - testCPUProfile(t, stackContainsLabeled, []string{"runtime/pprof.cpuHogger;key=value"}, nil, func(dur time.Duration) { + matches := matchAndAvoidStacks(stackContainsLabeled, []string{"runtime/pprof.cpuHogger;key=value"}, nil) + testCPUProfile(t, matches, func(dur time.Duration) { start := time.Now() var wg sync.WaitGroup for time.Since(start) < dur { @@ -1394,6 +1422,86 @@ func TestLabelRace(t *testing.T) { }) } +// TestLabelSystemstack makes sure CPU profiler samples of goroutines running +// on systemstack include the correct pprof labels. See issue #48577 +func TestLabelSystemstack(t *testing.T) { + matchBasics := matchAndAvoidStacks(stackContainsLabeled, []string{"runtime.systemstack;key=value"}, avoidFunctions()) + matches := func(t *testing.T, prof *profile.Profile) bool { + if !matchBasics(t, prof) { + return false + } + + var withLabel, withoutLabel int64 + for _, s := range prof.Sample { + var systemstack, labelHog bool + for _, loc := range s.Location { + for _, l := range loc.Line { + switch l.Function.Name { + case "runtime.systemstack": + systemstack = true + case "runtime/pprof.labelHog": + labelHog = true + } + } + } + + if systemstack && labelHog { + if s.Label != nil && contains(s.Label["key"], "value") { + withLabel += s.Value[0] + } else { + withoutLabel += s.Value[0] + } + } + } + + // ratio on 2019 Intel MBP before/after CL 351751 for n=30 runs: + // before: mean=0.013 stddev=0.013 min=0.000 max=0.039 + // after : mean=0.996 stddev=0.007 min=0.967 max=1.000 + // + // TODO: Figure out why some samples (containing gcWriteBarrier, gcStart) + // still have labelHog without labels. Once fixed this test case can be + // simplified to just check that all samples containing labelHog() have the + // label, and no other samples do. + ratio := float64(withLabel) / float64((withLabel + withoutLabel)) + if ratio < 0.9 { + t.Logf("only %.1f%% of labelHog(systemstack()) samples have label", ratio*100) + return false + } + return true + } + + testCPUProfile(t, matches, func(dur time.Duration) { + Do(context.Background(), Labels("key", "value"), func(context.Context) { + var wg sync.WaitGroup + stop := make(chan struct{}) + for i := 0; i < runtime.GOMAXPROCS(0); i++ { + wg.Add(1) + go func() { + defer wg.Done() + labelHog(stop) + }() + } + + time.Sleep(dur) + close(stop) + wg.Wait() + }) + }) +} + +// labelHog is designed to burn CPU time in a way that a high number of CPU +// samples end up running on systemstack. +func labelHog(stop chan struct{}) { + for i := 0; ; i++ { + select { + case <-stop: + return + default: + fmt.Fprintf(io.Discard, "%d", i) + } + } +} + // Check that there is no deadlock when the program receives SIGPROF while in // 64bit atomics' critical section. Used to happen on mips{,le}. See #20146. func TestAtomicLoadStore64(t *testing.T) { @@ -1686,7 +1794,8 @@ func TestTimeVDSO(t *testing.T) { testenv.SkipFlaky(t, 48655) } - p := testCPUProfile(t, stackContains, []string{"time.now"}, avoidFunctions(), func(dur time.Duration) { + matches := matchAndAvoidStacks(stackContains, []string{"time.now"}, avoidFunctions()) + p := testCPUProfile(t, matches, func(dur time.Duration) { t0 := time.Now() for { t := time.Now() diff --git a/src/runtime/proc.go b/src/runtime/proc.go index f375b67981..7509f7632f 100644 --- a/src/runtime/proc.go +++ b/src/runtime/proc.go @@ -4726,7 +4726,14 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) { } if prof.hz != 0 { - cpuprof.add(gp, stk[:n]) + // Note: it can happen on Windows that we interrupted a system thread + // with no g, so gp could nil. The other nil checks are done out of + // caution, but not expected to be nil in practice. + var tagPtr *unsafe.Pointer + if gp != nil && gp.m != nil && gp.m.curg != nil { + tagPtr = &gp.m.curg.labels + } + cpuprof.add(tagPtr, stk[:n]) } getg().m.mallocing-- } From 29483b3dae9bc043887b5372aefe0e53194b9ce7 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Sat, 27 Nov 2021 10:33:59 -0800 Subject: [PATCH 377/752] test: re-enable a bunch of tests with types2 Enable a bunch of types2-related error tests to run successfully, so they no longer have to be disabled in run.go. - directive.go: split it into directive.go and directive2.go, since the possible errors are now split across the parser and noder2, so they can't all be reported in one file. - linkname2.go: similarly, split it into linkname2.go and linkname3.go for the same reason. - issue16428.go, issue17645.go, issue47201.dir/bo.go: handle slightly different wording by types2 - issue5609.go: handle slight different error (array length must be integer vs. array bound too large). - float_lit3.go: handle slightly different wording (overflows float vs cannot convert to float) I purposely didn't try to fix tests yet where there are extra or missing errors on different lines, since that is not easy to make work for both -G=3 and -G=0. In a later change, will flip to make the types2 version match correctly, vs. the -G=0 version. Change-Id: I6079ff258e3b90146335b9995764e3b1b56cda59 Reviewed-on: https://go-review.googlesource.com/c/go/+/368455 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: Matthew Dempsky --- .../compile/internal/types2/stdlib_test.go | 2 + src/go/types/stdlib_test.go | 2 + test/directive.go | 37 +---------- test/directive2.go | 63 ++++++++++++++++++ test/fixedbugs/issue16428.go | 2 +- test/fixedbugs/issue17645.go | 2 +- test/fixedbugs/issue47201.dir/b.go | 2 +- test/fixedbugs/issue5609.go | 2 +- test/float_lit3.go | 8 +-- test/linkname2.go | 6 -- test/linkname3.go | 25 +++++++ test/run.go | 18 ++--- test/shift1.go | 66 +++++++++---------- 13 files changed, 142 insertions(+), 93 deletions(-) create mode 100644 test/directive2.go create mode 100644 test/linkname3.go diff --git a/src/cmd/compile/internal/types2/stdlib_test.go b/src/cmd/compile/internal/types2/stdlib_test.go index 5ac01ac253..551611da55 100644 --- a/src/cmd/compile/internal/types2/stdlib_test.go +++ b/src/cmd/compile/internal/types2/stdlib_test.go @@ -165,9 +165,11 @@ 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 + "directive2.go", // tests compiler rejection of bad directive placement - ignore "embedfunc.go", // tests //go:embed "embedvers.go", // tests //go:embed "linkname2.go", // types2 doesn't check validity of //go:xxx directives + "linkname3.go", // types2 doesn't check validity of //go:xxx directives ) } diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go index c56e0ba428..687b80540a 100644 --- a/src/go/types/stdlib_test.go +++ b/src/go/types/stdlib_test.go @@ -166,9 +166,11 @@ 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 + "directive2.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 + "linkname3.go", // go/types doesn't check validity of //go:xxx directives ) } diff --git a/test/directive.go b/test/directive.go index 37781c30d5..147e81db2c 100644 --- a/test/directive.go +++ b/test/directive.go @@ -6,16 +6,11 @@ // Verify that misplaced directives are diagnosed. -// ok -//go:build !ignore - //go:noinline // ERROR "misplaced compiler directive" //go:noinline // ERROR "misplaced compiler directive" package main -//go:build bad // ERROR "misplaced compiler directive" - //go:nosplit func f1() {} @@ -38,11 +33,10 @@ type T int //go:notinheap type T1 int -//go:notinheap // ERROR "misplaced compiler directive" type ( //go:notinheap //go:noinline // ERROR "misplaced compiler directive" - T2 int //go:notinheap // ERROR "misplaced compiler directive" + T2 int T2b int //go:notinheap T2c int @@ -50,40 +44,20 @@ type ( T3 int ) -//go:notinheap // ERROR "misplaced compiler directive" -type ( - //go:notinheap - T4 int -) - -//go:notinheap // ERROR "misplaced compiler directive" -type () - -type T5 int - -func g() {} //go:noinline // ERROR "misplaced compiler directive" - -// ok: attached to f (duplicated yes, but ok) -//go:noinline - //go:noinline func f() { - //go:noinline // ERROR "misplaced compiler directive" x := 1 - //go:noinline // ERROR "misplaced compiler directive" { - _ = x //go:noinline // ERROR "misplaced compiler directive" + _ = x } //go:noinline // ERROR "misplaced compiler directive" - var y int //go:noinline // ERROR "misplaced compiler directive" - //go:noinline // ERROR "misplaced compiler directive" + var y int _ = y //go:noinline // ERROR "misplaced compiler directive" const c = 1 - //go:noinline // ERROR "misplaced compiler directive" _ = func() {} //go:noinline // ERROR "misplaced compiler directive" @@ -95,8 +69,3 @@ func f() { // someday there might be a directive that can apply to type aliases, but go:notinheap doesn't. //go:notinheap // ERROR "misplaced compiler directive" type T6 = int - -// EOF -//go:noinline // ERROR "misplaced compiler directive" - -//go:build bad // ERROR "misplaced compiler directive" diff --git a/test/directive2.go b/test/directive2.go new file mode 100644 index 0000000000..e73e11235d --- /dev/null +++ b/test/directive2.go @@ -0,0 +1,63 @@ +// 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. + +// Verify that misplaced directives are diagnosed. + +// ok +//go:build !ignore + +package main + +//go:build bad // ERROR "misplaced compiler directive" + +//go:notinheap // ERROR "misplaced compiler directive" +type ( + T2 int //go:notinheap // ERROR "misplaced compiler directive" + T2b int + T2c int + T3 int +) + +//go:notinheap // ERROR "misplaced compiler directive" +type ( + //go:notinheap + T4 int +) + +//go:notinheap // ERROR "misplaced compiler directive" +type () + +type T5 int + +func g() {} //go:noinline // ERROR "misplaced compiler directive" + +// ok: attached to f (duplicated yes, but ok) +//go:noinline + +//go:noinline +func f() { + //go:noinline // ERROR "misplaced compiler directive" + x := 1 + + //go:noinline // ERROR "misplaced compiler directive" + { + _ = x //go:noinline // ERROR "misplaced compiler directive" + } + var y int //go:noinline // ERROR "misplaced compiler directive" + //go:noinline // ERROR "misplaced compiler directive" + _ = y + + const c = 1 + + _ = func() {} + + // ok: + //go:notinheap + type T int +} + +// EOF +//go:noinline // ERROR "misplaced compiler directive" diff --git a/test/fixedbugs/issue16428.go b/test/fixedbugs/issue16428.go index 5696d186c7..91e1079959 100644 --- a/test/fixedbugs/issue16428.go +++ b/test/fixedbugs/issue16428.go @@ -7,6 +7,6 @@ package p var ( - b = [...]byte("abc") // ERROR "outside of array literal" + b = [...]byte("abc") // ERROR "outside of array literal|outside a composite literal" s = len(b) ) diff --git a/test/fixedbugs/issue17645.go b/test/fixedbugs/issue17645.go index bb34e4ee97..111fa81e13 100644 --- 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|incompatible type" "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 .. \(.*untyped string.*\) as .*int.*|incompatible type" "cannot use Foo{.*} \(.*type Foo\) as type int in .*append" "cannot use append\(s\, Foo{.*}\) \(.*type \[\]int\) as type string in (assignment|variable declaration)" } diff --git a/test/fixedbugs/issue47201.dir/b.go b/test/fixedbugs/issue47201.dir/b.go index 5fd0635af2..ae3ff3f2b8 100644 --- a/test/fixedbugs/issue47201.dir/b.go +++ b/test/fixedbugs/issue47201.dir/b.go @@ -4,6 +4,6 @@ package main -func Println() {} // ERROR "Println redeclared in this block" +func Println() {} // ERROR "Println redeclared in this block|Println already declared" func main() {} diff --git a/test/fixedbugs/issue5609.go b/test/fixedbugs/issue5609.go index ea770b4865..a39d3fb0c6 100644 --- a/test/fixedbugs/issue5609.go +++ b/test/fixedbugs/issue5609.go @@ -10,4 +10,4 @@ package pkg const Large uint64 = 18446744073709551615 -var foo [Large]uint64 // ERROR "array bound is too large|array bound overflows" +var foo [Large]uint64 // ERROR "array bound is too large|array bound overflows|array length.*must be integer" diff --git a/test/float_lit3.go b/test/float_lit3.go index 850d02c9c7..37a1289fb9 100644 --- a/test/float_lit3.go +++ b/test/float_lit3.go @@ -29,19 +29,19 @@ const ( var x = []interface{}{ float32(max32 + ulp32/2 - 1), // ok float32(max32 + ulp32/2 - two128/two256), // ok - float32(max32 + ulp32/2), // ERROR "constant 3\.40282e\+38 overflows float32" + float32(max32 + ulp32/2), // ERROR "constant 3\.40282e\+38 overflows float32|cannot convert.*to type float32" float32(-max32 - ulp32/2 + 1), // ok float32(-max32 - ulp32/2 + two128/two256), // ok - float32(-max32 - ulp32/2), // ERROR "constant -3\.40282e\+38 overflows float32" + float32(-max32 - ulp32/2), // ERROR "constant -3\.40282e\+38 overflows float32|cannot convert.*to type float32" // If the compiler's internal floating point representation // is shorter than 1024 bits, it cannot distinguish max64+ulp64/2-1 and max64+ulp64/2. float64(max64 + ulp64/2 - two1024/two256), // ok float64(max64 + ulp64/2 - 1), // ok - float64(max64 + ulp64/2), // ERROR "constant 1\.79769e\+308 overflows float64" + float64(max64 + ulp64/2), // ERROR "constant 1\.79769e\+308 overflows float64|cannot convert.*to type float64" float64(-max64 - ulp64/2 + two1024/two256), // ok float64(-max64 - ulp64/2 + 1), // ok - float64(-max64 - ulp64/2), // ERROR "constant -1\.79769e\+308 overflows float64" + float64(-max64 - ulp64/2), // ERROR "constant -1\.79769e\+308 overflows float64|cannot convert.*to type float64" } diff --git a/test/linkname2.go b/test/linkname2.go index cb7f9be345..5eb250f9c4 100644 --- a/test/linkname2.go +++ b/test/linkname2.go @@ -16,12 +16,6 @@ var x, y int //go:linkname x ok // ERROR "//go:linkname requires linkname argument or -p compiler flag" -// ERROR "//go:linkname must refer to declared function or variable" -// ERROR "//go:linkname must refer to declared function or variable" -// ERROR "duplicate //go:linkname for x" //line linkname2.go:18 //go:linkname y -//go:linkname nonexist nonexist -//go:linkname t notvarfunc -//go:linkname x duplicate diff --git a/test/linkname3.go b/test/linkname3.go new file mode 100644 index 0000000000..df110cd064 --- /dev/null +++ b/test/linkname3.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. + +// 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 must refer to declared function or variable" +// ERROR "//go:linkname must refer to declared function or variable" +// ERROR "duplicate //go:linkname for x" + +//line linkname3.go:18 +//go:linkname nonexist nonexist +//go:linkname t notvarfunc +//go:linkname x duplicate diff --git a/test/run.go b/test/run.go index c6e82891da..e17d9729bc 100644 --- a/test/run.go +++ b/test/run.go @@ -2115,14 +2115,11 @@ func overlayDir(dstRoot, srcRoot string) error { // List of files that the compiler cannot errorcheck with the new typechecker (compiler -G option). // Temporary scaffolding until we pass all the tests at which point this map can be removed. var types2Failures = setOf( - "directive.go", // misplaced compiler directive checks - "float_lit3.go", // types2 reports extra errors "import1.go", // types2 reports extra errors "import6.go", // issue #43109 "initializerr.go", // types2 reports extra errors - "linkname2.go", // error reported by noder (not running for types2 errorcheck test) "notinheap.go", // types2 doesn't report errors about conversions that are invalid due to //go:notinheap - "shift1.go", // issue #42989 + "shift1.go", // mostly just different wording, but reports two new errors. "typecheck.go", // invalid function is not causing errors when called "fixedbugs/bug176.go", // types2 reports all errors (pref: types2) @@ -2138,11 +2135,9 @@ var types2Failures = setOf( "fixedbugs/issue11610.go", // types2 not run after syntax errors "fixedbugs/issue11614.go", // types2 reports an extra error "fixedbugs/issue14520.go", // missing import path error by types2 - "fixedbugs/issue16428.go", // types2 reports two instead of one error "fixedbugs/issue17038.go", // types2 doesn't report a follow-on error (pref: types2) - "fixedbugs/issue17645.go", // multiple errors on same line "fixedbugs/issue18331.go", // missing error about misuse of //go:noescape (irgen needs code from noder) - "fixedbugs/issue18419.go", // types2 reports + "fixedbugs/issue18419.go", // types2 reports no field or method member, but should say unexported "fixedbugs/issue19012.go", // multiple errors on same line "fixedbugs/issue20233.go", // types2 reports two instead of one error (pref: compiler) "fixedbugs/issue20245.go", // types2 reports two instead of one error (pref: compiler) @@ -2156,8 +2151,6 @@ var types2Failures = setOf( "fixedbugs/issue4232.go", // types2 reports (correct) extra errors "fixedbugs/issue4452.go", // types2 reports (correct) extra errors "fixedbugs/issue4510.go", // types2 reports different (but ok) line numbers - "fixedbugs/issue47201.go", // types2 spells the error message differently - "fixedbugs/issue5609.go", // types2 needs a better error message "fixedbugs/issue7525b.go", // types2 reports init cycle error on different line - ok otherwise "fixedbugs/issue7525c.go", // types2 reports init cycle error on different line - ok otherwise "fixedbugs/issue7525d.go", // types2 reports init cycle error on different line - ok otherwise @@ -2176,9 +2169,10 @@ var g3Failures = setOf( ) var unifiedFailures = setOf( - "closure3.go", // unified IR numbers closures differently than -d=inlfuncswithclosures - "escape4.go", // unified IR can inline f5 and f6; test doesn't expect this - "inline.go", // unified IR reports function literal diagnostics on different lines than -d=inlfuncswithclosures + "closure3.go", // unified IR numbers closures differently than -d=inlfuncswithclosures + "escape4.go", // unified IR can inline f5 and f6; test doesn't expect this + "inline.go", // unified IR reports function literal diagnostics on different lines than -d=inlfuncswithclosures + "linkname3.go", // unified IR is missing some linkname errors "fixedbugs/issue42284.go", // prints "T(0) does not escape", but test expects "a.I(a.T(0)) does not escape" "fixedbugs/issue7921.go", // prints "… escapes to heap", but test expects "string(…) escapes to heap" diff --git a/test/shift1.go b/test/shift1.go index d6a6c38839..0dae49a74d 100644 --- a/test/shift1.go +++ b/test/shift1.go @@ -25,7 +25,7 @@ var ( var ( e1 = g(2.0 << s) // ERROR "invalid|shift of non-integer operand" f1 = h(2 << s) // ERROR "invalid" - g1 int64 = 1.1 << s // ERROR "truncated" + g1 int64 = 1.1 << s // ERROR "truncated|must be integer" ) // constant shift expressions @@ -44,7 +44,7 @@ var ( b3 = 1< Date: Fri, 3 Dec 2021 09:04:26 -0500 Subject: [PATCH 378/752] doc/go1.18: reorganize runtime/compiler a little For #47694. Change-Id: Iedf85f522f7c79ae0a61b4fc1f2f092cf7b613df Reviewed-on: https://go-review.googlesource.com/c/go/+/368696 Trust: Austin Clements Reviewed-by: Jeremy Faller --- doc/go1.18.html | 48 +++++++++++++++++++++++++----------------------- 1 file changed, 25 insertions(+), 23 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 2ea8e08423..3e7de64121 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -76,15 +76,6 @@ proposal.

    Ports

    -

    FreeBSD

    - -

    - Go 1.18 is the last release that is supported on FreeBSD 11.x, which has - already reached end-of-life. Go 1.19 will require FreeBSD 12.2+ or FreeBSD - 13.0+. - FreeBSD 13.0+ will require a kernel with the COMPAT_FREEBSD12 option set (this is the default). -

    -

    AMD64

    @@ -105,6 +96,15 @@ proposal. now supports the c-archive and c-shared build modes.

    +

    Windows

    + +

    + The windows/arm and windows/arm64 ports now support + non-cooperative preemption, bringing that capability to all four Windows + ports, which should hopefully address subtle bugs encountered when calling + into Win32 functions that block for extended periods of time. +

    +

    iOS

    @@ -113,6 +113,15 @@ proposal. Go 1.18 now requires iOS 12 or later; support for previous versions has been discontinued.

    +

    FreeBSD

    + +

    + Go 1.18 is the last release that is supported on FreeBSD 11.x, which has + already reached end-of-life. Go 1.19 will require FreeBSD 12.2+ or FreeBSD + 13.0+. + FreeBSD 13.0+ will require a kernel with the COMPAT_FREEBSD12 option set (this is the default). +

    +

    Tools

    Go command

    @@ -200,13 +209,6 @@ proposal.

    Runtime

    -

    - The windows/arm and windows/arm64 ports now support - non-cooperative preemption, bringing that capability to all four Windows - ports, which should hopefully address subtle bugs encountered when calling - into Win32 functions that block for extended periods of time. -

    -

    The garbage collector now includes non-heap sources of garbage collector work (e.g., stack scanning) when determining how frequently to run. As a result, @@ -222,6 +224,13 @@ proposal. been tuned to work more aggressively as a result.

    +

    + Go 1.17 generally improved the formatting of arguments in stack traces, + but could print inaccurate values for arguments passed in registers. + This is improved in Go 1.18 by printing a question mark (?) + after each value that may be inaccurate. +

    +

    Compiler

    @@ -243,13 +252,6 @@ proposal. Go 1.17 release notes for more details.

    -

    - Go 1.17 generally improved the formatting of arguments in stack traces, - but could print inaccurate values for arguments passed in registers. - This is improved in Go 1.18 by printing a question mark (?) - after each value that may be inaccurate. -

    -

    The new compiler -asan option supports the new go command -asan option. From deb988a2866ce541058d8af3844912d1a638980b Mon Sep 17 00:00:00 2001 From: Katie Hockman Date: Fri, 3 Dec 2021 12:23:44 -0500 Subject: [PATCH 379/752] doc/go1.18: mention fuzzing in the release notes Also make a few small formatting fixes. Change-Id: Iad99d030312393af3b6533f2cd00f09aea0f2a7d Reviewed-on: https://go-review.googlesource.com/c/go/+/369074 Trust: Katie Hockman Run-TryBot: Katie Hockman TryBot-Result: Gopher Robot Reviewed-by: Robert Griesemer --- doc/go1.18.html | 27 ++++++++++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 3e7de64121..27eaf0beec 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -59,9 +59,9 @@ Do not send CLs removing the interior tags from such phrases.

    Generics

    -Go 1.18 includes an implementation of generics as described -by the -proposal. + Go 1.18 includes an implementation of generics as described + by the + generics proposal.

    @@ -74,6 +74,27 @@ proposal.

    +

    Fuzzing

    + +

    + Go 1.18 includes an implementation of fuzzing as described by + the fuzzing proposal. +

    + +

    + See the fuzzing landing page to get + started. +

    + +

    + Please be aware that fuzzing can consume a lot of memory and may impact your + machine’s performance while it runs. Also be aware that the fuzzing engine + writes values that expand test coverage to a fuzz cache directory within + $GOCACHE/fuzz while it runs. There is currently no limit to the + number of files or total bytes that may be written to the fuzz cache, so it + may occupy a large amount of storage (possibly several GBs). +

    +

    Ports

    AMD64

    From c4a8550421ce16f233b48a85dc5dd04b16469b7f Mon Sep 17 00:00:00 2001 From: Sean Liao Date: Tue, 23 Nov 2021 20:52:07 +0100 Subject: [PATCH 380/752] .github: use multiple issue templates There are currently multiple issue templates floating around for different projects, these can sometimes be hard to find. Fixes #29839 Change-Id: I6600b6f78842736d81d35e6a64247d00706d9e0e Reviewed-on: https://go-review.googlesource.com/c/go/+/366736 Trust: Russ Cox Reviewed-by: Dmitri Shuralyov Run-TryBot: Dmitri Shuralyov TryBot-Result: Gopher Robot --- .../00-bug.md} | 11 +++- .github/ISSUE_TEMPLATE/01-pkgsite.md | 47 ++++++++++++++ .github/ISSUE_TEMPLATE/02-pkgsite-removal.md | 39 ++++++++++++ .github/ISSUE_TEMPLATE/03-gopls.md | 61 +++++++++++++++++++ .github/ISSUE_TEMPLATE/10-proposal.md | 13 ++++ .github/ISSUE_TEMPLATE/11-language-change.md | 52 ++++++++++++++++ .github/ISSUE_TEMPLATE/config.yml | 8 +++ 7 files changed, 229 insertions(+), 2 deletions(-) rename .github/{ISSUE_TEMPLATE => ISSUE_TEMPLATE/00-bug.md} (80%) create mode 100644 .github/ISSUE_TEMPLATE/01-pkgsite.md create mode 100644 .github/ISSUE_TEMPLATE/02-pkgsite-removal.md create mode 100644 .github/ISSUE_TEMPLATE/03-gopls.md create mode 100644 .github/ISSUE_TEMPLATE/10-proposal.md create mode 100644 .github/ISSUE_TEMPLATE/11-language-change.md create mode 100644 .github/ISSUE_TEMPLATE/config.yml diff --git a/.github/ISSUE_TEMPLATE b/.github/ISSUE_TEMPLATE/00-bug.md similarity index 80% rename from .github/ISSUE_TEMPLATE rename to .github/ISSUE_TEMPLATE/00-bug.md index 5cbfc09fe7..f056dab7dd 100644 --- a/.github/ISSUE_TEMPLATE +++ b/.github/ISSUE_TEMPLATE/00-bug.md @@ -1,6 +1,11 @@ +--- +name: Bugs +about: The go command, standard library, or anything else +title: "affected/package: " +--- + ### What version of Go are you using (`go version`)? @@ -26,7 +31,7 @@ $ go env @@ -36,3 +41,5 @@ A link on play.golang.org is best. ### What did you see instead? + + diff --git a/.github/ISSUE_TEMPLATE/01-pkgsite.md b/.github/ISSUE_TEMPLATE/01-pkgsite.md new file mode 100644 index 0000000000..fee00f5b27 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/01-pkgsite.md @@ -0,0 +1,47 @@ +--- +name: Pkg.go.dev bugs or feature requests +about: Issues or feature requests for the documentation site +title: "x/pkgsite: " +labels: pkgsite +--- + + + +### What is the URL of the page with the issue? + + + +### What is your user agent? + + + + + +### Screenshot + + + + + +### What did you do? + + + + + +### What did you expect to see? + + + +### What did you see instead? + + diff --git a/.github/ISSUE_TEMPLATE/02-pkgsite-removal.md b/.github/ISSUE_TEMPLATE/02-pkgsite-removal.md new file mode 100644 index 0000000000..5c1eb94be6 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/02-pkgsite-removal.md @@ -0,0 +1,39 @@ +--- +name: Pkg.go.dev package removal request +about: Request a package be removed from the documentation site (pkg.go.dev) +title: "x/pkgsite: package removal request for [type path here]" +labels: pkgsite +--- + + + +### What is the path of the package that you would like to have removed? + + + + + +### Are you the owner of this package? + + + + + +### What is the reason that you could not retract this package instead? + + + + diff --git a/.github/ISSUE_TEMPLATE/03-gopls.md b/.github/ISSUE_TEMPLATE/03-gopls.md new file mode 100644 index 0000000000..c4934c3898 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/03-gopls.md @@ -0,0 +1,61 @@ +--- +name: Gopls bugs or feature requests +about: Issues or feature requests for the Go language server (gopls) +title: "x/tools/gopls: " +labels: gopls Tools +--- + + + +### gopls version + + + + + +### go env + + + + +### What did you do? + + + + + +### What did you expect to see? + + + +### What did you see instead? + + + +### Editor and settings + + + + + +### Logs + + + + diff --git a/.github/ISSUE_TEMPLATE/10-proposal.md b/.github/ISSUE_TEMPLATE/10-proposal.md new file mode 100644 index 0000000000..ab30ddf417 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/10-proposal.md @@ -0,0 +1,13 @@ +--- +name: Proposals +about: New external API or other notable changes +title: "proposal: affected/package: " +labels: Proposal +--- + + + + diff --git a/.github/ISSUE_TEMPLATE/11-language-change.md b/.github/ISSUE_TEMPLATE/11-language-change.md new file mode 100644 index 0000000000..2032301327 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/11-language-change.md @@ -0,0 +1,52 @@ +--- +name: Language Change Proposals +about: Changes to the language +title: "proposal: Go 2: " +labels: Proposal Go2 LanguageChange +--- + + + +### Author background + +- **Would you consider yourself a novice, intermediate, or experienced Go programmer?** +- **What other languages do you have experience with?** + +### Related proposals + +- **Has this idea, or one like it, been proposed before?** + - **If so, how does this proposal differ?** +- **Does this affect error handling?** + - **If so, how does this differ from previous error handling proposals?** +- **Is this about generics?** + - **If so, how does this relate to the accepted design and other generics proposals?** + +### Proposal + +- **What is the proposed change?** +- **Who does this proposal help, and why?** +- **Please describe as precisely as possible the change to the language.** +- **What would change in the language spec?** +- **Please also describe the change informally, as in a class teaching Go.** +- **Is this change backward compatible?** + - Breaking the Go 1 compatibility guarantee is a large cost and requires a large benefit. + Show example code before and after the change. + - **Before** + - **After** +- **Orthogonality: how does this change interact or overlap with existing features?** +- **Is the goal of this change a performance improvement?** + - **If so, what quantifiable improvement should we expect?** + - **How would we measure it?** + +### Costs + +- **Would this change make Go easier or harder to learn, and why?** +- **What is the cost of this proposal? (Every language change has a cost).** +- **How many tools (such as vet, gopls, gofmt, goimports, etc.) would be affected?** +- **What is the compile time cost?** +- **What is the run time cost?** +- **Can you describe a possible implementation?** +- **Do you have a prototype? (This is not required.)** diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 0000000000..ddf5fc6833 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,8 @@ +blank_issues_enabled: false +contact_links: + - name: Questions + about: Please use one of the forums for questions or general discussions + url: https://go.dev/wiki/Questions + - name: Security Vulnerabilities + about: See here for our security policy + url: https://go.dev/security From ebe99189fce39be68ef4eafa29923b3a6585a262 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Fri, 3 Dec 2021 13:39:42 -0500 Subject: [PATCH 381/752] doc/go1.18: catch up with runtime/compiler commits and API changes For #47694. Change-Id: I21b1af1807d4da2fb2f4d9b961d44a21d715d7d2 Reviewed-on: https://go-review.googlesource.com/c/go/+/369155 Trust: Austin Clements Trust: Jeremy Faller Reviewed-by: Jeremy Faller --- doc/go1.18.html | 58 +++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 54 insertions(+), 4 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 27eaf0beec..4776936083 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -255,7 +255,7 @@ Do not send CLs removing the interior tags from such phrases.

    Compiler

    - Go 1.17 implemented a new way of passing + Go 1.17 implemented a new way of passing function arguments and results using registers instead of the stack on 64-bit x86 architecture on selected operating systems. Go 1.18 expands the supported platforms to include 64-bit ARM (GOARCH=arm64), @@ -263,14 +263,19 @@ Do not send CLs removing the interior tags from such phrases. as well as 64-bit x86 architecture (GOARCH=amd64) on all operating systems. On 64-bit ARM and 64-bit PowerPC systems, benchmarking shows - performance improvements of 10% or more. + typical performance improvements of 10% or more.

    - As mentioned in the Go 1.17 release notes, + As mentioned in the Go 1.17 release notes, this change does not affect the functionality of any safe Go code and is designed to have no impact on most assembly code. See the - Go 1.17 release notes for more details. + Go 1.17 release notes for more details. +

    + +

    + The compiler now can inline functions that contain range loops or + labeled for loops.

    @@ -278,6 +283,10 @@ Do not send CLs removing the interior tags from such phrases. new go command -asan option.

    +

    + TODO: Mention build speed impact. +

    +

    Linker

    @@ -367,6 +376,10 @@ Do not send CLs removing the interior tags from such phrases. handle Unicode punctuation and language-specific capitalization rules, and is superseded by the golang.org/x/text/cases package.

    + +

    + TODO: bytes.Cut. +

    @@ -393,6 +406,22 @@ Do not send CLs removing the interior tags from such phrases. +
    go/ast
    +
    +

    + TODO: Mention new generics APIs. +

    +
    +
    + +
    go/types
    +
    +

    + TODO: Mention new generics APIs. +

    +
    +
    +
    image/draw

    @@ -412,6 +441,12 @@ Do not send CLs removing the interior tags from such phrases. net.Error.Temporary has been deprecated.

    + +
    +

    + TODO: Several new net APIs. +

    +
    net/http
    @@ -488,6 +523,17 @@ Do not send CLs removing the interior tags from such phrases. Value.FieldByIndex when stepping through a nil pointer to an embedded struct.

    + +

    + reflect.Ptr and + reflect.PtrTo + have been renamed to + reflect.Pointer and + reflect.PointerTo, + respectively, for consistency with the rest of the reflect package. + The old names will continue to work, but will be deprecated in a + future Go release. +

    @@ -526,6 +572,10 @@ Do not send CLs removing the interior tags from such phrases. handle Unicode punctuation and language-specific capitalization rules, and is superseded by the golang.org/x/text/cases package.

    + +

    + TODO: strings.Cut. +

    From b3e1fbff4d45034a9345cf5ee95099c2742c78c6 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Fri, 3 Dec 2021 13:40:10 -0500 Subject: [PATCH 382/752] cmd/compile/abi-internal: mention SSE restriction on Plan 9 Change-Id: I2be08b88b5147cf37ac55b7472d63503739c9f05 Reviewed-on: https://go-review.googlesource.com/c/go/+/369156 Trust: Austin Clements Reviewed-by: Cherry Mui --- src/cmd/compile/abi-internal.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/cmd/compile/abi-internal.md b/src/cmd/compile/abi-internal.md index 50d8ed9159..7fe4463665 100644 --- a/src/cmd/compile/abi-internal.md +++ b/src/cmd/compile/abi-internal.md @@ -410,7 +410,11 @@ Special-purpose registers are as follows: | R13 | Scratch | Scratch | Scratch | | R14 | Current goroutine | Same | Same | | R15 | GOT reference temporary if dynlink | Same | Same | -| X15 | Zero value | Same | Scratch | +| X15 | Zero value (*) | Same | Scratch | + +(*) Except on Plan 9, where X15 is a scratch register because SSE +registers cannot be used in note handlers (so the compiler avoids +using them except when absolutely necessary). *Rationale*: These register meanings are compatible with Go’s stack-based calling convention except for R14 and X15, which will have From d20a0bfc8a7fd70537766990691d4c9e5841e086 Mon Sep 17 00:00:00 2001 From: Hossein Zolfi Date: Fri, 3 Dec 2021 22:51:11 +0330 Subject: [PATCH 383/752] doc/go1.18: change github.com/golang/go/issues to golang.org/issue Updates #47694 Change-Id: I84547ff995e2a302cf229fefefd28a7220a17028 Reviewed-on: https://go-review.googlesource.com/c/go/+/369016 Reviewed-by: Michael Knyszek Trust: Austin Clements --- doc/go1.18.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 4776936083..ea686933e0 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -230,7 +230,7 @@ Do not send CLs removing the interior tags from such phrases.

    Runtime

    -

    +

    The garbage collector now includes non-heap sources of garbage collector work (e.g., stack scanning) when determining how frequently to run. As a result, garbage collector overhead is more predictable when these sources are From 9ae0b35fad5d4bb95cdcf4a05fcf4b077a798572 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Fri, 3 Dec 2021 13:57:25 -0800 Subject: [PATCH 384/752] test: add test of select inside generic function Make sure that we can import/export selects for generics. Change-Id: Ibf36e98fc574ce9275820aa426b3e6703b0aae6d Reviewed-on: https://go-review.googlesource.com/c/go/+/369101 Trust: Keith Randall Trust: Dan Scales Run-TryBot: Keith Randall TryBot-Result: Gopher Robot Reviewed-by: Dan Scales --- test/typeparam/select.dir/a.go | 15 +++++++++++++++ test/typeparam/select.dir/main.go | 28 ++++++++++++++++++++++++++++ test/typeparam/select.go | 7 +++++++ 3 files changed, 50 insertions(+) create mode 100644 test/typeparam/select.dir/a.go create mode 100644 test/typeparam/select.dir/main.go create mode 100644 test/typeparam/select.go diff --git a/test/typeparam/select.dir/a.go b/test/typeparam/select.dir/a.go new file mode 100644 index 0000000000..983e4b1d5f --- /dev/null +++ b/test/typeparam/select.dir/a.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. + +package a + +func F[T any](c, d chan T) T { + select { + case x := <- c: + return x + case x := <- d: + return x + } +} + diff --git a/test/typeparam/select.dir/main.go b/test/typeparam/select.dir/main.go new file mode 100644 index 0000000000..6ea3fe2eea --- /dev/null +++ b/test/typeparam/select.dir/main.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 main + +import ( + "sort" + + "./a" +) + +func main() { + c := make(chan int, 1) + d := make(chan int, 1) + + c <- 5 + d <- 6 + + var r [2]int + r[0] = a.F(c, d) + r[1] = a.F(c, d) + sort.Ints(r[:]) + + if r != [2]int{5, 6} { + panic("incorrect results") + } +} diff --git a/test/typeparam/select.go b/test/typeparam/select.go new file mode 100644 index 0000000000..76930e5e4f --- /dev/null +++ b/test/typeparam/select.go @@ -0,0 +1,7 @@ +// rundir -G=3 + +// 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 From ba83aa7caa4116266b6cc999d4e1fe9123fe18cb Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 3 Dec 2021 10:04:49 -0800 Subject: [PATCH 385/752] doc/go1.18: add documentation for changes to go/constant Updates #47694 Change-Id: I2ce5aaa4493259790712a8a49e5b03472c8a7400 Reviewed-on: https://go-review.googlesource.com/c/go/+/369094 Trust: Robert Griesemer Reviewed-by: Robert Findley --- doc/go1.18.html | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index ea686933e0..5b0520e9d6 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -406,18 +406,11 @@ Do not send CLs removing the interior tags from such phrases. -

    go/ast
    +
    go/constant
    -

    - TODO: Mention new generics APIs. -

    -
    -
    - -
    go/types
    -
    -

    - TODO: Mention new generics APIs. +

    + The new Kind.String + method returns a human-readable name for the receiver kind.

    From 821bf04f2aa6b79d1d66ef7aba7537d346ea5a21 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 3 Dec 2021 10:11:53 -0800 Subject: [PATCH 386/752] doc/go1.18: add documentation for changes to go/token Updates #47694 Change-Id: I232fb20b3a77409b84c15f9ec1586e480f0f6390 Reviewed-on: https://go-review.googlesource.com/c/go/+/369095 Trust: Robert Griesemer Reviewed-by: Robert Findley --- doc/go1.18.html | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 5b0520e9d6..5f32d64283 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -415,6 +415,18 @@ Do not send CLs removing the interior tags from such phrases.
    +
    go/token
    +
    +

    + The new constant TILDE + represents the ~ token per the proposal + + Additions to go/ast and go/token to support parameterized functions and types + . +

    +
    +
    +
    image/draw

    From fa88ba1e8adacda08973d112cca8d6e66c1390e1 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 3 Dec 2021 10:52:52 -0800 Subject: [PATCH 387/752] doc/go1.18: add documentation for changes to go/ast Updates #47694 Change-Id: Ied26f6345df2c8640d4be5132a05db3897b59009 Reviewed-on: https://go-review.googlesource.com/c/go/+/369096 Trust: Robert Griesemer Reviewed-by: Robert Findley --- doc/go1.18.html | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 5f32d64283..c2a04ef419 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -406,6 +406,30 @@ Do not send CLs removing the interior tags from such phrases.

    +
    go/ast
    +
    +

    + Per the proposal + + Additions to go/ast and go/token to support parameterized functions and types + + the following additions are made to the go/ast package: +

      +
    • + the FuncType + and TypeSpec + nodes have a new field TypeParams to hold type parameters, if any. +
      • +
    • + The new expression node IndexListExpr + represents index expressions with multiple indices, used for function and type instantiations + with more than one explicit type argument. +
      • +
    +

    +
    +
    +
    go/constant

    From cd5f2cf50f6372e31dde0b407c1c3be57a2ce90f Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 3 Dec 2021 12:20:33 -0800 Subject: [PATCH 388/752] doc/go1.18: add documentation for changes to go/types The number of involved CLs is too large (hundreds) so no CLs are mentioned in (html) comments. Updates #47694 Change-Id: I655d800a1e56a71e9d70a190f1c42c17baf6861e Reviewed-on: https://go-review.googlesource.com/c/go/+/369099 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Robert Findley --- doc/go1.18.html | 87 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index c2a04ef419..fb0b054e28 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -451,6 +451,93 @@ Do not send CLs removing the interior tags from such phrases.

    +
    go/types
    +
    +

    + Per the proposal + + Additions to go/types to support type parameters + + the following additions are made to the go/types package: +

    +
      +
    • + The new type + TypeParam, factory function + NewTypeParam, + and associated methods were added to represent a type parameter. +
      • +
    • + The new type + TypeParamList holds a list of + type parameters. +
      • +
    • + The new type + TypeList and factory function + NewTypeList facilitate storing + a list of types. +
      • +
    • + The new factory function + NewSignatureType allocates a + Signature with + (receiver or function) type parameters. + To access those type parameters, the Signature type has two new methods + Signature.RecvTypeParams and + Signature.TypeParams. +
      • +
    • + Named types have four new methods: + Named.Origin to get the original + parameterized types of instantiated types, + Named.TypeArgs and + Named.TypeParams to get the + type arguments or type parameters of an instantiated or parameterized type, and + Named.SetTypeParams to set the + type parameters (for instance, when importing a named type where allocation of the named + type and setting of type parameters cannot be done both at once due to possible cycles). +
      • +
    • + The Interface type has four new methods: + Interface.IsComparable and + Interface.IsMethodSet to + query properties of the type set defined by the interface, and + Interface.MarkImplicit and + Interface.IsImplicit to set + and test whether the interface is an implicit interface around a type constraint literal. +
      • +
    • + The new types + Union and + Term, factory functions + NewUnion and + NewTerm, and associated + methods were added to represent type sets in interfaces. +
      • +
    • + The new function + Instantiate + instantiates a parameterized type. +
      • +
    • + The new Info.Instances + map records function and type instantiations through the new + Instance type. +
      • +
    • + The new type ArgumentError + and associated methods were added to represent an error related to a type argument. +
      • +
    • + The new type Context and factory function + NewContext + were added to facilitate sharing of identical type instances across type-checked packages. +
      • +
    +
    +
    +
    image/draw

    From 549cfefc7233f17e6bf2d79294d11882181e9387 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 3 Dec 2021 19:24:54 -0800 Subject: [PATCH 389/752] doc/go1.18: expand section on generics Also, move it up in the document. Updates #47694 Change-Id: I927c4c845089a5c22e2c5b5f3de1831c04c6d990 Reviewed-on: https://go-review.googlesource.com/c/go/+/369102 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 78 +++++++++++++++++++++++++++++++++++++------------ 1 file changed, 60 insertions(+), 18 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index fb0b054e28..4f485143a9 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -29,6 +29,66 @@ Do not send CLs removing the interior tags from such phrases. TODO: complete this section

    +

    Generics

    + +

    + Go 1.18 includes an implementation of generic features as described by the + Type + Parameters Proposal. + This includes major - but fully backward-compatible - changes to the language. + The following is a list of the most visible changes. For a more comprehensive overview, see the + proposal. + For details see the language spec. +

    +
      +
    • + The new token ~ is added to the set of + operators and punctuation. +
      • +
    • + The syntax for + Function and + type declarations + now accepts + type parameters. +
      • +
    • + The syntax for + Interface types + now permits the embedding of arbitrary types (not just type names of interfaces) + as well as union and ~T type elements. Such interfaces may only be used + as type constraints. + An interface now defines a set of types as well as a set of methods. +
      • +
    • + Parameterized functions and types can be instantiated by following them with a list of + type arguments in square brackets. +
      • +
    • + The new + predeclared identifier + any is an alias for the empty interface. It may be used instead of + interface{}. +
      • +
    • + The new + predeclared identifier + comparable is an interface the denotes the set of all types which can be + compared using == or !=. It may only be used as (or embedded in) + a type constraint. +
      • +
    + +

    + The current generics implementation has the following limitations: +

      +
    • + The Go compiler cannot currently handle type declarations inside generic functions + or methods. We hope to provide support for this feature in Go 1.19. +
      • +
    +

    +

    Bug fixes

    @@ -56,24 +116,6 @@ Do not send CLs removing the interior tags from such phrases. programs is likely very small.

    -

    Generics

    - -

    - Go 1.18 includes an implementation of generics as described - by the - generics proposal. -

    - -

    - The current generics implementation has the following limitations: -

      -
    • - The Go compiler cannot currently handle type declarations inside generic functions - or methods. We hope to provide support for this feature in Go 1.19. -
      • -
    -

    -

    Fuzzing

    From 1876b38263407ba51f9f3fa2e412ac3f84d3cb95 Mon Sep 17 00:00:00 2001 From: Jeremy Faller Date: Thu, 2 Dec 2021 13:37:25 -0500 Subject: [PATCH 390/752] doc/go1.18: add docs for SysProcAttr.Pdeathsig CL 355570 Updates #47694 Change-Id: I922cda28ca4cf1ae6d5e4f457cc66d5041b0e3e8 Reviewed-on: https://go-review.googlesource.com/c/go/+/368798 Trust: Jeremy Faller Run-TryBot: Jeremy Faller TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor Reviewed-by: Tobias Klauser --- doc/go1.18.html | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 4f485143a9..fa65ad604e 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -761,7 +761,8 @@ Do not send CLs removing the interior tags from such phrases.

    - TODO: https://golang.org/cl/355570: add support for SysProcAttr.Pdeathsig on FreeBSD + SysProcAttr.Pdeathsig. + is now supported in FreeBSD.

    From 3396878af43752a7c25406dabd525754f80a1c40 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Sat, 4 Dec 2021 06:34:08 -0800 Subject: [PATCH 391/752] doc/go1.18: use correct link for reflect.PointerTo For #47694 Change-Id: Iee4fda069a56ea4436b8aa32e2605f3349d7c154 Reviewed-on: https://go-review.googlesource.com/c/go/+/369334 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Emmanuel Odeke --- doc/go1.18.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index fa65ad604e..16a5a6723c 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -687,7 +687,7 @@ Do not send CLs removing the interior tags from such phrases. reflect.PtrTo have been renamed to reflect.Pointer and - reflect.PointerTo, + reflect.PointerTo, respectively, for consistency with the rest of the reflect package. The old names will continue to work, but will be deprecated in a future Go release. From ecf6b52b7f4ba6e8c98f25adf9e83773fe908829 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Sat, 4 Dec 2021 17:59:19 -0800 Subject: [PATCH 392/752] test/ken/slicearray.go: correct type width in comment The type was changed in https://golang.org/cl/3991043 but the comment wasn't updated. Change-Id: I7ba3f625c732e5e801675ffc5d4a28e1d310faa3 Reviewed-on: https://go-review.googlesource.com/c/go/+/369374 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Rob Pike --- test/ken/slicearray.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/ken/slicearray.go b/test/ken/slicearray.go index 6cf676c588..a431983d15 100644 --- a/test/ken/slicearray.go +++ b/test/ken/slicearray.go @@ -89,7 +89,7 @@ func main() { by = bx[2:8] tstb() - // width 4 (float64) + // width 8 (float64) lb = 0 hb = 10 fy = fx[lb:hb] From 20b9aaca30f7caa5a7cdd05fe0c2e18f64b04a16 Mon Sep 17 00:00:00 2001 From: zhouguangyuan Date: Mon, 6 Dec 2021 09:16:24 +0800 Subject: [PATCH 393/752] all: update vendored golang.org/x/sys MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Update the vendored x/sys to pick up CL 368994, which remove the declaration of function darwinSupportsAVX512 in cpu/cpu_gc_x86.go. The following commands were used:   go get -d golang.org/x/sys@97ca703d548df069cb02aacea9efc3093ffdc3c4   go mod tidy   go mod vendor Fixes #49942 Change-Id: I05162a051f572bf8599be198a6033384b7d19445 Reviewed-on: https://go-review.googlesource.com/c/go/+/369454 Trust: Emmanuel Odeke Reviewed-by: Ian Lance Taylor Reviewed-by: Tobias Klauser Reviewed-by: Keith Randall Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot --- src/cmd/go.mod | 2 +- src/cmd/go.sum | 4 +- .../golang.org/x/sys/plan9/pwd_go15_plan9.go | 1 + .../golang.org/x/sys/plan9/pwd_plan9.go | 1 + src/cmd/vendor/golang.org/x/sys/plan9/race.go | 1 + .../vendor/golang.org/x/sys/plan9/race0.go | 1 + src/cmd/vendor/golang.org/x/sys/plan9/str.go | 1 + .../vendor/golang.org/x/sys/plan9/syscall.go | 1 + .../x/sys/plan9/zsyscall_plan9_386.go | 1 + .../x/sys/plan9/zsyscall_plan9_amd64.go | 1 + .../x/sys/plan9/zsyscall_plan9_arm.go | 1 + .../vendor/golang.org/x/sys/unix/README.md | 2 +- src/cmd/vendor/golang.org/x/sys/unix/mkall.sh | 2 +- .../vendor/golang.org/x/sys/unix/mkerrors.sh | 3 +- .../golang.org/x/sys/unix/syscall_linux.go | 10 + .../golang.org/x/sys/unix/zerrors_linux.go | 14 +- .../x/sys/unix/zerrors_linux_386.go | 2 +- .../x/sys/unix/zerrors_linux_amd64.go | 2 +- .../x/sys/unix/zerrors_linux_arm.go | 2 +- .../x/sys/unix/zerrors_linux_arm64.go | 2 +- .../x/sys/unix/zerrors_linux_mips.go | 2 +- .../x/sys/unix/zerrors_linux_mips64.go | 2 +- .../x/sys/unix/zerrors_linux_mips64le.go | 2 +- .../x/sys/unix/zerrors_linux_mipsle.go | 2 +- .../x/sys/unix/zerrors_linux_ppc.go | 2 +- .../x/sys/unix/zerrors_linux_ppc64.go | 2 +- .../x/sys/unix/zerrors_linux_ppc64le.go | 2 +- .../x/sys/unix/zerrors_linux_riscv64.go | 2 +- .../x/sys/unix/zerrors_linux_s390x.go | 2 +- .../x/sys/unix/zerrors_linux_sparc64.go | 2 +- .../golang.org/x/sys/unix/zsyscall_linux.go | 17 +- .../golang.org/x/sys/unix/ztypes_linux.go | 11 +- .../golang.org/x/sys/unix/ztypes_linux_386.go | 2 +- .../x/sys/unix/ztypes_linux_amd64.go | 2 +- .../golang.org/x/sys/unix/ztypes_linux_arm.go | 2 +- .../x/sys/unix/ztypes_linux_arm64.go | 2 +- .../x/sys/unix/ztypes_linux_mips.go | 2 +- .../x/sys/unix/ztypes_linux_mips64.go | 2 +- .../x/sys/unix/ztypes_linux_mips64le.go | 2 +- .../x/sys/unix/ztypes_linux_mipsle.go | 2 +- .../golang.org/x/sys/unix/ztypes_linux_ppc.go | 2 +- .../x/sys/unix/ztypes_linux_ppc64.go | 2 +- .../x/sys/unix/ztypes_linux_ppc64le.go | 2 +- .../x/sys/unix/ztypes_linux_riscv64.go | 2 +- .../x/sys/unix/ztypes_linux_s390x.go | 2 +- .../x/sys/unix/ztypes_linux_sparc64.go | 2 +- .../golang.org/x/sys/windows/mksyscall.go | 2 +- .../x/sys/windows/setupapi_windows.go | 1425 +++++++++++++++++ .../x/sys/windows/setupapierrors_windows.go | 100 -- .../x/sys/windows/syscall_windows.go | 3 + .../golang.org/x/sys/windows/types_windows.go | 17 + .../x/sys/windows/zsyscall_windows.go | 313 ++++ src/cmd/vendor/modules.txt | 2 +- src/go.mod | 2 +- src/go.sum | 4 +- src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go | 4 - src/vendor/modules.txt | 2 +- 57 files changed, 1857 insertions(+), 147 deletions(-) create mode 100644 src/cmd/vendor/golang.org/x/sys/windows/setupapi_windows.go delete mode 100644 src/cmd/vendor/golang.org/x/sys/windows/setupapierrors_windows.go diff --git a/src/cmd/go.mod b/src/cmd/go.mod index 833c7d7b1f..434081eb2f 100644 --- a/src/cmd/go.mod +++ b/src/cmd/go.mod @@ -14,6 +14,6 @@ require ( require ( github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d // indirect golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa // indirect - golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e // indirect + golang.org/x/sys v0.0.0-20211205182925-97ca703d548d // indirect golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect ) diff --git a/src/cmd/go.sum b/src/cmd/go.sum index 0d39656a1d..4b7aa6994c 100644 --- a/src/cmd/go.sum +++ b/src/cmd/go.sum @@ -14,8 +14,8 @@ golang.org/x/mod v0.6.0-dev.0.20211102181907-3a5865c02020/go.mod h1:3p9vT2HGsQu2 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e h1:i6Vklmyu+fZMFYpum+sR4ZWABGW7MyIxfJZXYvcnbns= -golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211205182925-97ca703d548d h1:FjkYO/PPp4Wi0EAUOVLxePm7qVW4r4ctbWpURyuOD0E= +golang.org/x/sys v0.0.0-20211205182925-97ca703d548d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/tools v0.1.8-0.20211202032535-e212aff8fd14 h1:KPFD5zp3T4bZL/kdosp4tGDJ6DKwUmYSWM0twy7w/bg= diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go b/src/cmd/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go index 87ae9d2a33..c9b69937a0 100644 --- a/src/cmd/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go +++ b/src/cmd/vendor/golang.org/x/sys/plan9/pwd_go15_plan9.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build go1.5 // +build go1.5 package plan9 diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/pwd_plan9.go b/src/cmd/vendor/golang.org/x/sys/plan9/pwd_plan9.go index c07c798bc5..98bf56b732 100644 --- a/src/cmd/vendor/golang.org/x/sys/plan9/pwd_plan9.go +++ b/src/cmd/vendor/golang.org/x/sys/plan9/pwd_plan9.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !go1.5 // +build !go1.5 package plan9 diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/race.go b/src/cmd/vendor/golang.org/x/sys/plan9/race.go index 42edd93ef9..62377d2ff9 100644 --- a/src/cmd/vendor/golang.org/x/sys/plan9/race.go +++ b/src/cmd/vendor/golang.org/x/sys/plan9/race.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build plan9 && race // +build plan9,race package plan9 diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/race0.go b/src/cmd/vendor/golang.org/x/sys/plan9/race0.go index c89cf8fc0d..f8da30876d 100644 --- a/src/cmd/vendor/golang.org/x/sys/plan9/race0.go +++ b/src/cmd/vendor/golang.org/x/sys/plan9/race0.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build plan9 && !race // +build plan9,!race package plan9 diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/str.go b/src/cmd/vendor/golang.org/x/sys/plan9/str.go index 4f7f9ad7c8..55fa8d025e 100644 --- a/src/cmd/vendor/golang.org/x/sys/plan9/str.go +++ b/src/cmd/vendor/golang.org/x/sys/plan9/str.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build plan9 // +build plan9 package plan9 diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/syscall.go b/src/cmd/vendor/golang.org/x/sys/plan9/syscall.go index e7363a2f54..602473cba3 100644 --- a/src/cmd/vendor/golang.org/x/sys/plan9/syscall.go +++ b/src/cmd/vendor/golang.org/x/sys/plan9/syscall.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build plan9 // +build plan9 // Package plan9 contains an interface to the low-level operating system diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go index 6819bc2094..3f40b9bd74 100644 --- a/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go +++ b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_386.go @@ -1,6 +1,7 @@ // go run mksyscall.go -l32 -plan9 -tags plan9,386 syscall_plan9.go // Code generated by the command above; see README.md. DO NOT EDIT. +//go:build plan9 && 386 // +build plan9,386 package plan9 diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go index 418abbbfc7..0e6a96aa4f 100644 --- a/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go +++ b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_amd64.go @@ -1,6 +1,7 @@ // go run mksyscall.go -l32 -plan9 -tags plan9,amd64 syscall_plan9.go // Code generated by the command above; see README.md. DO NOT EDIT. +//go:build plan9 && amd64 // +build plan9,amd64 package plan9 diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go index 3e8a1a58ca..244c501b77 100644 --- a/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go +++ b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm.go @@ -1,6 +1,7 @@ // go run mksyscall.go -l32 -plan9 -tags plan9,arm syscall_plan9.go // Code generated by the command above; see README.md. DO NOT EDIT. +//go:build plan9 && arm // +build plan9,arm package plan9 diff --git a/src/cmd/vendor/golang.org/x/sys/unix/README.md b/src/cmd/vendor/golang.org/x/sys/unix/README.md index 474efad0e0..7d3c060e12 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/README.md +++ b/src/cmd/vendor/golang.org/x/sys/unix/README.md @@ -149,7 +149,7 @@ To add a constant, add the header that includes it to the appropriate variable. Then, edit the regex (if necessary) to match the desired constant. Avoid making the regex too broad to avoid matching unintended constants. -### mkmerge.go +### internal/mkmerge This program is used to extract duplicate const, func, and type declarations from the generated architecture-specific files listed below, and merge these diff --git a/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh b/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh index 396aadf86d..ee73623489 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh +++ b/src/cmd/vendor/golang.org/x/sys/unix/mkall.sh @@ -50,7 +50,7 @@ if [[ "$GOOS" = "linux" ]]; then # Use the Docker-based build system # Files generated through docker (use $cmd so you can Ctl-C the build or run) $cmd docker build --tag generate:$GOOS $GOOS - $cmd docker run --interactive --tty --volume $(cd -- "$(dirname -- "$0")" && /bin/pwd):/build generate:$GOOS + $cmd docker run --interactive --tty --volume $(cd -- "$(dirname -- "$0")/.." && /bin/pwd):/build generate:$GOOS exit fi 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 a74ef58f8c..4945739ea0 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh +++ b/src/cmd/vendor/golang.org/x/sys/unix/mkerrors.sh @@ -239,6 +239,7 @@ struct ltchars { #include #include #include +#include #include #include #include @@ -520,7 +521,7 @@ ccflags="$@" $2 ~ /^HW_MACHINE$/ || $2 ~ /^SYSCTL_VERS/ || $2 !~ "MNT_BITS" && - $2 ~ /^(MS|MNT|UMOUNT)_/ || + $2 ~ /^(MS|MNT|MOUNT|UMOUNT)_/ || $2 ~ /^NS_GET_/ || $2 ~ /^TUN(SET|GET|ATTACH|DETACH)/ || $2 ~ /^(O|F|[ES]?FD|NAME|S|PTRACE|PT|TFD)_/ || 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 bc9dc2e10a..4bc5baf77d 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/syscall_linux.go @@ -1775,6 +1775,16 @@ func Mount(source string, target string, fstype string, flags uintptr, data stri return mount(source, target, fstype, flags, datap) } +//sys mountSetattr(dirfd int, pathname string, flags uint, attr *MountAttr, size uintptr) (err error) = SYS_MOUNT_SETATTR + +// MountSetattr is a wrapper for mount_setattr(2). +// https://man7.org/linux/man-pages/man2/mount_setattr.2.html +// +// Requires kernel >= 5.12. +func MountSetattr(dirfd int, pathname string, flags uint, attr *MountAttr) error { + return mountSetattr(dirfd, pathname, flags, attr, unsafe.Sizeof(*attr)) +} + func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { if raceenabled { raceReleaseMerge(unsafe.Pointer(&ioSync)) 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 3bbc527519..d175aae896 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux.go @@ -1,4 +1,4 @@ -// Code generated by mkmerge.go; DO NOT EDIT. +// Code generated by mkmerge; DO NOT EDIT. //go:build linux // +build linux @@ -1476,6 +1476,18 @@ const ( MNT_FORCE = 0x1 MODULE_INIT_IGNORE_MODVERSIONS = 0x1 MODULE_INIT_IGNORE_VERMAGIC = 0x2 + MOUNT_ATTR_IDMAP = 0x100000 + MOUNT_ATTR_NOATIME = 0x10 + MOUNT_ATTR_NODEV = 0x4 + MOUNT_ATTR_NODIRATIME = 0x80 + MOUNT_ATTR_NOEXEC = 0x8 + MOUNT_ATTR_NOSUID = 0x2 + MOUNT_ATTR_NOSYMFOLLOW = 0x200000 + MOUNT_ATTR_RDONLY = 0x1 + MOUNT_ATTR_RELATIME = 0x0 + MOUNT_ATTR_SIZE_VER0 = 0x20 + MOUNT_ATTR_STRICTATIME = 0x20 + MOUNT_ATTR__ATIME = 0x70 MSDOS_SUPER_MAGIC = 0x4d44 MSG_BATCH = 0x40000 MSG_CMSG_CLOEXEC = 0x40000000 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 80c790840c..3ca40ca7f0 100644 --- 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 @@ -5,7 +5,7 @@ // +build 386,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 /build/unix/_const.go package unix 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 da55638a44..ead332091a 100644 --- 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 @@ -5,7 +5,7 @@ // +build amd64,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 /build/unix/_const.go package unix 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 c3da063c70..39bdc94558 100644 --- 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 @@ -5,7 +5,7 @@ // +build arm,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/_const.go package unix 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 fd9f0d1dbf..9aec987db1 100644 --- 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 @@ -5,7 +5,7 @@ // +build arm64,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/unix/_const.go package unix 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 c358ada0d3..a8bba9491e 100644 --- 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 @@ -5,7 +5,7 @@ // +build mips,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/_const.go package unix 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 1dc1ee16b9..ee9e7e2020 100644 --- 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 @@ -5,7 +5,7 @@ // +build mips64,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/_const.go package unix 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 3ae187dd93..ba4b288a3c 100644 --- 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 @@ -5,7 +5,7 @@ // +build mips64le,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/_const.go package unix 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 39895f0dd1..bc93afc367 100644 --- 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 @@ -5,7 +5,7 @@ // +build mipsle,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/_const.go package unix diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go index a98a45537b..9295e69478 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/zerrors_linux_ppc.go @@ -5,7 +5,7 @@ // +build ppc,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/_const.go package unix 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 0a8fbbffaa..1fa081c9a6 100644 --- 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 @@ -5,7 +5,7 @@ // +build ppc64,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/_const.go package unix 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 cb835a1442..74b3211494 100644 --- 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 @@ -5,7 +5,7 @@ // +build ppc64le,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/_const.go package unix 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 73cf6554b0..c91c8ac5b0 100644 --- 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 @@ -5,7 +5,7 @@ // +build riscv64,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/_const.go package unix 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 04b6dfaf5f..b66bf22289 100644 --- 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 @@ -5,7 +5,7 @@ // +build s390x,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/unix/_const.go package unix 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 8c87d979d4..f7fb149b0c 100644 --- 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 @@ -5,7 +5,7 @@ // +build sparc64,linux // Code generated by cmd/cgo -godefs; DO NOT EDIT. -// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/_const.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/_const.go package unix diff --git a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go index 4f5da1f54f..93edda4c49 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/zsyscall_linux.go @@ -1,4 +1,4 @@ -// Code generated by mkmerge.go; DO NOT EDIT. +// Code generated by mkmerge; DO NOT EDIT. //go:build linux // +build linux @@ -409,6 +409,21 @@ func mount(source string, target string, fstype string, flags uintptr, data *byt // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT +func mountSetattr(dirfd int, pathname string, flags uint, attr *MountAttr, size uintptr) (err error) { + var _p0 *byte + _p0, err = BytePtrFromString(pathname) + if err != nil { + return + } + _, _, e1 := Syscall6(SYS_MOUNT_SETATTR, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags), uintptr(unsafe.Pointer(attr)), uintptr(size), 0) + if e1 != 0 { + err = errnoErr(e1) + } + return +} + +// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT + func Acct(path string) (err error) { var _p0 *byte _p0, err = BytePtrFromString(path) 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 620a6702fe..37b521436b 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux.go @@ -1,4 +1,4 @@ -// Code generated by mkmerge.go; DO NOT EDIT. +// Code generated by mkmerge; DO NOT EDIT. //go:build linux // +build linux @@ -743,6 +743,8 @@ const ( AT_STATX_FORCE_SYNC = 0x2000 AT_STATX_DONT_SYNC = 0x4000 + AT_RECURSIVE = 0x8000 + AT_SYMLINK_FOLLOW = 0x400 AT_SYMLINK_NOFOLLOW = 0x100 @@ -3959,3 +3961,10 @@ const ( SHM_RDONLY = 0x1000 SHM_RND = 0x2000 ) + +type MountAttr struct { + Attr_set uint64 + Attr_clr uint64 + Propagation uint64 + Userns_fd uint64 +} 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 eeeb9aa39a..bea2549455 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m32 /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go: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 d30e1155cc..b8c8f28943 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include -m64 /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go: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 69d0297520..4db4430163 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go: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 28a0455bc9..3ebcad8a88 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go: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 64a845483d..3eb33e48ab 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go: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 a1b7dee412..79a9446725 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go: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 936fa6a266..8f4b107cad 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go: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 5dd546fbf0..e4eb217981 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go:build mipsle && linux diff --git a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go index 947b32e434..d5b21f0f7d 100644 --- a/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go +++ b/src/cmd/vendor/golang.org/x/sys/unix/ztypes_linux_ppc.go @@ -1,4 +1,4 @@ -// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go:build ppc && 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 2a606151b0..5188d142b9 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go: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 d0d735d02c..de4dd4c736 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go: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 95e3d6d06f..dccbf9b060 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go: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 cccf1ef26a..6358806106 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include -fsigned-char /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go: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 44fcbe4e9a..765edc13ff 100644 --- 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 /build/linux/types.go | go run mkpost.go +// cgo -godefs -- -Wall -Werror -static -I/tmp/include /build/unix/linux/types.go | go run mkpost.go // Code generated by the command above; see README.md. DO NOT EDIT. //go:build sparc64 && linux diff --git a/src/cmd/vendor/golang.org/x/sys/windows/mksyscall.go b/src/cmd/vendor/golang.org/x/sys/windows/mksyscall.go index 6102910989..8563f79c57 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/mksyscall.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/mksyscall.go @@ -7,4 +7,4 @@ package windows -//go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go eventlog.go service.go syscall_windows.go security_windows.go +//go:generate go run golang.org/x/sys/windows/mkwinsyscall -output zsyscall_windows.go eventlog.go service.go syscall_windows.go security_windows.go setupapi_windows.go diff --git a/src/cmd/vendor/golang.org/x/sys/windows/setupapi_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/setupapi_windows.go new file mode 100644 index 0000000000..14027da3f3 --- /dev/null +++ b/src/cmd/vendor/golang.org/x/sys/windows/setupapi_windows.go @@ -0,0 +1,1425 @@ +// 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 windows + +import ( + "encoding/binary" + "errors" + "fmt" + "runtime" + "strings" + "syscall" + "unsafe" +) + +// This file contains functions that wrap SetupAPI.dll and CfgMgr32.dll, +// core system functions for managing hardware devices, drivers, and the PnP tree. +// Information about these APIs can be found at: +// https://docs.microsoft.com/en-us/windows-hardware/drivers/install/setupapi +// https://docs.microsoft.com/en-us/windows/win32/devinst/cfgmgr32- + +const ( + ERROR_EXPECTED_SECTION_NAME Errno = 0x20000000 | 0xC0000000 | 0 + ERROR_BAD_SECTION_NAME_LINE Errno = 0x20000000 | 0xC0000000 | 1 + ERROR_SECTION_NAME_TOO_LONG Errno = 0x20000000 | 0xC0000000 | 2 + ERROR_GENERAL_SYNTAX Errno = 0x20000000 | 0xC0000000 | 3 + ERROR_WRONG_INF_STYLE Errno = 0x20000000 | 0xC0000000 | 0x100 + ERROR_SECTION_NOT_FOUND Errno = 0x20000000 | 0xC0000000 | 0x101 + ERROR_LINE_NOT_FOUND Errno = 0x20000000 | 0xC0000000 | 0x102 + ERROR_NO_BACKUP Errno = 0x20000000 | 0xC0000000 | 0x103 + ERROR_NO_ASSOCIATED_CLASS Errno = 0x20000000 | 0xC0000000 | 0x200 + ERROR_CLASS_MISMATCH Errno = 0x20000000 | 0xC0000000 | 0x201 + ERROR_DUPLICATE_FOUND Errno = 0x20000000 | 0xC0000000 | 0x202 + ERROR_NO_DRIVER_SELECTED Errno = 0x20000000 | 0xC0000000 | 0x203 + ERROR_KEY_DOES_NOT_EXIST Errno = 0x20000000 | 0xC0000000 | 0x204 + ERROR_INVALID_DEVINST_NAME Errno = 0x20000000 | 0xC0000000 | 0x205 + ERROR_INVALID_CLASS Errno = 0x20000000 | 0xC0000000 | 0x206 + ERROR_DEVINST_ALREADY_EXISTS Errno = 0x20000000 | 0xC0000000 | 0x207 + ERROR_DEVINFO_NOT_REGISTERED Errno = 0x20000000 | 0xC0000000 | 0x208 + ERROR_INVALID_REG_PROPERTY Errno = 0x20000000 | 0xC0000000 | 0x209 + ERROR_NO_INF Errno = 0x20000000 | 0xC0000000 | 0x20A + ERROR_NO_SUCH_DEVINST Errno = 0x20000000 | 0xC0000000 | 0x20B + ERROR_CANT_LOAD_CLASS_ICON Errno = 0x20000000 | 0xC0000000 | 0x20C + ERROR_INVALID_CLASS_INSTALLER Errno = 0x20000000 | 0xC0000000 | 0x20D + ERROR_DI_DO_DEFAULT Errno = 0x20000000 | 0xC0000000 | 0x20E + ERROR_DI_NOFILECOPY Errno = 0x20000000 | 0xC0000000 | 0x20F + ERROR_INVALID_HWPROFILE Errno = 0x20000000 | 0xC0000000 | 0x210 + ERROR_NO_DEVICE_SELECTED Errno = 0x20000000 | 0xC0000000 | 0x211 + ERROR_DEVINFO_LIST_LOCKED Errno = 0x20000000 | 0xC0000000 | 0x212 + ERROR_DEVINFO_DATA_LOCKED Errno = 0x20000000 | 0xC0000000 | 0x213 + ERROR_DI_BAD_PATH Errno = 0x20000000 | 0xC0000000 | 0x214 + ERROR_NO_CLASSINSTALL_PARAMS Errno = 0x20000000 | 0xC0000000 | 0x215 + ERROR_FILEQUEUE_LOCKED Errno = 0x20000000 | 0xC0000000 | 0x216 + ERROR_BAD_SERVICE_INSTALLSECT Errno = 0x20000000 | 0xC0000000 | 0x217 + ERROR_NO_CLASS_DRIVER_LIST Errno = 0x20000000 | 0xC0000000 | 0x218 + ERROR_NO_ASSOCIATED_SERVICE Errno = 0x20000000 | 0xC0000000 | 0x219 + ERROR_NO_DEFAULT_DEVICE_INTERFACE Errno = 0x20000000 | 0xC0000000 | 0x21A + ERROR_DEVICE_INTERFACE_ACTIVE Errno = 0x20000000 | 0xC0000000 | 0x21B + ERROR_DEVICE_INTERFACE_REMOVED Errno = 0x20000000 | 0xC0000000 | 0x21C + ERROR_BAD_INTERFACE_INSTALLSECT Errno = 0x20000000 | 0xC0000000 | 0x21D + ERROR_NO_SUCH_INTERFACE_CLASS Errno = 0x20000000 | 0xC0000000 | 0x21E + ERROR_INVALID_REFERENCE_STRING Errno = 0x20000000 | 0xC0000000 | 0x21F + ERROR_INVALID_MACHINENAME Errno = 0x20000000 | 0xC0000000 | 0x220 + ERROR_REMOTE_COMM_FAILURE Errno = 0x20000000 | 0xC0000000 | 0x221 + ERROR_MACHINE_UNAVAILABLE Errno = 0x20000000 | 0xC0000000 | 0x222 + ERROR_NO_CONFIGMGR_SERVICES Errno = 0x20000000 | 0xC0000000 | 0x223 + ERROR_INVALID_PROPPAGE_PROVIDER Errno = 0x20000000 | 0xC0000000 | 0x224 + ERROR_NO_SUCH_DEVICE_INTERFACE Errno = 0x20000000 | 0xC0000000 | 0x225 + ERROR_DI_POSTPROCESSING_REQUIRED Errno = 0x20000000 | 0xC0000000 | 0x226 + ERROR_INVALID_COINSTALLER Errno = 0x20000000 | 0xC0000000 | 0x227 + ERROR_NO_COMPAT_DRIVERS Errno = 0x20000000 | 0xC0000000 | 0x228 + ERROR_NO_DEVICE_ICON Errno = 0x20000000 | 0xC0000000 | 0x229 + ERROR_INVALID_INF_LOGCONFIG Errno = 0x20000000 | 0xC0000000 | 0x22A + ERROR_DI_DONT_INSTALL Errno = 0x20000000 | 0xC0000000 | 0x22B + ERROR_INVALID_FILTER_DRIVER Errno = 0x20000000 | 0xC0000000 | 0x22C + ERROR_NON_WINDOWS_NT_DRIVER Errno = 0x20000000 | 0xC0000000 | 0x22D + ERROR_NON_WINDOWS_DRIVER Errno = 0x20000000 | 0xC0000000 | 0x22E + ERROR_NO_CATALOG_FOR_OEM_INF Errno = 0x20000000 | 0xC0000000 | 0x22F + ERROR_DEVINSTALL_QUEUE_NONNATIVE Errno = 0x20000000 | 0xC0000000 | 0x230 + ERROR_NOT_DISABLEABLE Errno = 0x20000000 | 0xC0000000 | 0x231 + ERROR_CANT_REMOVE_DEVINST Errno = 0x20000000 | 0xC0000000 | 0x232 + ERROR_INVALID_TARGET Errno = 0x20000000 | 0xC0000000 | 0x233 + ERROR_DRIVER_NONNATIVE Errno = 0x20000000 | 0xC0000000 | 0x234 + ERROR_IN_WOW64 Errno = 0x20000000 | 0xC0000000 | 0x235 + ERROR_SET_SYSTEM_RESTORE_POINT Errno = 0x20000000 | 0xC0000000 | 0x236 + ERROR_SCE_DISABLED Errno = 0x20000000 | 0xC0000000 | 0x238 + ERROR_UNKNOWN_EXCEPTION Errno = 0x20000000 | 0xC0000000 | 0x239 + ERROR_PNP_REGISTRY_ERROR Errno = 0x20000000 | 0xC0000000 | 0x23A + ERROR_REMOTE_REQUEST_UNSUPPORTED Errno = 0x20000000 | 0xC0000000 | 0x23B + ERROR_NOT_AN_INSTALLED_OEM_INF Errno = 0x20000000 | 0xC0000000 | 0x23C + ERROR_INF_IN_USE_BY_DEVICES Errno = 0x20000000 | 0xC0000000 | 0x23D + ERROR_DI_FUNCTION_OBSOLETE Errno = 0x20000000 | 0xC0000000 | 0x23E + ERROR_NO_AUTHENTICODE_CATALOG Errno = 0x20000000 | 0xC0000000 | 0x23F + ERROR_AUTHENTICODE_DISALLOWED Errno = 0x20000000 | 0xC0000000 | 0x240 + ERROR_AUTHENTICODE_TRUSTED_PUBLISHER Errno = 0x20000000 | 0xC0000000 | 0x241 + ERROR_AUTHENTICODE_TRUST_NOT_ESTABLISHED Errno = 0x20000000 | 0xC0000000 | 0x242 + ERROR_AUTHENTICODE_PUBLISHER_NOT_TRUSTED Errno = 0x20000000 | 0xC0000000 | 0x243 + ERROR_SIGNATURE_OSATTRIBUTE_MISMATCH Errno = 0x20000000 | 0xC0000000 | 0x244 + ERROR_ONLY_VALIDATE_VIA_AUTHENTICODE Errno = 0x20000000 | 0xC0000000 | 0x245 + ERROR_DEVICE_INSTALLER_NOT_READY Errno = 0x20000000 | 0xC0000000 | 0x246 + ERROR_DRIVER_STORE_ADD_FAILED Errno = 0x20000000 | 0xC0000000 | 0x247 + ERROR_DEVICE_INSTALL_BLOCKED Errno = 0x20000000 | 0xC0000000 | 0x248 + ERROR_DRIVER_INSTALL_BLOCKED Errno = 0x20000000 | 0xC0000000 | 0x249 + ERROR_WRONG_INF_TYPE Errno = 0x20000000 | 0xC0000000 | 0x24A + ERROR_FILE_HASH_NOT_IN_CATALOG Errno = 0x20000000 | 0xC0000000 | 0x24B + ERROR_DRIVER_STORE_DELETE_FAILED Errno = 0x20000000 | 0xC0000000 | 0x24C + ERROR_UNRECOVERABLE_STACK_OVERFLOW Errno = 0x20000000 | 0xC0000000 | 0x300 + EXCEPTION_SPAPI_UNRECOVERABLE_STACK_OVERFLOW Errno = ERROR_UNRECOVERABLE_STACK_OVERFLOW + ERROR_NO_DEFAULT_INTERFACE_DEVICE Errno = ERROR_NO_DEFAULT_DEVICE_INTERFACE + ERROR_INTERFACE_DEVICE_ACTIVE Errno = ERROR_DEVICE_INTERFACE_ACTIVE + ERROR_INTERFACE_DEVICE_REMOVED Errno = ERROR_DEVICE_INTERFACE_REMOVED + ERROR_NO_SUCH_INTERFACE_DEVICE Errno = ERROR_NO_SUCH_DEVICE_INTERFACE +) + +const ( + MAX_DEVICE_ID_LEN = 200 + MAX_DEVNODE_ID_LEN = MAX_DEVICE_ID_LEN + MAX_GUID_STRING_LEN = 39 // 38 chars + terminator null + MAX_CLASS_NAME_LEN = 32 + MAX_PROFILE_LEN = 80 + MAX_CONFIG_VALUE = 9999 + MAX_INSTANCE_VALUE = 9999 + CONFIGMG_VERSION = 0x0400 +) + +// Maximum string length constants +const ( + LINE_LEN = 256 // Windows 9x-compatible maximum for displayable strings coming from a device INF. + MAX_INF_STRING_LENGTH = 4096 // Actual maximum size of an INF string (including string substitutions). + MAX_INF_SECTION_NAME_LENGTH = 255 // For Windows 9x compatibility, INF section names should be constrained to 32 characters. + MAX_TITLE_LEN = 60 + MAX_INSTRUCTION_LEN = 256 + MAX_LABEL_LEN = 30 + MAX_SERVICE_NAME_LEN = 256 + MAX_SUBTITLE_LEN = 256 +) + +const ( + // SP_MAX_MACHINENAME_LENGTH defines maximum length of a machine name in the format expected by ConfigMgr32 CM_Connect_Machine (i.e., "\\\\MachineName\0"). + SP_MAX_MACHINENAME_LENGTH = MAX_PATH + 3 +) + +// HSPFILEQ is type for setup file queue +type HSPFILEQ uintptr + +// DevInfo holds reference to device information set +type DevInfo Handle + +// DEVINST is a handle usually recognized by cfgmgr32 APIs +type DEVINST uint32 + +// DevInfoData is a device information structure (references a device instance that is a member of a device information set) +type DevInfoData struct { + size uint32 + ClassGUID GUID + DevInst DEVINST + _ uintptr +} + +// DevInfoListDetailData is a structure for detailed information on a device information set (used for SetupDiGetDeviceInfoListDetail which supersedes the functionality of SetupDiGetDeviceInfoListClass). +type DevInfoListDetailData struct { + size uint32 // Use unsafeSizeOf method + ClassGUID GUID + RemoteMachineHandle Handle + remoteMachineName [SP_MAX_MACHINENAME_LENGTH]uint16 +} + +func (*DevInfoListDetailData) unsafeSizeOf() uint32 { + if unsafe.Sizeof(uintptr(0)) == 4 { + // Windows declares this with pshpack1.h + return uint32(unsafe.Offsetof(DevInfoListDetailData{}.remoteMachineName) + unsafe.Sizeof(DevInfoListDetailData{}.remoteMachineName)) + } + return uint32(unsafe.Sizeof(DevInfoListDetailData{})) +} + +func (data *DevInfoListDetailData) RemoteMachineName() string { + return UTF16ToString(data.remoteMachineName[:]) +} + +func (data *DevInfoListDetailData) SetRemoteMachineName(remoteMachineName string) error { + str, err := UTF16FromString(remoteMachineName) + if err != nil { + return err + } + copy(data.remoteMachineName[:], str) + return nil +} + +// DI_FUNCTION is function type for device installer +type DI_FUNCTION uint32 + +const ( + DIF_SELECTDEVICE DI_FUNCTION = 0x00000001 + DIF_INSTALLDEVICE DI_FUNCTION = 0x00000002 + DIF_ASSIGNRESOURCES DI_FUNCTION = 0x00000003 + DIF_PROPERTIES DI_FUNCTION = 0x00000004 + DIF_REMOVE DI_FUNCTION = 0x00000005 + DIF_FIRSTTIMESETUP DI_FUNCTION = 0x00000006 + DIF_FOUNDDEVICE DI_FUNCTION = 0x00000007 + DIF_SELECTCLASSDRIVERS DI_FUNCTION = 0x00000008 + DIF_VALIDATECLASSDRIVERS DI_FUNCTION = 0x00000009 + DIF_INSTALLCLASSDRIVERS DI_FUNCTION = 0x0000000A + DIF_CALCDISKSPACE DI_FUNCTION = 0x0000000B + DIF_DESTROYPRIVATEDATA DI_FUNCTION = 0x0000000C + DIF_VALIDATEDRIVER DI_FUNCTION = 0x0000000D + DIF_DETECT DI_FUNCTION = 0x0000000F + DIF_INSTALLWIZARD DI_FUNCTION = 0x00000010 + DIF_DESTROYWIZARDDATA DI_FUNCTION = 0x00000011 + DIF_PROPERTYCHANGE DI_FUNCTION = 0x00000012 + DIF_ENABLECLASS DI_FUNCTION = 0x00000013 + DIF_DETECTVERIFY DI_FUNCTION = 0x00000014 + DIF_INSTALLDEVICEFILES DI_FUNCTION = 0x00000015 + DIF_UNREMOVE DI_FUNCTION = 0x00000016 + DIF_SELECTBESTCOMPATDRV DI_FUNCTION = 0x00000017 + DIF_ALLOW_INSTALL DI_FUNCTION = 0x00000018 + DIF_REGISTERDEVICE DI_FUNCTION = 0x00000019 + DIF_NEWDEVICEWIZARD_PRESELECT DI_FUNCTION = 0x0000001A + DIF_NEWDEVICEWIZARD_SELECT DI_FUNCTION = 0x0000001B + DIF_NEWDEVICEWIZARD_PREANALYZE DI_FUNCTION = 0x0000001C + DIF_NEWDEVICEWIZARD_POSTANALYZE DI_FUNCTION = 0x0000001D + DIF_NEWDEVICEWIZARD_FINISHINSTALL DI_FUNCTION = 0x0000001E + DIF_INSTALLINTERFACES DI_FUNCTION = 0x00000020 + DIF_DETECTCANCEL DI_FUNCTION = 0x00000021 + DIF_REGISTER_COINSTALLERS DI_FUNCTION = 0x00000022 + DIF_ADDPROPERTYPAGE_ADVANCED DI_FUNCTION = 0x00000023 + DIF_ADDPROPERTYPAGE_BASIC DI_FUNCTION = 0x00000024 + DIF_TROUBLESHOOTER DI_FUNCTION = 0x00000026 + DIF_POWERMESSAGEWAKE DI_FUNCTION = 0x00000027 + DIF_ADDREMOTEPROPERTYPAGE_ADVANCED DI_FUNCTION = 0x00000028 + DIF_UPDATEDRIVER_UI DI_FUNCTION = 0x00000029 + DIF_FINISHINSTALL_ACTION DI_FUNCTION = 0x0000002A +) + +// DevInstallParams is device installation parameters structure (associated with a particular device information element, or globally with a device information set) +type DevInstallParams struct { + size uint32 + Flags DI_FLAGS + FlagsEx DI_FLAGSEX + hwndParent uintptr + InstallMsgHandler uintptr + InstallMsgHandlerContext uintptr + FileQueue HSPFILEQ + _ uintptr + _ uint32 + driverPath [MAX_PATH]uint16 +} + +func (params *DevInstallParams) DriverPath() string { + return UTF16ToString(params.driverPath[:]) +} + +func (params *DevInstallParams) SetDriverPath(driverPath string) error { + str, err := UTF16FromString(driverPath) + if err != nil { + return err + } + copy(params.driverPath[:], str) + return nil +} + +// DI_FLAGS is SP_DEVINSTALL_PARAMS.Flags values +type DI_FLAGS uint32 + +const ( + // Flags for choosing a device + DI_SHOWOEM DI_FLAGS = 0x00000001 // support Other... button + DI_SHOWCOMPAT DI_FLAGS = 0x00000002 // show compatibility list + DI_SHOWCLASS DI_FLAGS = 0x00000004 // show class list + DI_SHOWALL DI_FLAGS = 0x00000007 // both class & compat list shown + DI_NOVCP DI_FLAGS = 0x00000008 // don't create a new copy queue--use caller-supplied FileQueue + DI_DIDCOMPAT DI_FLAGS = 0x00000010 // Searched for compatible devices + DI_DIDCLASS DI_FLAGS = 0x00000020 // Searched for class devices + DI_AUTOASSIGNRES DI_FLAGS = 0x00000040 // No UI for resources if possible + + // Flags returned by DiInstallDevice to indicate need to reboot/restart + DI_NEEDRESTART DI_FLAGS = 0x00000080 // Reboot required to take effect + DI_NEEDREBOOT DI_FLAGS = 0x00000100 // "" + + // Flags for device installation + DI_NOBROWSE DI_FLAGS = 0x00000200 // no Browse... in InsertDisk + + // Flags set by DiBuildDriverInfoList + DI_MULTMFGS DI_FLAGS = 0x00000400 // Set if multiple manufacturers in class driver list + + // Flag indicates that device is disabled + DI_DISABLED DI_FLAGS = 0x00000800 // Set if device disabled + + // Flags for Device/Class Properties + DI_GENERALPAGE_ADDED DI_FLAGS = 0x00001000 + DI_RESOURCEPAGE_ADDED DI_FLAGS = 0x00002000 + + // Flag to indicate the setting properties for this Device (or class) caused a change so the Dev Mgr UI probably needs to be updated. + DI_PROPERTIES_CHANGE DI_FLAGS = 0x00004000 + + // Flag to indicate that the sorting from the INF file should be used. + DI_INF_IS_SORTED DI_FLAGS = 0x00008000 + + // Flag to indicate that only the the INF specified by SP_DEVINSTALL_PARAMS.DriverPath should be searched. + DI_ENUMSINGLEINF DI_FLAGS = 0x00010000 + + // Flag that prevents ConfigMgr from removing/re-enumerating devices during device + // registration, installation, and deletion. + DI_DONOTCALLCONFIGMG DI_FLAGS = 0x00020000 + + // The following flag can be used to install a device disabled + DI_INSTALLDISABLED DI_FLAGS = 0x00040000 + + // Flag that causes SetupDiBuildDriverInfoList to build a device's compatible driver + // list from its existing class driver list, instead of the normal INF search. + DI_COMPAT_FROM_CLASS DI_FLAGS = 0x00080000 + + // This flag is set if the Class Install params should be used. + DI_CLASSINSTALLPARAMS DI_FLAGS = 0x00100000 + + // This flag is set if the caller of DiCallClassInstaller does NOT want the internal default action performed if the Class installer returns ERROR_DI_DO_DEFAULT. + DI_NODI_DEFAULTACTION DI_FLAGS = 0x00200000 + + // Flags for device installation + DI_QUIETINSTALL DI_FLAGS = 0x00800000 // don't confuse the user with questions or excess info + DI_NOFILECOPY DI_FLAGS = 0x01000000 // No file Copy necessary + DI_FORCECOPY DI_FLAGS = 0x02000000 // Force files to be copied from install path + DI_DRIVERPAGE_ADDED DI_FLAGS = 0x04000000 // Prop provider added Driver page. + DI_USECI_SELECTSTRINGS DI_FLAGS = 0x08000000 // Use Class Installer Provided strings in the Select Device Dlg + DI_OVERRIDE_INFFLAGS DI_FLAGS = 0x10000000 // Override INF flags + DI_PROPS_NOCHANGEUSAGE DI_FLAGS = 0x20000000 // No Enable/Disable in General Props + + DI_NOSELECTICONS DI_FLAGS = 0x40000000 // No small icons in select device dialogs + + DI_NOWRITE_IDS DI_FLAGS = 0x80000000 // Don't write HW & Compat IDs on install +) + +// DI_FLAGSEX is SP_DEVINSTALL_PARAMS.FlagsEx values +type DI_FLAGSEX uint32 + +const ( + DI_FLAGSEX_CI_FAILED DI_FLAGSEX = 0x00000004 // Failed to Load/Call class installer + DI_FLAGSEX_FINISHINSTALL_ACTION DI_FLAGSEX = 0x00000008 // Class/co-installer wants to get a DIF_FINISH_INSTALL action in client context. + DI_FLAGSEX_DIDINFOLIST DI_FLAGSEX = 0x00000010 // Did the Class Info List + DI_FLAGSEX_DIDCOMPATINFO DI_FLAGSEX = 0x00000020 // Did the Compat Info List + DI_FLAGSEX_FILTERCLASSES DI_FLAGSEX = 0x00000040 + DI_FLAGSEX_SETFAILEDINSTALL DI_FLAGSEX = 0x00000080 + DI_FLAGSEX_DEVICECHANGE DI_FLAGSEX = 0x00000100 + DI_FLAGSEX_ALWAYSWRITEIDS DI_FLAGSEX = 0x00000200 + DI_FLAGSEX_PROPCHANGE_PENDING DI_FLAGSEX = 0x00000400 // One or more device property sheets have had changes made to them, and need to have a DIF_PROPERTYCHANGE occur. + DI_FLAGSEX_ALLOWEXCLUDEDDRVS DI_FLAGSEX = 0x00000800 + DI_FLAGSEX_NOUIONQUERYREMOVE DI_FLAGSEX = 0x00001000 + DI_FLAGSEX_USECLASSFORCOMPAT DI_FLAGSEX = 0x00002000 // Use the device's class when building compat drv list. (Ignored if DI_COMPAT_FROM_CLASS flag is specified.) + DI_FLAGSEX_NO_DRVREG_MODIFY DI_FLAGSEX = 0x00008000 // Don't run AddReg and DelReg for device's software (driver) key. + DI_FLAGSEX_IN_SYSTEM_SETUP DI_FLAGSEX = 0x00010000 // Installation is occurring during initial system setup. + DI_FLAGSEX_INET_DRIVER DI_FLAGSEX = 0x00020000 // Driver came from Windows Update + DI_FLAGSEX_APPENDDRIVERLIST DI_FLAGSEX = 0x00040000 // Cause SetupDiBuildDriverInfoList to append a new driver list to an existing list. + DI_FLAGSEX_PREINSTALLBACKUP DI_FLAGSEX = 0x00080000 // not used + DI_FLAGSEX_BACKUPONREPLACE DI_FLAGSEX = 0x00100000 // not used + DI_FLAGSEX_DRIVERLIST_FROM_URL DI_FLAGSEX = 0x00200000 // build driver list from INF(s) retrieved from URL specified in SP_DEVINSTALL_PARAMS.DriverPath (empty string means Windows Update website) + DI_FLAGSEX_EXCLUDE_OLD_INET_DRIVERS DI_FLAGSEX = 0x00800000 // Don't include old Internet drivers when building a driver list. Ignored on Windows Vista and later. + DI_FLAGSEX_POWERPAGE_ADDED DI_FLAGSEX = 0x01000000 // class installer added their own power page + DI_FLAGSEX_FILTERSIMILARDRIVERS DI_FLAGSEX = 0x02000000 // only include similar drivers in class list + DI_FLAGSEX_INSTALLEDDRIVER DI_FLAGSEX = 0x04000000 // only add the installed driver to the class or compat driver list. Used in calls to SetupDiBuildDriverInfoList + DI_FLAGSEX_NO_CLASSLIST_NODE_MERGE DI_FLAGSEX = 0x08000000 // Don't remove identical driver nodes from the class list + DI_FLAGSEX_ALTPLATFORM_DRVSEARCH DI_FLAGSEX = 0x10000000 // Build driver list based on alternate platform information specified in associated file queue + DI_FLAGSEX_RESTART_DEVICE_ONLY DI_FLAGSEX = 0x20000000 // only restart the device drivers are being installed on as opposed to restarting all devices using those drivers. + DI_FLAGSEX_RECURSIVESEARCH DI_FLAGSEX = 0x40000000 // Tell SetupDiBuildDriverInfoList to do a recursive search + DI_FLAGSEX_SEARCH_PUBLISHED_INFS DI_FLAGSEX = 0x80000000 // Tell SetupDiBuildDriverInfoList to do a "published INF" search +) + +// ClassInstallHeader is the first member of any class install parameters structure. It contains the device installation request code that defines the format of the rest of the install parameters structure. +type ClassInstallHeader struct { + size uint32 + InstallFunction DI_FUNCTION +} + +func MakeClassInstallHeader(installFunction DI_FUNCTION) *ClassInstallHeader { + hdr := &ClassInstallHeader{InstallFunction: installFunction} + hdr.size = uint32(unsafe.Sizeof(*hdr)) + return hdr +} + +// DICS_STATE specifies values indicating a change in a device's state +type DICS_STATE uint32 + +const ( + DICS_ENABLE DICS_STATE = 0x00000001 // The device is being enabled. + DICS_DISABLE DICS_STATE = 0x00000002 // The device is being disabled. + DICS_PROPCHANGE DICS_STATE = 0x00000003 // The properties of the device have changed. + DICS_START DICS_STATE = 0x00000004 // The device is being started (if the request is for the currently active hardware profile). + DICS_STOP DICS_STATE = 0x00000005 // The device is being stopped. The driver stack will be unloaded and the CSCONFIGFLAG_DO_NOT_START flag will be set for the device. +) + +// DICS_FLAG specifies the scope of a device property change +type DICS_FLAG uint32 + +const ( + DICS_FLAG_GLOBAL DICS_FLAG = 0x00000001 // make change in all hardware profiles + DICS_FLAG_CONFIGSPECIFIC DICS_FLAG = 0x00000002 // make change in specified profile only + DICS_FLAG_CONFIGGENERAL DICS_FLAG = 0x00000004 // 1 or more hardware profile-specific changes to follow (obsolete) +) + +// PropChangeParams is a structure corresponding to a DIF_PROPERTYCHANGE install function. +type PropChangeParams struct { + ClassInstallHeader ClassInstallHeader + StateChange DICS_STATE + Scope DICS_FLAG + HwProfile uint32 +} + +// DI_REMOVEDEVICE specifies the scope of the device removal +type DI_REMOVEDEVICE uint32 + +const ( + DI_REMOVEDEVICE_GLOBAL DI_REMOVEDEVICE = 0x00000001 // Make this change in all hardware profiles. Remove information about the device from the registry. + DI_REMOVEDEVICE_CONFIGSPECIFIC DI_REMOVEDEVICE = 0x00000002 // Make this change to only the hardware profile specified by HwProfile. this flag only applies to root-enumerated devices. When Windows removes the device from the last hardware profile in which it was configured, Windows performs a global removal. +) + +// RemoveDeviceParams is a structure corresponding to a DIF_REMOVE install function. +type RemoveDeviceParams struct { + ClassInstallHeader ClassInstallHeader + Scope DI_REMOVEDEVICE + HwProfile uint32 +} + +// DrvInfoData is driver information structure (member of a driver info list that may be associated with a particular device instance, or (globally) with a device information set) +type DrvInfoData struct { + size uint32 + DriverType uint32 + _ uintptr + description [LINE_LEN]uint16 + mfgName [LINE_LEN]uint16 + providerName [LINE_LEN]uint16 + DriverDate Filetime + DriverVersion uint64 +} + +func (data *DrvInfoData) Description() string { + return UTF16ToString(data.description[:]) +} + +func (data *DrvInfoData) SetDescription(description string) error { + str, err := UTF16FromString(description) + if err != nil { + return err + } + copy(data.description[:], str) + return nil +} + +func (data *DrvInfoData) MfgName() string { + return UTF16ToString(data.mfgName[:]) +} + +func (data *DrvInfoData) SetMfgName(mfgName string) error { + str, err := UTF16FromString(mfgName) + if err != nil { + return err + } + copy(data.mfgName[:], str) + return nil +} + +func (data *DrvInfoData) ProviderName() string { + return UTF16ToString(data.providerName[:]) +} + +func (data *DrvInfoData) SetProviderName(providerName string) error { + str, err := UTF16FromString(providerName) + if err != nil { + return err + } + copy(data.providerName[:], str) + return nil +} + +// IsNewer method returns true if DrvInfoData date and version is newer than supplied parameters. +func (data *DrvInfoData) IsNewer(driverDate Filetime, driverVersion uint64) bool { + if data.DriverDate.HighDateTime > driverDate.HighDateTime { + return true + } + if data.DriverDate.HighDateTime < driverDate.HighDateTime { + return false + } + + if data.DriverDate.LowDateTime > driverDate.LowDateTime { + return true + } + if data.DriverDate.LowDateTime < driverDate.LowDateTime { + return false + } + + if data.DriverVersion > driverVersion { + return true + } + if data.DriverVersion < driverVersion { + return false + } + + return false +} + +// DrvInfoDetailData is driver information details structure (provides detailed information about a particular driver information structure) +type DrvInfoDetailData struct { + size uint32 // Use unsafeSizeOf method + InfDate Filetime + compatIDsOffset uint32 + compatIDsLength uint32 + _ uintptr + sectionName [LINE_LEN]uint16 + infFileName [MAX_PATH]uint16 + drvDescription [LINE_LEN]uint16 + hardwareID [1]uint16 +} + +func (*DrvInfoDetailData) unsafeSizeOf() uint32 { + if unsafe.Sizeof(uintptr(0)) == 4 { + // Windows declares this with pshpack1.h + return uint32(unsafe.Offsetof(DrvInfoDetailData{}.hardwareID) + unsafe.Sizeof(DrvInfoDetailData{}.hardwareID)) + } + return uint32(unsafe.Sizeof(DrvInfoDetailData{})) +} + +func (data *DrvInfoDetailData) SectionName() string { + return UTF16ToString(data.sectionName[:]) +} + +func (data *DrvInfoDetailData) InfFileName() string { + return UTF16ToString(data.infFileName[:]) +} + +func (data *DrvInfoDetailData) DrvDescription() string { + return UTF16ToString(data.drvDescription[:]) +} + +func (data *DrvInfoDetailData) HardwareID() string { + if data.compatIDsOffset > 1 { + bufW := data.getBuf() + return UTF16ToString(bufW[:wcslen(bufW)]) + } + + return "" +} + +func (data *DrvInfoDetailData) CompatIDs() []string { + a := make([]string, 0) + + if data.compatIDsLength > 0 { + bufW := data.getBuf() + bufW = bufW[data.compatIDsOffset : data.compatIDsOffset+data.compatIDsLength] + for i := 0; i < len(bufW); { + j := i + wcslen(bufW[i:]) + if i < j { + a = append(a, UTF16ToString(bufW[i:j])) + } + i = j + 1 + } + } + + return a +} + +func (data *DrvInfoDetailData) getBuf() []uint16 { + len := (data.size - uint32(unsafe.Offsetof(data.hardwareID))) / 2 + sl := struct { + addr *uint16 + len int + cap int + }{&data.hardwareID[0], int(len), int(len)} + return *(*[]uint16)(unsafe.Pointer(&sl)) +} + +// IsCompatible method tests if given hardware ID matches the driver or is listed on the compatible ID list. +func (data *DrvInfoDetailData) IsCompatible(hwid string) bool { + hwidLC := strings.ToLower(hwid) + if strings.ToLower(data.HardwareID()) == hwidLC { + return true + } + a := data.CompatIDs() + for i := range a { + if strings.ToLower(a[i]) == hwidLC { + return true + } + } + + return false +} + +// DICD flags control SetupDiCreateDeviceInfo +type DICD uint32 + +const ( + DICD_GENERATE_ID DICD = 0x00000001 + DICD_INHERIT_CLASSDRVS DICD = 0x00000002 +) + +// SUOI flags control SetupUninstallOEMInf +type SUOI uint32 + +const ( + SUOI_FORCEDELETE SUOI = 0x0001 +) + +// SPDIT flags to distinguish between class drivers and +// device drivers. (Passed in 'DriverType' parameter of +// driver information list APIs) +type SPDIT uint32 + +const ( + SPDIT_NODRIVER SPDIT = 0x00000000 + SPDIT_CLASSDRIVER SPDIT = 0x00000001 + SPDIT_COMPATDRIVER SPDIT = 0x00000002 +) + +// DIGCF flags control what is included in the device information set built by SetupDiGetClassDevs +type DIGCF uint32 + +const ( + DIGCF_DEFAULT DIGCF = 0x00000001 // only valid with DIGCF_DEVICEINTERFACE + DIGCF_PRESENT DIGCF = 0x00000002 + DIGCF_ALLCLASSES DIGCF = 0x00000004 + DIGCF_PROFILE DIGCF = 0x00000008 + DIGCF_DEVICEINTERFACE DIGCF = 0x00000010 +) + +// DIREG specifies values for SetupDiCreateDevRegKey, SetupDiOpenDevRegKey, and SetupDiDeleteDevRegKey. +type DIREG uint32 + +const ( + DIREG_DEV DIREG = 0x00000001 // Open/Create/Delete device key + DIREG_DRV DIREG = 0x00000002 // Open/Create/Delete driver key + DIREG_BOTH DIREG = 0x00000004 // Delete both driver and Device key +) + +// SPDRP specifies device registry property codes +// (Codes marked as read-only (R) may only be used for +// SetupDiGetDeviceRegistryProperty) +// +// These values should cover the same set of registry properties +// as defined by the CM_DRP codes in cfgmgr32.h. +// +// Note that SPDRP codes are zero based while CM_DRP codes are one based! +type SPDRP uint32 + +const ( + SPDRP_DEVICEDESC SPDRP = 0x00000000 // DeviceDesc (R/W) + SPDRP_HARDWAREID SPDRP = 0x00000001 // HardwareID (R/W) + SPDRP_COMPATIBLEIDS SPDRP = 0x00000002 // CompatibleIDs (R/W) + SPDRP_SERVICE SPDRP = 0x00000004 // Service (R/W) + SPDRP_CLASS SPDRP = 0x00000007 // Class (R--tied to ClassGUID) + SPDRP_CLASSGUID SPDRP = 0x00000008 // ClassGUID (R/W) + SPDRP_DRIVER SPDRP = 0x00000009 // Driver (R/W) + SPDRP_CONFIGFLAGS SPDRP = 0x0000000A // ConfigFlags (R/W) + SPDRP_MFG SPDRP = 0x0000000B // Mfg (R/W) + SPDRP_FRIENDLYNAME SPDRP = 0x0000000C // FriendlyName (R/W) + SPDRP_LOCATION_INFORMATION SPDRP = 0x0000000D // LocationInformation (R/W) + SPDRP_PHYSICAL_DEVICE_OBJECT_NAME SPDRP = 0x0000000E // PhysicalDeviceObjectName (R) + SPDRP_CAPABILITIES SPDRP = 0x0000000F // Capabilities (R) + SPDRP_UI_NUMBER SPDRP = 0x00000010 // UiNumber (R) + SPDRP_UPPERFILTERS SPDRP = 0x00000011 // UpperFilters (R/W) + SPDRP_LOWERFILTERS SPDRP = 0x00000012 // LowerFilters (R/W) + SPDRP_BUSTYPEGUID SPDRP = 0x00000013 // BusTypeGUID (R) + SPDRP_LEGACYBUSTYPE SPDRP = 0x00000014 // LegacyBusType (R) + SPDRP_BUSNUMBER SPDRP = 0x00000015 // BusNumber (R) + SPDRP_ENUMERATOR_NAME SPDRP = 0x00000016 // Enumerator Name (R) + SPDRP_SECURITY SPDRP = 0x00000017 // Security (R/W, binary form) + SPDRP_SECURITY_SDS SPDRP = 0x00000018 // Security (W, SDS form) + SPDRP_DEVTYPE SPDRP = 0x00000019 // Device Type (R/W) + SPDRP_EXCLUSIVE SPDRP = 0x0000001A // Device is exclusive-access (R/W) + SPDRP_CHARACTERISTICS SPDRP = 0x0000001B // Device Characteristics (R/W) + SPDRP_ADDRESS SPDRP = 0x0000001C // Device Address (R) + SPDRP_UI_NUMBER_DESC_FORMAT SPDRP = 0x0000001D // UiNumberDescFormat (R/W) + SPDRP_DEVICE_POWER_DATA SPDRP = 0x0000001E // Device Power Data (R) + SPDRP_REMOVAL_POLICY SPDRP = 0x0000001F // Removal Policy (R) + SPDRP_REMOVAL_POLICY_HW_DEFAULT SPDRP = 0x00000020 // Hardware Removal Policy (R) + SPDRP_REMOVAL_POLICY_OVERRIDE SPDRP = 0x00000021 // Removal Policy Override (RW) + SPDRP_INSTALL_STATE SPDRP = 0x00000022 // Device Install State (R) + SPDRP_LOCATION_PATHS SPDRP = 0x00000023 // Device Location Paths (R) + SPDRP_BASE_CONTAINERID SPDRP = 0x00000024 // Base ContainerID (R) + + SPDRP_MAXIMUM_PROPERTY SPDRP = 0x00000025 // Upper bound on ordinals +) + +// DEVPROPTYPE represents the property-data-type identifier that specifies the +// data type of a device property value in the unified device property model. +type DEVPROPTYPE uint32 + +const ( + DEVPROP_TYPEMOD_ARRAY DEVPROPTYPE = 0x00001000 + DEVPROP_TYPEMOD_LIST DEVPROPTYPE = 0x00002000 + + DEVPROP_TYPE_EMPTY DEVPROPTYPE = 0x00000000 + DEVPROP_TYPE_NULL DEVPROPTYPE = 0x00000001 + DEVPROP_TYPE_SBYTE DEVPROPTYPE = 0x00000002 + DEVPROP_TYPE_BYTE DEVPROPTYPE = 0x00000003 + DEVPROP_TYPE_INT16 DEVPROPTYPE = 0x00000004 + DEVPROP_TYPE_UINT16 DEVPROPTYPE = 0x00000005 + DEVPROP_TYPE_INT32 DEVPROPTYPE = 0x00000006 + DEVPROP_TYPE_UINT32 DEVPROPTYPE = 0x00000007 + DEVPROP_TYPE_INT64 DEVPROPTYPE = 0x00000008 + DEVPROP_TYPE_UINT64 DEVPROPTYPE = 0x00000009 + DEVPROP_TYPE_FLOAT DEVPROPTYPE = 0x0000000A + DEVPROP_TYPE_DOUBLE DEVPROPTYPE = 0x0000000B + DEVPROP_TYPE_DECIMAL DEVPROPTYPE = 0x0000000C + DEVPROP_TYPE_GUID DEVPROPTYPE = 0x0000000D + DEVPROP_TYPE_CURRENCY DEVPROPTYPE = 0x0000000E + DEVPROP_TYPE_DATE DEVPROPTYPE = 0x0000000F + DEVPROP_TYPE_FILETIME DEVPROPTYPE = 0x00000010 + DEVPROP_TYPE_BOOLEAN DEVPROPTYPE = 0x00000011 + DEVPROP_TYPE_STRING DEVPROPTYPE = 0x00000012 + DEVPROP_TYPE_STRING_LIST DEVPROPTYPE = DEVPROP_TYPE_STRING | DEVPROP_TYPEMOD_LIST + DEVPROP_TYPE_SECURITY_DESCRIPTOR DEVPROPTYPE = 0x00000013 + DEVPROP_TYPE_SECURITY_DESCRIPTOR_STRING DEVPROPTYPE = 0x00000014 + DEVPROP_TYPE_DEVPROPKEY DEVPROPTYPE = 0x00000015 + DEVPROP_TYPE_DEVPROPTYPE DEVPROPTYPE = 0x00000016 + DEVPROP_TYPE_BINARY DEVPROPTYPE = DEVPROP_TYPE_BYTE | DEVPROP_TYPEMOD_ARRAY + DEVPROP_TYPE_ERROR DEVPROPTYPE = 0x00000017 + DEVPROP_TYPE_NTSTATUS DEVPROPTYPE = 0x00000018 + DEVPROP_TYPE_STRING_INDIRECT DEVPROPTYPE = 0x00000019 + + MAX_DEVPROP_TYPE DEVPROPTYPE = 0x00000019 + MAX_DEVPROP_TYPEMOD DEVPROPTYPE = 0x00002000 + + DEVPROP_MASK_TYPE DEVPROPTYPE = 0x00000FFF + DEVPROP_MASK_TYPEMOD DEVPROPTYPE = 0x0000F000 +) + +// DEVPROPGUID specifies a property category. +type DEVPROPGUID GUID + +// DEVPROPID uniquely identifies the property within the property category. +type DEVPROPID uint32 + +const DEVPROPID_FIRST_USABLE DEVPROPID = 2 + +// DEVPROPKEY represents a device property key for a device property in the +// unified device property model. +type DEVPROPKEY struct { + FmtID DEVPROPGUID + PID DEVPROPID +} + +// CONFIGRET is a return value or error code from cfgmgr32 APIs +type CONFIGRET uint32 + +func (ret CONFIGRET) Error() string { + if win32Error, ok := ret.Unwrap().(Errno); ok { + return fmt.Sprintf("%s (CfgMgr error: 0x%08x)", win32Error.Error(), uint32(ret)) + } + return fmt.Sprintf("CfgMgr error: 0x%08x", uint32(ret)) +} + +func (ret CONFIGRET) Win32Error(defaultError Errno) Errno { + return cm_MapCrToWin32Err(ret, defaultError) +} + +func (ret CONFIGRET) Unwrap() error { + const noMatch = Errno(^uintptr(0)) + win32Error := ret.Win32Error(noMatch) + if win32Error == noMatch { + return nil + } + return win32Error +} + +const ( + CR_SUCCESS CONFIGRET = 0x00000000 + CR_DEFAULT CONFIGRET = 0x00000001 + CR_OUT_OF_MEMORY CONFIGRET = 0x00000002 + CR_INVALID_POINTER CONFIGRET = 0x00000003 + CR_INVALID_FLAG CONFIGRET = 0x00000004 + CR_INVALID_DEVNODE CONFIGRET = 0x00000005 + CR_INVALID_DEVINST = CR_INVALID_DEVNODE + CR_INVALID_RES_DES CONFIGRET = 0x00000006 + CR_INVALID_LOG_CONF CONFIGRET = 0x00000007 + CR_INVALID_ARBITRATOR CONFIGRET = 0x00000008 + CR_INVALID_NODELIST CONFIGRET = 0x00000009 + CR_DEVNODE_HAS_REQS CONFIGRET = 0x0000000A + CR_DEVINST_HAS_REQS = CR_DEVNODE_HAS_REQS + CR_INVALID_RESOURCEID CONFIGRET = 0x0000000B + CR_DLVXD_NOT_FOUND CONFIGRET = 0x0000000C + CR_NO_SUCH_DEVNODE CONFIGRET = 0x0000000D + CR_NO_SUCH_DEVINST = CR_NO_SUCH_DEVNODE + CR_NO_MORE_LOG_CONF CONFIGRET = 0x0000000E + CR_NO_MORE_RES_DES CONFIGRET = 0x0000000F + CR_ALREADY_SUCH_DEVNODE CONFIGRET = 0x00000010 + CR_ALREADY_SUCH_DEVINST = CR_ALREADY_SUCH_DEVNODE + CR_INVALID_RANGE_LIST CONFIGRET = 0x00000011 + CR_INVALID_RANGE CONFIGRET = 0x00000012 + CR_FAILURE CONFIGRET = 0x00000013 + CR_NO_SUCH_LOGICAL_DEV CONFIGRET = 0x00000014 + CR_CREATE_BLOCKED CONFIGRET = 0x00000015 + CR_NOT_SYSTEM_VM CONFIGRET = 0x00000016 + CR_REMOVE_VETOED CONFIGRET = 0x00000017 + CR_APM_VETOED CONFIGRET = 0x00000018 + CR_INVALID_LOAD_TYPE CONFIGRET = 0x00000019 + CR_BUFFER_SMALL CONFIGRET = 0x0000001A + CR_NO_ARBITRATOR CONFIGRET = 0x0000001B + CR_NO_REGISTRY_HANDLE CONFIGRET = 0x0000001C + CR_REGISTRY_ERROR CONFIGRET = 0x0000001D + CR_INVALID_DEVICE_ID CONFIGRET = 0x0000001E + CR_INVALID_DATA CONFIGRET = 0x0000001F + CR_INVALID_API CONFIGRET = 0x00000020 + CR_DEVLOADER_NOT_READY CONFIGRET = 0x00000021 + CR_NEED_RESTART CONFIGRET = 0x00000022 + CR_NO_MORE_HW_PROFILES CONFIGRET = 0x00000023 + CR_DEVICE_NOT_THERE CONFIGRET = 0x00000024 + CR_NO_SUCH_VALUE CONFIGRET = 0x00000025 + CR_WRONG_TYPE CONFIGRET = 0x00000026 + CR_INVALID_PRIORITY CONFIGRET = 0x00000027 + CR_NOT_DISABLEABLE CONFIGRET = 0x00000028 + CR_FREE_RESOURCES CONFIGRET = 0x00000029 + CR_QUERY_VETOED CONFIGRET = 0x0000002A + CR_CANT_SHARE_IRQ CONFIGRET = 0x0000002B + CR_NO_DEPENDENT CONFIGRET = 0x0000002C + CR_SAME_RESOURCES CONFIGRET = 0x0000002D + CR_NO_SUCH_REGISTRY_KEY CONFIGRET = 0x0000002E + CR_INVALID_MACHINENAME CONFIGRET = 0x0000002F + CR_REMOTE_COMM_FAILURE CONFIGRET = 0x00000030 + CR_MACHINE_UNAVAILABLE CONFIGRET = 0x00000031 + CR_NO_CM_SERVICES CONFIGRET = 0x00000032 + CR_ACCESS_DENIED CONFIGRET = 0x00000033 + CR_CALL_NOT_IMPLEMENTED CONFIGRET = 0x00000034 + CR_INVALID_PROPERTY CONFIGRET = 0x00000035 + CR_DEVICE_INTERFACE_ACTIVE CONFIGRET = 0x00000036 + CR_NO_SUCH_DEVICE_INTERFACE CONFIGRET = 0x00000037 + CR_INVALID_REFERENCE_STRING CONFIGRET = 0x00000038 + CR_INVALID_CONFLICT_LIST CONFIGRET = 0x00000039 + CR_INVALID_INDEX CONFIGRET = 0x0000003A + CR_INVALID_STRUCTURE_SIZE CONFIGRET = 0x0000003B + NUM_CR_RESULTS CONFIGRET = 0x0000003C +) + +const ( + CM_GET_DEVICE_INTERFACE_LIST_PRESENT = 0 // only currently 'live' device interfaces + CM_GET_DEVICE_INTERFACE_LIST_ALL_DEVICES = 1 // all registered device interfaces, live or not +) + +const ( + DN_ROOT_ENUMERATED = 0x00000001 // Was enumerated by ROOT + DN_DRIVER_LOADED = 0x00000002 // Has Register_Device_Driver + DN_ENUM_LOADED = 0x00000004 // Has Register_Enumerator + DN_STARTED = 0x00000008 // Is currently configured + DN_MANUAL = 0x00000010 // Manually installed + DN_NEED_TO_ENUM = 0x00000020 // May need reenumeration + DN_NOT_FIRST_TIME = 0x00000040 // Has received a config + DN_HARDWARE_ENUM = 0x00000080 // Enum generates hardware ID + DN_LIAR = 0x00000100 // Lied about can reconfig once + DN_HAS_MARK = 0x00000200 // Not CM_Create_DevInst lately + DN_HAS_PROBLEM = 0x00000400 // Need device installer + DN_FILTERED = 0x00000800 // Is filtered + DN_MOVED = 0x00001000 // Has been moved + DN_DISABLEABLE = 0x00002000 // Can be disabled + DN_REMOVABLE = 0x00004000 // Can be removed + DN_PRIVATE_PROBLEM = 0x00008000 // Has a private problem + DN_MF_PARENT = 0x00010000 // Multi function parent + DN_MF_CHILD = 0x00020000 // Multi function child + DN_WILL_BE_REMOVED = 0x00040000 // DevInst is being removed + DN_NOT_FIRST_TIMEE = 0x00080000 // Has received a config enumerate + DN_STOP_FREE_RES = 0x00100000 // When child is stopped, free resources + DN_REBAL_CANDIDATE = 0x00200000 // Don't skip during rebalance + DN_BAD_PARTIAL = 0x00400000 // This devnode's log_confs do not have same resources + DN_NT_ENUMERATOR = 0x00800000 // This devnode's is an NT enumerator + DN_NT_DRIVER = 0x01000000 // This devnode's is an NT driver + DN_NEEDS_LOCKING = 0x02000000 // Devnode need lock resume processing + DN_ARM_WAKEUP = 0x04000000 // Devnode can be the wakeup device + DN_APM_ENUMERATOR = 0x08000000 // APM aware enumerator + DN_APM_DRIVER = 0x10000000 // APM aware driver + DN_SILENT_INSTALL = 0x20000000 // Silent install + DN_NO_SHOW_IN_DM = 0x40000000 // No show in device manager + DN_BOOT_LOG_PROB = 0x80000000 // Had a problem during preassignment of boot log conf + DN_NEED_RESTART = DN_LIAR // System needs to be restarted for this Devnode to work properly + DN_DRIVER_BLOCKED = DN_NOT_FIRST_TIME // One or more drivers are blocked from loading for this Devnode + DN_LEGACY_DRIVER = DN_MOVED // This device is using a legacy driver + DN_CHILD_WITH_INVALID_ID = DN_HAS_MARK // One or more children have invalid IDs + DN_DEVICE_DISCONNECTED = DN_NEEDS_LOCKING // The function driver for a device reported that the device is not connected. Typically this means a wireless device is out of range. + DN_QUERY_REMOVE_PENDING = DN_MF_PARENT // Device is part of a set of related devices collectively pending query-removal + DN_QUERY_REMOVE_ACTIVE = DN_MF_CHILD // Device is actively engaged in a query-remove IRP + DN_CHANGEABLE_FLAGS = DN_NOT_FIRST_TIME | DN_HARDWARE_ENUM | DN_HAS_MARK | DN_DISABLEABLE | DN_REMOVABLE | DN_MF_CHILD | DN_MF_PARENT | DN_NOT_FIRST_TIMEE | DN_STOP_FREE_RES | DN_REBAL_CANDIDATE | DN_NT_ENUMERATOR | DN_NT_DRIVER | DN_SILENT_INSTALL | DN_NO_SHOW_IN_DM +) + +//sys setupDiCreateDeviceInfoListEx(classGUID *GUID, hwndParent uintptr, machineName *uint16, reserved uintptr) (handle DevInfo, err error) [failretval==DevInfo(InvalidHandle)] = setupapi.SetupDiCreateDeviceInfoListExW + +// SetupDiCreateDeviceInfoListEx function creates an empty device information set on a remote or a local computer and optionally associates the set with a device setup class. +func SetupDiCreateDeviceInfoListEx(classGUID *GUID, hwndParent uintptr, machineName string) (deviceInfoSet DevInfo, err error) { + var machineNameUTF16 *uint16 + if machineName != "" { + machineNameUTF16, err = UTF16PtrFromString(machineName) + if err != nil { + return + } + } + return setupDiCreateDeviceInfoListEx(classGUID, hwndParent, machineNameUTF16, 0) +} + +//sys setupDiGetDeviceInfoListDetail(deviceInfoSet DevInfo, deviceInfoSetDetailData *DevInfoListDetailData) (err error) = setupapi.SetupDiGetDeviceInfoListDetailW + +// SetupDiGetDeviceInfoListDetail function retrieves information associated with a device information set including the class GUID, remote computer handle, and remote computer name. +func SetupDiGetDeviceInfoListDetail(deviceInfoSet DevInfo) (deviceInfoSetDetailData *DevInfoListDetailData, err error) { + data := &DevInfoListDetailData{} + data.size = data.unsafeSizeOf() + + return data, setupDiGetDeviceInfoListDetail(deviceInfoSet, data) +} + +// DeviceInfoListDetail method retrieves information associated with a device information set including the class GUID, remote computer handle, and remote computer name. +func (deviceInfoSet DevInfo) DeviceInfoListDetail() (*DevInfoListDetailData, error) { + return SetupDiGetDeviceInfoListDetail(deviceInfoSet) +} + +//sys setupDiCreateDeviceInfo(deviceInfoSet DevInfo, DeviceName *uint16, classGUID *GUID, DeviceDescription *uint16, hwndParent uintptr, CreationFlags DICD, deviceInfoData *DevInfoData) (err error) = setupapi.SetupDiCreateDeviceInfoW + +// SetupDiCreateDeviceInfo function creates a new device information element and adds it as a new member to the specified device information set. +func SetupDiCreateDeviceInfo(deviceInfoSet DevInfo, deviceName string, classGUID *GUID, deviceDescription string, hwndParent uintptr, creationFlags DICD) (deviceInfoData *DevInfoData, err error) { + deviceNameUTF16, err := UTF16PtrFromString(deviceName) + if err != nil { + return + } + + var deviceDescriptionUTF16 *uint16 + if deviceDescription != "" { + deviceDescriptionUTF16, err = UTF16PtrFromString(deviceDescription) + if err != nil { + return + } + } + + data := &DevInfoData{} + data.size = uint32(unsafe.Sizeof(*data)) + + return data, setupDiCreateDeviceInfo(deviceInfoSet, deviceNameUTF16, classGUID, deviceDescriptionUTF16, hwndParent, creationFlags, data) +} + +// CreateDeviceInfo method creates a new device information element and adds it as a new member to the specified device information set. +func (deviceInfoSet DevInfo) CreateDeviceInfo(deviceName string, classGUID *GUID, deviceDescription string, hwndParent uintptr, creationFlags DICD) (*DevInfoData, error) { + return SetupDiCreateDeviceInfo(deviceInfoSet, deviceName, classGUID, deviceDescription, hwndParent, creationFlags) +} + +//sys setupDiEnumDeviceInfo(deviceInfoSet DevInfo, memberIndex uint32, deviceInfoData *DevInfoData) (err error) = setupapi.SetupDiEnumDeviceInfo + +// SetupDiEnumDeviceInfo function returns a DevInfoData structure that specifies a device information element in a device information set. +func SetupDiEnumDeviceInfo(deviceInfoSet DevInfo, memberIndex int) (*DevInfoData, error) { + data := &DevInfoData{} + data.size = uint32(unsafe.Sizeof(*data)) + + return data, setupDiEnumDeviceInfo(deviceInfoSet, uint32(memberIndex), data) +} + +// EnumDeviceInfo method returns a DevInfoData structure that specifies a device information element in a device information set. +func (deviceInfoSet DevInfo) EnumDeviceInfo(memberIndex int) (*DevInfoData, error) { + return SetupDiEnumDeviceInfo(deviceInfoSet, memberIndex) +} + +// SetupDiDestroyDeviceInfoList function deletes a device information set and frees all associated memory. +//sys SetupDiDestroyDeviceInfoList(deviceInfoSet DevInfo) (err error) = setupapi.SetupDiDestroyDeviceInfoList + +// Close method deletes a device information set and frees all associated memory. +func (deviceInfoSet DevInfo) Close() error { + return SetupDiDestroyDeviceInfoList(deviceInfoSet) +} + +//sys SetupDiBuildDriverInfoList(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT) (err error) = setupapi.SetupDiBuildDriverInfoList + +// BuildDriverInfoList method builds a list of drivers that is associated with a specific device or with the global class driver list for a device information set. +func (deviceInfoSet DevInfo) BuildDriverInfoList(deviceInfoData *DevInfoData, driverType SPDIT) error { + return SetupDiBuildDriverInfoList(deviceInfoSet, deviceInfoData, driverType) +} + +//sys SetupDiCancelDriverInfoSearch(deviceInfoSet DevInfo) (err error) = setupapi.SetupDiCancelDriverInfoSearch + +// CancelDriverInfoSearch method cancels a driver list search that is currently in progress in a different thread. +func (deviceInfoSet DevInfo) CancelDriverInfoSearch() error { + return SetupDiCancelDriverInfoSearch(deviceInfoSet) +} + +//sys setupDiEnumDriverInfo(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT, memberIndex uint32, driverInfoData *DrvInfoData) (err error) = setupapi.SetupDiEnumDriverInfoW + +// SetupDiEnumDriverInfo function enumerates the members of a driver list. +func SetupDiEnumDriverInfo(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT, memberIndex int) (*DrvInfoData, error) { + data := &DrvInfoData{} + data.size = uint32(unsafe.Sizeof(*data)) + + return data, setupDiEnumDriverInfo(deviceInfoSet, deviceInfoData, driverType, uint32(memberIndex), data) +} + +// EnumDriverInfo method enumerates the members of a driver list. +func (deviceInfoSet DevInfo) EnumDriverInfo(deviceInfoData *DevInfoData, driverType SPDIT, memberIndex int) (*DrvInfoData, error) { + return SetupDiEnumDriverInfo(deviceInfoSet, deviceInfoData, driverType, memberIndex) +} + +//sys setupDiGetSelectedDriver(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData) (err error) = setupapi.SetupDiGetSelectedDriverW + +// SetupDiGetSelectedDriver function retrieves the selected driver for a device information set or a particular device information element. +func SetupDiGetSelectedDriver(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (*DrvInfoData, error) { + data := &DrvInfoData{} + data.size = uint32(unsafe.Sizeof(*data)) + + return data, setupDiGetSelectedDriver(deviceInfoSet, deviceInfoData, data) +} + +// SelectedDriver method retrieves the selected driver for a device information set or a particular device information element. +func (deviceInfoSet DevInfo) SelectedDriver(deviceInfoData *DevInfoData) (*DrvInfoData, error) { + return SetupDiGetSelectedDriver(deviceInfoSet, deviceInfoData) +} + +//sys SetupDiSetSelectedDriver(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData) (err error) = setupapi.SetupDiSetSelectedDriverW + +// SetSelectedDriver method sets, or resets, the selected driver for a device information element or the selected class driver for a device information set. +func (deviceInfoSet DevInfo) SetSelectedDriver(deviceInfoData *DevInfoData, driverInfoData *DrvInfoData) error { + return SetupDiSetSelectedDriver(deviceInfoSet, deviceInfoData, driverInfoData) +} + +//sys setupDiGetDriverInfoDetail(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData, driverInfoDetailData *DrvInfoDetailData, driverInfoDetailDataSize uint32, requiredSize *uint32) (err error) = setupapi.SetupDiGetDriverInfoDetailW + +// SetupDiGetDriverInfoDetail function retrieves driver information detail for a device information set or a particular device information element in the device information set. +func SetupDiGetDriverInfoDetail(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData) (*DrvInfoDetailData, error) { + reqSize := uint32(2048) + for { + buf := make([]byte, reqSize) + data := (*DrvInfoDetailData)(unsafe.Pointer(&buf[0])) + data.size = data.unsafeSizeOf() + err := setupDiGetDriverInfoDetail(deviceInfoSet, deviceInfoData, driverInfoData, data, uint32(len(buf)), &reqSize) + if err == ERROR_INSUFFICIENT_BUFFER { + continue + } + if err != nil { + return nil, err + } + data.size = reqSize + return data, nil + } +} + +// DriverInfoDetail method retrieves driver information detail for a device information set or a particular device information element in the device information set. +func (deviceInfoSet DevInfo) DriverInfoDetail(deviceInfoData *DevInfoData, driverInfoData *DrvInfoData) (*DrvInfoDetailData, error) { + return SetupDiGetDriverInfoDetail(deviceInfoSet, deviceInfoData, driverInfoData) +} + +//sys SetupDiDestroyDriverInfoList(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT) (err error) = setupapi.SetupDiDestroyDriverInfoList + +// DestroyDriverInfoList method deletes a driver list. +func (deviceInfoSet DevInfo) DestroyDriverInfoList(deviceInfoData *DevInfoData, driverType SPDIT) error { + return SetupDiDestroyDriverInfoList(deviceInfoSet, deviceInfoData, driverType) +} + +//sys setupDiGetClassDevsEx(classGUID *GUID, Enumerator *uint16, hwndParent uintptr, Flags DIGCF, deviceInfoSet DevInfo, machineName *uint16, reserved uintptr) (handle DevInfo, err error) [failretval==DevInfo(InvalidHandle)] = setupapi.SetupDiGetClassDevsExW + +// SetupDiGetClassDevsEx function returns a handle to a device information set that contains requested device information elements for a local or a remote computer. +func SetupDiGetClassDevsEx(classGUID *GUID, enumerator string, hwndParent uintptr, flags DIGCF, deviceInfoSet DevInfo, machineName string) (handle DevInfo, err error) { + var enumeratorUTF16 *uint16 + if enumerator != "" { + enumeratorUTF16, err = UTF16PtrFromString(enumerator) + if err != nil { + return + } + } + var machineNameUTF16 *uint16 + if machineName != "" { + machineNameUTF16, err = UTF16PtrFromString(machineName) + if err != nil { + return + } + } + return setupDiGetClassDevsEx(classGUID, enumeratorUTF16, hwndParent, flags, deviceInfoSet, machineNameUTF16, 0) +} + +// SetupDiCallClassInstaller function calls the appropriate class installer, and any registered co-installers, with the specified installation request (DIF code). +//sys SetupDiCallClassInstaller(installFunction DI_FUNCTION, deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) = setupapi.SetupDiCallClassInstaller + +// CallClassInstaller member calls the appropriate class installer, and any registered co-installers, with the specified installation request (DIF code). +func (deviceInfoSet DevInfo) CallClassInstaller(installFunction DI_FUNCTION, deviceInfoData *DevInfoData) error { + return SetupDiCallClassInstaller(installFunction, deviceInfoSet, deviceInfoData) +} + +// SetupDiOpenDevRegKey function opens a registry key for device-specific configuration information. +//sys SetupDiOpenDevRegKey(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, Scope DICS_FLAG, HwProfile uint32, KeyType DIREG, samDesired uint32) (key Handle, err error) [failretval==InvalidHandle] = setupapi.SetupDiOpenDevRegKey + +// OpenDevRegKey method opens a registry key for device-specific configuration information. +func (deviceInfoSet DevInfo) OpenDevRegKey(DeviceInfoData *DevInfoData, Scope DICS_FLAG, HwProfile uint32, KeyType DIREG, samDesired uint32) (Handle, error) { + return SetupDiOpenDevRegKey(deviceInfoSet, DeviceInfoData, Scope, HwProfile, KeyType, samDesired) +} + +//sys setupDiGetDeviceProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, propertyKey *DEVPROPKEY, propertyType *DEVPROPTYPE, propertyBuffer *byte, propertyBufferSize uint32, requiredSize *uint32, flags uint32) (err error) = setupapi.SetupDiGetDevicePropertyW + +// SetupDiGetDeviceProperty function retrieves a specified device instance property. +func SetupDiGetDeviceProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, propertyKey *DEVPROPKEY) (value interface{}, err error) { + reqSize := uint32(256) + for { + var dataType DEVPROPTYPE + buf := make([]byte, reqSize) + err = setupDiGetDeviceProperty(deviceInfoSet, deviceInfoData, propertyKey, &dataType, &buf[0], uint32(len(buf)), &reqSize, 0) + if err == ERROR_INSUFFICIENT_BUFFER { + continue + } + if err != nil { + return + } + switch dataType { + case DEVPROP_TYPE_STRING: + ret := UTF16ToString(bufToUTF16(buf)) + runtime.KeepAlive(buf) + return ret, nil + } + return nil, errors.New("unimplemented property type") + } +} + +//sys setupDiGetDeviceRegistryProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, property SPDRP, propertyRegDataType *uint32, propertyBuffer *byte, propertyBufferSize uint32, requiredSize *uint32) (err error) = setupapi.SetupDiGetDeviceRegistryPropertyW + +// SetupDiGetDeviceRegistryProperty function retrieves a specified Plug and Play device property. +func SetupDiGetDeviceRegistryProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, property SPDRP) (value interface{}, err error) { + reqSize := uint32(256) + for { + var dataType uint32 + buf := make([]byte, reqSize) + err = setupDiGetDeviceRegistryProperty(deviceInfoSet, deviceInfoData, property, &dataType, &buf[0], uint32(len(buf)), &reqSize) + if err == ERROR_INSUFFICIENT_BUFFER { + continue + } + if err != nil { + return + } + return getRegistryValue(buf[:reqSize], dataType) + } +} + +func getRegistryValue(buf []byte, dataType uint32) (interface{}, error) { + switch dataType { + case REG_SZ: + ret := UTF16ToString(bufToUTF16(buf)) + runtime.KeepAlive(buf) + return ret, nil + case REG_EXPAND_SZ: + value := UTF16ToString(bufToUTF16(buf)) + if value == "" { + return "", nil + } + p, err := syscall.UTF16PtrFromString(value) + if err != nil { + return "", err + } + ret := make([]uint16, 100) + for { + n, err := ExpandEnvironmentStrings(p, &ret[0], uint32(len(ret))) + if err != nil { + return "", err + } + if n <= uint32(len(ret)) { + return UTF16ToString(ret[:n]), nil + } + ret = make([]uint16, n) + } + case REG_BINARY: + return buf, nil + case REG_DWORD_LITTLE_ENDIAN: + return binary.LittleEndian.Uint32(buf), nil + case REG_DWORD_BIG_ENDIAN: + return binary.BigEndian.Uint32(buf), nil + case REG_MULTI_SZ: + bufW := bufToUTF16(buf) + a := []string{} + for i := 0; i < len(bufW); { + j := i + wcslen(bufW[i:]) + if i < j { + a = append(a, UTF16ToString(bufW[i:j])) + } + i = j + 1 + } + runtime.KeepAlive(buf) + return a, nil + case REG_QWORD_LITTLE_ENDIAN: + return binary.LittleEndian.Uint64(buf), nil + default: + return nil, fmt.Errorf("Unsupported registry value type: %v", dataType) + } +} + +// bufToUTF16 function reinterprets []byte buffer as []uint16 +func bufToUTF16(buf []byte) []uint16 { + sl := struct { + addr *uint16 + len int + cap int + }{(*uint16)(unsafe.Pointer(&buf[0])), len(buf) / 2, cap(buf) / 2} + return *(*[]uint16)(unsafe.Pointer(&sl)) +} + +// utf16ToBuf function reinterprets []uint16 as []byte +func utf16ToBuf(buf []uint16) []byte { + sl := struct { + addr *byte + len int + cap int + }{(*byte)(unsafe.Pointer(&buf[0])), len(buf) * 2, cap(buf) * 2} + return *(*[]byte)(unsafe.Pointer(&sl)) +} + +func wcslen(str []uint16) int { + for i := 0; i < len(str); i++ { + if str[i] == 0 { + return i + } + } + return len(str) +} + +// DeviceRegistryProperty method retrieves a specified Plug and Play device property. +func (deviceInfoSet DevInfo) DeviceRegistryProperty(deviceInfoData *DevInfoData, property SPDRP) (interface{}, error) { + return SetupDiGetDeviceRegistryProperty(deviceInfoSet, deviceInfoData, property) +} + +//sys setupDiSetDeviceRegistryProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, property SPDRP, propertyBuffer *byte, propertyBufferSize uint32) (err error) = setupapi.SetupDiSetDeviceRegistryPropertyW + +// SetupDiSetDeviceRegistryProperty function sets a Plug and Play device property for a device. +func SetupDiSetDeviceRegistryProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, property SPDRP, propertyBuffers []byte) error { + return setupDiSetDeviceRegistryProperty(deviceInfoSet, deviceInfoData, property, &propertyBuffers[0], uint32(len(propertyBuffers))) +} + +// SetDeviceRegistryProperty function sets a Plug and Play device property for a device. +func (deviceInfoSet DevInfo) SetDeviceRegistryProperty(deviceInfoData *DevInfoData, property SPDRP, propertyBuffers []byte) error { + return SetupDiSetDeviceRegistryProperty(deviceInfoSet, deviceInfoData, property, propertyBuffers) +} + +// SetDeviceRegistryPropertyString method sets a Plug and Play device property string for a device. +func (deviceInfoSet DevInfo) SetDeviceRegistryPropertyString(deviceInfoData *DevInfoData, property SPDRP, str string) error { + str16, err := UTF16FromString(str) + if err != nil { + return err + } + err = SetupDiSetDeviceRegistryProperty(deviceInfoSet, deviceInfoData, property, utf16ToBuf(append(str16, 0))) + runtime.KeepAlive(str16) + return err +} + +//sys setupDiGetDeviceInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, deviceInstallParams *DevInstallParams) (err error) = setupapi.SetupDiGetDeviceInstallParamsW + +// SetupDiGetDeviceInstallParams function retrieves device installation parameters for a device information set or a particular device information element. +func SetupDiGetDeviceInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (*DevInstallParams, error) { + params := &DevInstallParams{} + params.size = uint32(unsafe.Sizeof(*params)) + + return params, setupDiGetDeviceInstallParams(deviceInfoSet, deviceInfoData, params) +} + +// DeviceInstallParams method retrieves device installation parameters for a device information set or a particular device information element. +func (deviceInfoSet DevInfo) DeviceInstallParams(deviceInfoData *DevInfoData) (*DevInstallParams, error) { + return SetupDiGetDeviceInstallParams(deviceInfoSet, deviceInfoData) +} + +//sys setupDiGetDeviceInstanceId(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, instanceId *uint16, instanceIdSize uint32, instanceIdRequiredSize *uint32) (err error) = setupapi.SetupDiGetDeviceInstanceIdW + +// SetupDiGetDeviceInstanceId function retrieves the instance ID of the device. +func SetupDiGetDeviceInstanceId(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (string, error) { + reqSize := uint32(1024) + for { + buf := make([]uint16, reqSize) + err := setupDiGetDeviceInstanceId(deviceInfoSet, deviceInfoData, &buf[0], uint32(len(buf)), &reqSize) + if err == ERROR_INSUFFICIENT_BUFFER { + continue + } + if err != nil { + return "", err + } + return UTF16ToString(buf), nil + } +} + +// DeviceInstanceID method retrieves the instance ID of the device. +func (deviceInfoSet DevInfo) DeviceInstanceID(deviceInfoData *DevInfoData) (string, error) { + return SetupDiGetDeviceInstanceId(deviceInfoSet, deviceInfoData) +} + +// SetupDiGetClassInstallParams function retrieves class installation parameters for a device information set or a particular device information element. +//sys SetupDiGetClassInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, classInstallParams *ClassInstallHeader, classInstallParamsSize uint32, requiredSize *uint32) (err error) = setupapi.SetupDiGetClassInstallParamsW + +// ClassInstallParams method retrieves class installation parameters for a device information set or a particular device information element. +func (deviceInfoSet DevInfo) ClassInstallParams(deviceInfoData *DevInfoData, classInstallParams *ClassInstallHeader, classInstallParamsSize uint32, requiredSize *uint32) error { + return SetupDiGetClassInstallParams(deviceInfoSet, deviceInfoData, classInstallParams, classInstallParamsSize, requiredSize) +} + +//sys SetupDiSetDeviceInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, deviceInstallParams *DevInstallParams) (err error) = setupapi.SetupDiSetDeviceInstallParamsW + +// SetDeviceInstallParams member sets device installation parameters for a device information set or a particular device information element. +func (deviceInfoSet DevInfo) SetDeviceInstallParams(deviceInfoData *DevInfoData, deviceInstallParams *DevInstallParams) error { + return SetupDiSetDeviceInstallParams(deviceInfoSet, deviceInfoData, deviceInstallParams) +} + +// SetupDiSetClassInstallParams function sets or clears class install parameters for a device information set or a particular device information element. +//sys SetupDiSetClassInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, classInstallParams *ClassInstallHeader, classInstallParamsSize uint32) (err error) = setupapi.SetupDiSetClassInstallParamsW + +// SetClassInstallParams method sets or clears class install parameters for a device information set or a particular device information element. +func (deviceInfoSet DevInfo) SetClassInstallParams(deviceInfoData *DevInfoData, classInstallParams *ClassInstallHeader, classInstallParamsSize uint32) error { + return SetupDiSetClassInstallParams(deviceInfoSet, deviceInfoData, classInstallParams, classInstallParamsSize) +} + +//sys setupDiClassNameFromGuidEx(classGUID *GUID, className *uint16, classNameSize uint32, requiredSize *uint32, machineName *uint16, reserved uintptr) (err error) = setupapi.SetupDiClassNameFromGuidExW + +// SetupDiClassNameFromGuidEx function retrieves the class name associated with a class GUID. The class can be installed on a local or remote computer. +func SetupDiClassNameFromGuidEx(classGUID *GUID, machineName string) (className string, err error) { + var classNameUTF16 [MAX_CLASS_NAME_LEN]uint16 + + var machineNameUTF16 *uint16 + if machineName != "" { + machineNameUTF16, err = UTF16PtrFromString(machineName) + if err != nil { + return + } + } + + err = setupDiClassNameFromGuidEx(classGUID, &classNameUTF16[0], MAX_CLASS_NAME_LEN, nil, machineNameUTF16, 0) + if err != nil { + return + } + + className = UTF16ToString(classNameUTF16[:]) + return +} + +//sys setupDiClassGuidsFromNameEx(className *uint16, classGuidList *GUID, classGuidListSize uint32, requiredSize *uint32, machineName *uint16, reserved uintptr) (err error) = setupapi.SetupDiClassGuidsFromNameExW + +// SetupDiClassGuidsFromNameEx function retrieves the GUIDs associated with the specified class name. This resulting list contains the classes currently installed on a local or remote computer. +func SetupDiClassGuidsFromNameEx(className string, machineName string) ([]GUID, error) { + classNameUTF16, err := UTF16PtrFromString(className) + if err != nil { + return nil, err + } + + var machineNameUTF16 *uint16 + if machineName != "" { + machineNameUTF16, err = UTF16PtrFromString(machineName) + if err != nil { + return nil, err + } + } + + reqSize := uint32(4) + for { + buf := make([]GUID, reqSize) + err = setupDiClassGuidsFromNameEx(classNameUTF16, &buf[0], uint32(len(buf)), &reqSize, machineNameUTF16, 0) + if err == ERROR_INSUFFICIENT_BUFFER { + continue + } + if err != nil { + return nil, err + } + return buf[:reqSize], nil + } +} + +//sys setupDiGetSelectedDevice(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) = setupapi.SetupDiGetSelectedDevice + +// SetupDiGetSelectedDevice function retrieves the selected device information element in a device information set. +func SetupDiGetSelectedDevice(deviceInfoSet DevInfo) (*DevInfoData, error) { + data := &DevInfoData{} + data.size = uint32(unsafe.Sizeof(*data)) + + return data, setupDiGetSelectedDevice(deviceInfoSet, data) +} + +// SelectedDevice method retrieves the selected device information element in a device information set. +func (deviceInfoSet DevInfo) SelectedDevice() (*DevInfoData, error) { + return SetupDiGetSelectedDevice(deviceInfoSet) +} + +// SetupDiSetSelectedDevice function sets a device information element as the selected member of a device information set. This function is typically used by an installation wizard. +//sys SetupDiSetSelectedDevice(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) = setupapi.SetupDiSetSelectedDevice + +// SetSelectedDevice method sets a device information element as the selected member of a device information set. This function is typically used by an installation wizard. +func (deviceInfoSet DevInfo) SetSelectedDevice(deviceInfoData *DevInfoData) error { + return SetupDiSetSelectedDevice(deviceInfoSet, deviceInfoData) +} + +//sys setupUninstallOEMInf(infFileName *uint16, flags SUOI, reserved uintptr) (err error) = setupapi.SetupUninstallOEMInfW + +// SetupUninstallOEMInf uninstalls the specified driver. +func SetupUninstallOEMInf(infFileName string, flags SUOI) error { + infFileName16, err := UTF16PtrFromString(infFileName) + if err != nil { + return err + } + return setupUninstallOEMInf(infFileName16, flags, 0) +} + +//sys cm_MapCrToWin32Err(configRet CONFIGRET, defaultWin32Error Errno) (ret Errno) = CfgMgr32.CM_MapCrToWin32Err + +//sys cm_Get_Device_Interface_List_Size(len *uint32, interfaceClass *GUID, deviceID *uint16, flags uint32) (ret CONFIGRET) = CfgMgr32.CM_Get_Device_Interface_List_SizeW +//sys cm_Get_Device_Interface_List(interfaceClass *GUID, deviceID *uint16, buffer *uint16, bufferLen uint32, flags uint32) (ret CONFIGRET) = CfgMgr32.CM_Get_Device_Interface_ListW + +func CM_Get_Device_Interface_List(deviceID string, interfaceClass *GUID, flags uint32) ([]string, error) { + deviceID16, err := UTF16PtrFromString(deviceID) + if err != nil { + return nil, err + } + var buf []uint16 + var buflen uint32 + for { + if ret := cm_Get_Device_Interface_List_Size(&buflen, interfaceClass, deviceID16, flags); ret != CR_SUCCESS { + return nil, ret + } + buf = make([]uint16, buflen) + if ret := cm_Get_Device_Interface_List(interfaceClass, deviceID16, &buf[0], buflen, flags); ret == CR_SUCCESS { + break + } else if ret != CR_BUFFER_SMALL { + return nil, ret + } + } + var interfaces []string + for i := 0; i < len(buf); { + j := i + wcslen(buf[i:]) + if i < j { + interfaces = append(interfaces, UTF16ToString(buf[i:j])) + } + i = j + 1 + } + if interfaces == nil { + return nil, ERROR_NO_SUCH_DEVICE_INTERFACE + } + return interfaces, nil +} + +//sys cm_Get_DevNode_Status(status *uint32, problemNumber *uint32, devInst DEVINST, flags uint32) (ret CONFIGRET) = CfgMgr32.CM_Get_DevNode_Status + +func CM_Get_DevNode_Status(status *uint32, problemNumber *uint32, devInst DEVINST, flags uint32) error { + ret := cm_Get_DevNode_Status(status, problemNumber, devInst, flags) + if ret == CR_SUCCESS { + return nil + } + return ret +} diff --git a/src/cmd/vendor/golang.org/x/sys/windows/setupapierrors_windows.go b/src/cmd/vendor/golang.org/x/sys/windows/setupapierrors_windows.go deleted file mode 100644 index 1681810e04..0000000000 --- a/src/cmd/vendor/golang.org/x/sys/windows/setupapierrors_windows.go +++ /dev/null @@ -1,100 +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 windows - -import "syscall" - -const ( - ERROR_EXPECTED_SECTION_NAME syscall.Errno = 0x20000000 | 0xC0000000 | 0 - ERROR_BAD_SECTION_NAME_LINE syscall.Errno = 0x20000000 | 0xC0000000 | 1 - ERROR_SECTION_NAME_TOO_LONG syscall.Errno = 0x20000000 | 0xC0000000 | 2 - ERROR_GENERAL_SYNTAX syscall.Errno = 0x20000000 | 0xC0000000 | 3 - ERROR_WRONG_INF_STYLE syscall.Errno = 0x20000000 | 0xC0000000 | 0x100 - ERROR_SECTION_NOT_FOUND syscall.Errno = 0x20000000 | 0xC0000000 | 0x101 - ERROR_LINE_NOT_FOUND syscall.Errno = 0x20000000 | 0xC0000000 | 0x102 - ERROR_NO_BACKUP syscall.Errno = 0x20000000 | 0xC0000000 | 0x103 - ERROR_NO_ASSOCIATED_CLASS syscall.Errno = 0x20000000 | 0xC0000000 | 0x200 - ERROR_CLASS_MISMATCH syscall.Errno = 0x20000000 | 0xC0000000 | 0x201 - ERROR_DUPLICATE_FOUND syscall.Errno = 0x20000000 | 0xC0000000 | 0x202 - ERROR_NO_DRIVER_SELECTED syscall.Errno = 0x20000000 | 0xC0000000 | 0x203 - ERROR_KEY_DOES_NOT_EXIST syscall.Errno = 0x20000000 | 0xC0000000 | 0x204 - ERROR_INVALID_DEVINST_NAME syscall.Errno = 0x20000000 | 0xC0000000 | 0x205 - ERROR_INVALID_CLASS syscall.Errno = 0x20000000 | 0xC0000000 | 0x206 - ERROR_DEVINST_ALREADY_EXISTS syscall.Errno = 0x20000000 | 0xC0000000 | 0x207 - ERROR_DEVINFO_NOT_REGISTERED syscall.Errno = 0x20000000 | 0xC0000000 | 0x208 - ERROR_INVALID_REG_PROPERTY syscall.Errno = 0x20000000 | 0xC0000000 | 0x209 - ERROR_NO_INF syscall.Errno = 0x20000000 | 0xC0000000 | 0x20A - ERROR_NO_SUCH_DEVINST syscall.Errno = 0x20000000 | 0xC0000000 | 0x20B - ERROR_CANT_LOAD_CLASS_ICON syscall.Errno = 0x20000000 | 0xC0000000 | 0x20C - ERROR_INVALID_CLASS_INSTALLER syscall.Errno = 0x20000000 | 0xC0000000 | 0x20D - ERROR_DI_DO_DEFAULT syscall.Errno = 0x20000000 | 0xC0000000 | 0x20E - ERROR_DI_NOFILECOPY syscall.Errno = 0x20000000 | 0xC0000000 | 0x20F - ERROR_INVALID_HWPROFILE syscall.Errno = 0x20000000 | 0xC0000000 | 0x210 - ERROR_NO_DEVICE_SELECTED syscall.Errno = 0x20000000 | 0xC0000000 | 0x211 - ERROR_DEVINFO_LIST_LOCKED syscall.Errno = 0x20000000 | 0xC0000000 | 0x212 - ERROR_DEVINFO_DATA_LOCKED syscall.Errno = 0x20000000 | 0xC0000000 | 0x213 - ERROR_DI_BAD_PATH syscall.Errno = 0x20000000 | 0xC0000000 | 0x214 - ERROR_NO_CLASSINSTALL_PARAMS syscall.Errno = 0x20000000 | 0xC0000000 | 0x215 - ERROR_FILEQUEUE_LOCKED syscall.Errno = 0x20000000 | 0xC0000000 | 0x216 - ERROR_BAD_SERVICE_INSTALLSECT syscall.Errno = 0x20000000 | 0xC0000000 | 0x217 - ERROR_NO_CLASS_DRIVER_LIST syscall.Errno = 0x20000000 | 0xC0000000 | 0x218 - ERROR_NO_ASSOCIATED_SERVICE syscall.Errno = 0x20000000 | 0xC0000000 | 0x219 - ERROR_NO_DEFAULT_DEVICE_INTERFACE syscall.Errno = 0x20000000 | 0xC0000000 | 0x21A - ERROR_DEVICE_INTERFACE_ACTIVE syscall.Errno = 0x20000000 | 0xC0000000 | 0x21B - ERROR_DEVICE_INTERFACE_REMOVED syscall.Errno = 0x20000000 | 0xC0000000 | 0x21C - ERROR_BAD_INTERFACE_INSTALLSECT syscall.Errno = 0x20000000 | 0xC0000000 | 0x21D - ERROR_NO_SUCH_INTERFACE_CLASS syscall.Errno = 0x20000000 | 0xC0000000 | 0x21E - ERROR_INVALID_REFERENCE_STRING syscall.Errno = 0x20000000 | 0xC0000000 | 0x21F - ERROR_INVALID_MACHINENAME syscall.Errno = 0x20000000 | 0xC0000000 | 0x220 - ERROR_REMOTE_COMM_FAILURE syscall.Errno = 0x20000000 | 0xC0000000 | 0x221 - ERROR_MACHINE_UNAVAILABLE syscall.Errno = 0x20000000 | 0xC0000000 | 0x222 - ERROR_NO_CONFIGMGR_SERVICES syscall.Errno = 0x20000000 | 0xC0000000 | 0x223 - ERROR_INVALID_PROPPAGE_PROVIDER syscall.Errno = 0x20000000 | 0xC0000000 | 0x224 - ERROR_NO_SUCH_DEVICE_INTERFACE syscall.Errno = 0x20000000 | 0xC0000000 | 0x225 - ERROR_DI_POSTPROCESSING_REQUIRED syscall.Errno = 0x20000000 | 0xC0000000 | 0x226 - ERROR_INVALID_COINSTALLER syscall.Errno = 0x20000000 | 0xC0000000 | 0x227 - ERROR_NO_COMPAT_DRIVERS syscall.Errno = 0x20000000 | 0xC0000000 | 0x228 - ERROR_NO_DEVICE_ICON syscall.Errno = 0x20000000 | 0xC0000000 | 0x229 - ERROR_INVALID_INF_LOGCONFIG syscall.Errno = 0x20000000 | 0xC0000000 | 0x22A - ERROR_DI_DONT_INSTALL syscall.Errno = 0x20000000 | 0xC0000000 | 0x22B - ERROR_INVALID_FILTER_DRIVER syscall.Errno = 0x20000000 | 0xC0000000 | 0x22C - ERROR_NON_WINDOWS_NT_DRIVER syscall.Errno = 0x20000000 | 0xC0000000 | 0x22D - ERROR_NON_WINDOWS_DRIVER syscall.Errno = 0x20000000 | 0xC0000000 | 0x22E - ERROR_NO_CATALOG_FOR_OEM_INF syscall.Errno = 0x20000000 | 0xC0000000 | 0x22F - ERROR_DEVINSTALL_QUEUE_NONNATIVE syscall.Errno = 0x20000000 | 0xC0000000 | 0x230 - ERROR_NOT_DISABLEABLE syscall.Errno = 0x20000000 | 0xC0000000 | 0x231 - ERROR_CANT_REMOVE_DEVINST syscall.Errno = 0x20000000 | 0xC0000000 | 0x232 - ERROR_INVALID_TARGET syscall.Errno = 0x20000000 | 0xC0000000 | 0x233 - ERROR_DRIVER_NONNATIVE syscall.Errno = 0x20000000 | 0xC0000000 | 0x234 - ERROR_IN_WOW64 syscall.Errno = 0x20000000 | 0xC0000000 | 0x235 - ERROR_SET_SYSTEM_RESTORE_POINT syscall.Errno = 0x20000000 | 0xC0000000 | 0x236 - ERROR_SCE_DISABLED syscall.Errno = 0x20000000 | 0xC0000000 | 0x238 - ERROR_UNKNOWN_EXCEPTION syscall.Errno = 0x20000000 | 0xC0000000 | 0x239 - ERROR_PNP_REGISTRY_ERROR syscall.Errno = 0x20000000 | 0xC0000000 | 0x23A - ERROR_REMOTE_REQUEST_UNSUPPORTED syscall.Errno = 0x20000000 | 0xC0000000 | 0x23B - ERROR_NOT_AN_INSTALLED_OEM_INF syscall.Errno = 0x20000000 | 0xC0000000 | 0x23C - ERROR_INF_IN_USE_BY_DEVICES syscall.Errno = 0x20000000 | 0xC0000000 | 0x23D - ERROR_DI_FUNCTION_OBSOLETE syscall.Errno = 0x20000000 | 0xC0000000 | 0x23E - ERROR_NO_AUTHENTICODE_CATALOG syscall.Errno = 0x20000000 | 0xC0000000 | 0x23F - ERROR_AUTHENTICODE_DISALLOWED syscall.Errno = 0x20000000 | 0xC0000000 | 0x240 - ERROR_AUTHENTICODE_TRUSTED_PUBLISHER syscall.Errno = 0x20000000 | 0xC0000000 | 0x241 - ERROR_AUTHENTICODE_TRUST_NOT_ESTABLISHED syscall.Errno = 0x20000000 | 0xC0000000 | 0x242 - ERROR_AUTHENTICODE_PUBLISHER_NOT_TRUSTED syscall.Errno = 0x20000000 | 0xC0000000 | 0x243 - ERROR_SIGNATURE_OSATTRIBUTE_MISMATCH syscall.Errno = 0x20000000 | 0xC0000000 | 0x244 - ERROR_ONLY_VALIDATE_VIA_AUTHENTICODE syscall.Errno = 0x20000000 | 0xC0000000 | 0x245 - ERROR_DEVICE_INSTALLER_NOT_READY syscall.Errno = 0x20000000 | 0xC0000000 | 0x246 - ERROR_DRIVER_STORE_ADD_FAILED syscall.Errno = 0x20000000 | 0xC0000000 | 0x247 - ERROR_DEVICE_INSTALL_BLOCKED syscall.Errno = 0x20000000 | 0xC0000000 | 0x248 - ERROR_DRIVER_INSTALL_BLOCKED syscall.Errno = 0x20000000 | 0xC0000000 | 0x249 - ERROR_WRONG_INF_TYPE syscall.Errno = 0x20000000 | 0xC0000000 | 0x24A - ERROR_FILE_HASH_NOT_IN_CATALOG syscall.Errno = 0x20000000 | 0xC0000000 | 0x24B - ERROR_DRIVER_STORE_DELETE_FAILED syscall.Errno = 0x20000000 | 0xC0000000 | 0x24C - ERROR_UNRECOVERABLE_STACK_OVERFLOW syscall.Errno = 0x20000000 | 0xC0000000 | 0x300 - EXCEPTION_SPAPI_UNRECOVERABLE_STACK_OVERFLOW syscall.Errno = ERROR_UNRECOVERABLE_STACK_OVERFLOW - ERROR_NO_DEFAULT_INTERFACE_DEVICE syscall.Errno = ERROR_NO_DEFAULT_DEVICE_INTERFACE - ERROR_INTERFACE_DEVICE_ACTIVE syscall.Errno = ERROR_DEVICE_INTERFACE_ACTIVE - ERROR_INTERFACE_DEVICE_REMOVED syscall.Errno = ERROR_DEVICE_INTERFACE_REMOVED - ERROR_NO_SUCH_INTERFACE_DEVICE syscall.Errno = ERROR_NO_SUCH_DEVICE_INTERFACE -) 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 2ff6aa0470..200b62a003 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/syscall_windows.go @@ -248,6 +248,7 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys FreeEnvironmentStrings(envs *uint16) (err error) = kernel32.FreeEnvironmentStringsW //sys GetEnvironmentVariable(name *uint16, buffer *uint16, size uint32) (n uint32, err error) = kernel32.GetEnvironmentVariableW //sys SetEnvironmentVariable(name *uint16, value *uint16) (err error) = kernel32.SetEnvironmentVariableW +//sys ExpandEnvironmentStrings(src *uint16, dst *uint16, size uint32) (n uint32, err error) = kernel32.ExpandEnvironmentStringsW //sys CreateEnvironmentBlock(block **uint16, token Token, inheritExisting bool) (err error) = userenv.CreateEnvironmentBlock //sys DestroyEnvironmentBlock(block *uint16) (err error) = userenv.DestroyEnvironmentBlock //sys getTickCount64() (ms uint64) = kernel32.GetTickCount64 @@ -322,6 +323,8 @@ func NewCallbackCDecl(fn interface{}) uintptr { //sys WriteConsole(console Handle, buf *uint16, towrite uint32, written *uint32, reserved *byte) (err error) = kernel32.WriteConsoleW //sys ReadConsole(console Handle, buf *uint16, toread uint32, read *uint32, inputControl *byte) (err error) = kernel32.ReadConsoleW //sys CreateToolhelp32Snapshot(flags uint32, processId uint32) (handle Handle, err error) [failretval==InvalidHandle] = kernel32.CreateToolhelp32Snapshot +//sys Module32First(snapshot Handle, moduleEntry *ModuleEntry32) (err error) = kernel32.Module32FirstW +//sys Module32Next(snapshot Handle, moduleEntry *ModuleEntry32) (err error) = kernel32.Module32NextW //sys Process32First(snapshot Handle, procEntry *ProcessEntry32) (err error) = kernel32.Process32FirstW //sys Process32Next(snapshot Handle, procEntry *ProcessEntry32) (err error) = kernel32.Process32NextW //sys Thread32First(snapshot Handle, threadEntry *ThreadEntry32) (err error) 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 286dd1eab9..73087bf5e5 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/types_windows.go @@ -156,6 +156,8 @@ const ( MAX_PATH = 260 MAX_LONG_PATH = 32768 + MAX_MODULE_NAME32 = 255 + MAX_COMPUTERNAME_LENGTH = 15 TIME_ZONE_ID_UNKNOWN = 0 @@ -970,6 +972,21 @@ type ThreadEntry32 struct { Flags uint32 } +type ModuleEntry32 struct { + Size uint32 + ModuleID uint32 + ProcessID uint32 + GlblcntUsage uint32 + ProccntUsage uint32 + ModBaseAddr uintptr + ModBaseSize uint32 + ModuleHandle Handle + Module [MAX_MODULE_NAME32 + 1]uint16 + ExePath [MAX_PATH]uint16 +} + +const SizeofModuleEntry32 = unsafe.Sizeof(ModuleEntry32{}) + type Systemtime struct { Year uint16 Month uint16 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 91817d6dcb..1055d47ed3 100644 --- a/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go +++ b/src/cmd/vendor/golang.org/x/sys/windows/zsyscall_windows.go @@ -36,6 +36,7 @@ func errnoErr(e syscall.Errno) error { } var ( + modCfgMgr32 = NewLazySystemDLL("CfgMgr32.dll") modadvapi32 = NewLazySystemDLL("advapi32.dll") modcrypt32 = NewLazySystemDLL("crypt32.dll") moddnsapi = NewLazySystemDLL("dnsapi.dll") @@ -48,6 +49,7 @@ var ( modpsapi = NewLazySystemDLL("psapi.dll") modsechost = NewLazySystemDLL("sechost.dll") modsecur32 = NewLazySystemDLL("secur32.dll") + modsetupapi = NewLazySystemDLL("setupapi.dll") modshell32 = NewLazySystemDLL("shell32.dll") moduser32 = NewLazySystemDLL("user32.dll") moduserenv = NewLazySystemDLL("userenv.dll") @@ -56,6 +58,10 @@ var ( modws2_32 = NewLazySystemDLL("ws2_32.dll") modwtsapi32 = NewLazySystemDLL("wtsapi32.dll") + procCM_Get_DevNode_Status = modCfgMgr32.NewProc("CM_Get_DevNode_Status") + procCM_Get_Device_Interface_ListW = modCfgMgr32.NewProc("CM_Get_Device_Interface_ListW") + procCM_Get_Device_Interface_List_SizeW = modCfgMgr32.NewProc("CM_Get_Device_Interface_List_SizeW") + procCM_MapCrToWin32Err = modCfgMgr32.NewProc("CM_MapCrToWin32Err") procAdjustTokenGroups = modadvapi32.NewProc("AdjustTokenGroups") procAdjustTokenPrivileges = modadvapi32.NewProc("AdjustTokenPrivileges") procAllocateAndInitializeSid = modadvapi32.NewProc("AllocateAndInitializeSid") @@ -199,6 +205,7 @@ var ( procDeviceIoControl = modkernel32.NewProc("DeviceIoControl") procDuplicateHandle = modkernel32.NewProc("DuplicateHandle") procExitProcess = modkernel32.NewProc("ExitProcess") + procExpandEnvironmentStringsW = modkernel32.NewProc("ExpandEnvironmentStringsW") procFindClose = modkernel32.NewProc("FindClose") procFindCloseChangeNotification = modkernel32.NewProc("FindCloseChangeNotification") procFindFirstChangeNotificationW = modkernel32.NewProc("FindFirstChangeNotificationW") @@ -288,6 +295,8 @@ var ( procLockFileEx = modkernel32.NewProc("LockFileEx") procLockResource = modkernel32.NewProc("LockResource") procMapViewOfFile = modkernel32.NewProc("MapViewOfFile") + procModule32FirstW = modkernel32.NewProc("Module32FirstW") + procModule32NextW = modkernel32.NewProc("Module32NextW") procMoveFileExW = modkernel32.NewProc("MoveFileExW") procMoveFileW = modkernel32.NewProc("MoveFileW") procMultiByteToWideChar = modkernel32.NewProc("MultiByteToWideChar") @@ -400,6 +409,34 @@ var ( procUnsubscribeServiceChangeNotifications = modsechost.NewProc("UnsubscribeServiceChangeNotifications") procGetUserNameExW = modsecur32.NewProc("GetUserNameExW") procTranslateNameW = modsecur32.NewProc("TranslateNameW") + procSetupDiBuildDriverInfoList = modsetupapi.NewProc("SetupDiBuildDriverInfoList") + procSetupDiCallClassInstaller = modsetupapi.NewProc("SetupDiCallClassInstaller") + procSetupDiCancelDriverInfoSearch = modsetupapi.NewProc("SetupDiCancelDriverInfoSearch") + procSetupDiClassGuidsFromNameExW = modsetupapi.NewProc("SetupDiClassGuidsFromNameExW") + procSetupDiClassNameFromGuidExW = modsetupapi.NewProc("SetupDiClassNameFromGuidExW") + procSetupDiCreateDeviceInfoListExW = modsetupapi.NewProc("SetupDiCreateDeviceInfoListExW") + procSetupDiCreateDeviceInfoW = modsetupapi.NewProc("SetupDiCreateDeviceInfoW") + procSetupDiDestroyDeviceInfoList = modsetupapi.NewProc("SetupDiDestroyDeviceInfoList") + procSetupDiDestroyDriverInfoList = modsetupapi.NewProc("SetupDiDestroyDriverInfoList") + procSetupDiEnumDeviceInfo = modsetupapi.NewProc("SetupDiEnumDeviceInfo") + procSetupDiEnumDriverInfoW = modsetupapi.NewProc("SetupDiEnumDriverInfoW") + procSetupDiGetClassDevsExW = modsetupapi.NewProc("SetupDiGetClassDevsExW") + procSetupDiGetClassInstallParamsW = modsetupapi.NewProc("SetupDiGetClassInstallParamsW") + procSetupDiGetDeviceInfoListDetailW = modsetupapi.NewProc("SetupDiGetDeviceInfoListDetailW") + procSetupDiGetDeviceInstallParamsW = modsetupapi.NewProc("SetupDiGetDeviceInstallParamsW") + procSetupDiGetDeviceInstanceIdW = modsetupapi.NewProc("SetupDiGetDeviceInstanceIdW") + procSetupDiGetDevicePropertyW = modsetupapi.NewProc("SetupDiGetDevicePropertyW") + procSetupDiGetDeviceRegistryPropertyW = modsetupapi.NewProc("SetupDiGetDeviceRegistryPropertyW") + procSetupDiGetDriverInfoDetailW = modsetupapi.NewProc("SetupDiGetDriverInfoDetailW") + procSetupDiGetSelectedDevice = modsetupapi.NewProc("SetupDiGetSelectedDevice") + procSetupDiGetSelectedDriverW = modsetupapi.NewProc("SetupDiGetSelectedDriverW") + procSetupDiOpenDevRegKey = modsetupapi.NewProc("SetupDiOpenDevRegKey") + procSetupDiSetClassInstallParamsW = modsetupapi.NewProc("SetupDiSetClassInstallParamsW") + procSetupDiSetDeviceInstallParamsW = modsetupapi.NewProc("SetupDiSetDeviceInstallParamsW") + procSetupDiSetDeviceRegistryPropertyW = modsetupapi.NewProc("SetupDiSetDeviceRegistryPropertyW") + procSetupDiSetSelectedDevice = modsetupapi.NewProc("SetupDiSetSelectedDevice") + procSetupDiSetSelectedDriverW = modsetupapi.NewProc("SetupDiSetSelectedDriverW") + procSetupUninstallOEMInfW = modsetupapi.NewProc("SetupUninstallOEMInfW") procCommandLineToArgvW = modshell32.NewProc("CommandLineToArgvW") procSHGetKnownFolderPath = modshell32.NewProc("SHGetKnownFolderPath") procShellExecuteW = modshell32.NewProc("ShellExecuteW") @@ -447,6 +484,30 @@ var ( procWTSQueryUserToken = modwtsapi32.NewProc("WTSQueryUserToken") ) +func cm_Get_DevNode_Status(status *uint32, problemNumber *uint32, devInst DEVINST, flags uint32) (ret CONFIGRET) { + r0, _, _ := syscall.Syscall6(procCM_Get_DevNode_Status.Addr(), 4, uintptr(unsafe.Pointer(status)), uintptr(unsafe.Pointer(problemNumber)), uintptr(devInst), uintptr(flags), 0, 0) + ret = CONFIGRET(r0) + return +} + +func cm_Get_Device_Interface_List(interfaceClass *GUID, deviceID *uint16, buffer *uint16, bufferLen uint32, flags uint32) (ret CONFIGRET) { + r0, _, _ := syscall.Syscall6(procCM_Get_Device_Interface_ListW.Addr(), 5, uintptr(unsafe.Pointer(interfaceClass)), uintptr(unsafe.Pointer(deviceID)), uintptr(unsafe.Pointer(buffer)), uintptr(bufferLen), uintptr(flags), 0) + ret = CONFIGRET(r0) + return +} + +func cm_Get_Device_Interface_List_Size(len *uint32, interfaceClass *GUID, deviceID *uint16, flags uint32) (ret CONFIGRET) { + r0, _, _ := syscall.Syscall6(procCM_Get_Device_Interface_List_SizeW.Addr(), 4, uintptr(unsafe.Pointer(len)), uintptr(unsafe.Pointer(interfaceClass)), uintptr(unsafe.Pointer(deviceID)), uintptr(flags), 0, 0) + ret = CONFIGRET(r0) + return +} + +func cm_MapCrToWin32Err(configRet CONFIGRET, defaultWin32Error Errno) (ret Errno) { + r0, _, _ := syscall.Syscall(procCM_MapCrToWin32Err.Addr(), 2, uintptr(configRet), uintptr(defaultWin32Error), 0) + ret = Errno(r0) + return +} + func AdjustTokenGroups(token Token, resetToDefault bool, newstate *Tokengroups, buflen uint32, prevstate *Tokengroups, returnlen *uint32) (err error) { var _p0 uint32 if resetToDefault { @@ -1716,6 +1777,15 @@ func ExitProcess(exitcode uint32) { return } +func ExpandEnvironmentStrings(src *uint16, dst *uint16, size uint32) (n uint32, err error) { + r0, _, e1 := syscall.Syscall(procExpandEnvironmentStringsW.Addr(), 3, uintptr(unsafe.Pointer(src)), uintptr(unsafe.Pointer(dst)), uintptr(size)) + n = uint32(r0) + if n == 0 { + err = errnoErr(e1) + } + return +} + func FindClose(handle Handle) (err error) { r1, _, e1 := syscall.Syscall(procFindClose.Addr(), 1, uintptr(handle), 0, 0) if r1 == 0 { @@ -2499,6 +2569,22 @@ func MapViewOfFile(handle Handle, access uint32, offsetHigh uint32, offsetLow ui return } +func Module32First(snapshot Handle, moduleEntry *ModuleEntry32) (err error) { + r1, _, e1 := syscall.Syscall(procModule32FirstW.Addr(), 2, uintptr(snapshot), uintptr(unsafe.Pointer(moduleEntry)), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func Module32Next(snapshot Handle, moduleEntry *ModuleEntry32) (err error) { + r1, _, e1 := syscall.Syscall(procModule32NextW.Addr(), 2, uintptr(snapshot), uintptr(unsafe.Pointer(moduleEntry)), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + func MoveFileEx(from *uint16, to *uint16, flags uint32) (err error) { r1, _, e1 := syscall.Syscall(procMoveFileExW.Addr(), 3, uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(to)), uintptr(flags)) if r1 == 0 { @@ -3432,6 +3518,233 @@ func TranslateName(accName *uint16, accNameFormat uint32, desiredNameFormat uint return } +func SetupDiBuildDriverInfoList(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiBuildDriverInfoList.Addr(), 3, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(driverType)) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func SetupDiCallClassInstaller(installFunction DI_FUNCTION, deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiCallClassInstaller.Addr(), 3, uintptr(installFunction), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData))) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func SetupDiCancelDriverInfoSearch(deviceInfoSet DevInfo) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiCancelDriverInfoSearch.Addr(), 1, uintptr(deviceInfoSet), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiClassGuidsFromNameEx(className *uint16, classGuidList *GUID, classGuidListSize uint32, requiredSize *uint32, machineName *uint16, reserved uintptr) (err error) { + r1, _, e1 := syscall.Syscall6(procSetupDiClassGuidsFromNameExW.Addr(), 6, uintptr(unsafe.Pointer(className)), uintptr(unsafe.Pointer(classGuidList)), uintptr(classGuidListSize), uintptr(unsafe.Pointer(requiredSize)), uintptr(unsafe.Pointer(machineName)), uintptr(reserved)) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiClassNameFromGuidEx(classGUID *GUID, className *uint16, classNameSize uint32, requiredSize *uint32, machineName *uint16, reserved uintptr) (err error) { + r1, _, e1 := syscall.Syscall6(procSetupDiClassNameFromGuidExW.Addr(), 6, uintptr(unsafe.Pointer(classGUID)), uintptr(unsafe.Pointer(className)), uintptr(classNameSize), uintptr(unsafe.Pointer(requiredSize)), uintptr(unsafe.Pointer(machineName)), uintptr(reserved)) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiCreateDeviceInfoListEx(classGUID *GUID, hwndParent uintptr, machineName *uint16, reserved uintptr) (handle DevInfo, err error) { + r0, _, e1 := syscall.Syscall6(procSetupDiCreateDeviceInfoListExW.Addr(), 4, uintptr(unsafe.Pointer(classGUID)), uintptr(hwndParent), uintptr(unsafe.Pointer(machineName)), uintptr(reserved), 0, 0) + handle = DevInfo(r0) + if handle == DevInfo(InvalidHandle) { + err = errnoErr(e1) + } + return +} + +func setupDiCreateDeviceInfo(deviceInfoSet DevInfo, DeviceName *uint16, classGUID *GUID, DeviceDescription *uint16, hwndParent uintptr, CreationFlags DICD, deviceInfoData *DevInfoData) (err error) { + r1, _, e1 := syscall.Syscall9(procSetupDiCreateDeviceInfoW.Addr(), 7, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(DeviceName)), uintptr(unsafe.Pointer(classGUID)), uintptr(unsafe.Pointer(DeviceDescription)), uintptr(hwndParent), uintptr(CreationFlags), uintptr(unsafe.Pointer(deviceInfoData)), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func SetupDiDestroyDeviceInfoList(deviceInfoSet DevInfo) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiDestroyDeviceInfoList.Addr(), 1, uintptr(deviceInfoSet), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func SetupDiDestroyDriverInfoList(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiDestroyDriverInfoList.Addr(), 3, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(driverType)) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiEnumDeviceInfo(deviceInfoSet DevInfo, memberIndex uint32, deviceInfoData *DevInfoData) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiEnumDeviceInfo.Addr(), 3, uintptr(deviceInfoSet), uintptr(memberIndex), uintptr(unsafe.Pointer(deviceInfoData))) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiEnumDriverInfo(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverType SPDIT, memberIndex uint32, driverInfoData *DrvInfoData) (err error) { + r1, _, e1 := syscall.Syscall6(procSetupDiEnumDriverInfoW.Addr(), 5, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(driverType), uintptr(memberIndex), uintptr(unsafe.Pointer(driverInfoData)), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiGetClassDevsEx(classGUID *GUID, Enumerator *uint16, hwndParent uintptr, Flags DIGCF, deviceInfoSet DevInfo, machineName *uint16, reserved uintptr) (handle DevInfo, err error) { + r0, _, e1 := syscall.Syscall9(procSetupDiGetClassDevsExW.Addr(), 7, uintptr(unsafe.Pointer(classGUID)), uintptr(unsafe.Pointer(Enumerator)), uintptr(hwndParent), uintptr(Flags), uintptr(deviceInfoSet), uintptr(unsafe.Pointer(machineName)), uintptr(reserved), 0, 0) + handle = DevInfo(r0) + if handle == DevInfo(InvalidHandle) { + err = errnoErr(e1) + } + return +} + +func SetupDiGetClassInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, classInstallParams *ClassInstallHeader, classInstallParamsSize uint32, requiredSize *uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procSetupDiGetClassInstallParamsW.Addr(), 5, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(classInstallParams)), uintptr(classInstallParamsSize), uintptr(unsafe.Pointer(requiredSize)), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiGetDeviceInfoListDetail(deviceInfoSet DevInfo, deviceInfoSetDetailData *DevInfoListDetailData) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiGetDeviceInfoListDetailW.Addr(), 2, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoSetDetailData)), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiGetDeviceInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, deviceInstallParams *DevInstallParams) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiGetDeviceInstallParamsW.Addr(), 3, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(deviceInstallParams))) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiGetDeviceInstanceId(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, instanceId *uint16, instanceIdSize uint32, instanceIdRequiredSize *uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procSetupDiGetDeviceInstanceIdW.Addr(), 5, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(instanceId)), uintptr(instanceIdSize), uintptr(unsafe.Pointer(instanceIdRequiredSize)), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiGetDeviceProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, propertyKey *DEVPROPKEY, propertyType *DEVPROPTYPE, propertyBuffer *byte, propertyBufferSize uint32, requiredSize *uint32, flags uint32) (err error) { + r1, _, e1 := syscall.Syscall9(procSetupDiGetDevicePropertyW.Addr(), 8, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(propertyKey)), uintptr(unsafe.Pointer(propertyType)), uintptr(unsafe.Pointer(propertyBuffer)), uintptr(propertyBufferSize), uintptr(unsafe.Pointer(requiredSize)), uintptr(flags), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiGetDeviceRegistryProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, property SPDRP, propertyRegDataType *uint32, propertyBuffer *byte, propertyBufferSize uint32, requiredSize *uint32) (err error) { + r1, _, e1 := syscall.Syscall9(procSetupDiGetDeviceRegistryPropertyW.Addr(), 7, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(property), uintptr(unsafe.Pointer(propertyRegDataType)), uintptr(unsafe.Pointer(propertyBuffer)), uintptr(propertyBufferSize), uintptr(unsafe.Pointer(requiredSize)), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiGetDriverInfoDetail(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData, driverInfoDetailData *DrvInfoDetailData, driverInfoDetailDataSize uint32, requiredSize *uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procSetupDiGetDriverInfoDetailW.Addr(), 6, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(driverInfoData)), uintptr(unsafe.Pointer(driverInfoDetailData)), uintptr(driverInfoDetailDataSize), uintptr(unsafe.Pointer(requiredSize))) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiGetSelectedDevice(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiGetSelectedDevice.Addr(), 2, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiGetSelectedDriver(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiGetSelectedDriverW.Addr(), 3, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(driverInfoData))) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func SetupDiOpenDevRegKey(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, Scope DICS_FLAG, HwProfile uint32, KeyType DIREG, samDesired uint32) (key Handle, err error) { + r0, _, e1 := syscall.Syscall6(procSetupDiOpenDevRegKey.Addr(), 6, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(Scope), uintptr(HwProfile), uintptr(KeyType), uintptr(samDesired)) + key = Handle(r0) + if key == InvalidHandle { + err = errnoErr(e1) + } + return +} + +func SetupDiSetClassInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, classInstallParams *ClassInstallHeader, classInstallParamsSize uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procSetupDiSetClassInstallParamsW.Addr(), 4, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(classInstallParams)), uintptr(classInstallParamsSize), 0, 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func SetupDiSetDeviceInstallParams(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, deviceInstallParams *DevInstallParams) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiSetDeviceInstallParamsW.Addr(), 3, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(deviceInstallParams))) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupDiSetDeviceRegistryProperty(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, property SPDRP, propertyBuffer *byte, propertyBufferSize uint32) (err error) { + r1, _, e1 := syscall.Syscall6(procSetupDiSetDeviceRegistryPropertyW.Addr(), 5, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(property), uintptr(unsafe.Pointer(propertyBuffer)), uintptr(propertyBufferSize), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func SetupDiSetSelectedDevice(deviceInfoSet DevInfo, deviceInfoData *DevInfoData) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiSetSelectedDevice.Addr(), 2, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), 0) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func SetupDiSetSelectedDriver(deviceInfoSet DevInfo, deviceInfoData *DevInfoData, driverInfoData *DrvInfoData) (err error) { + r1, _, e1 := syscall.Syscall(procSetupDiSetSelectedDriverW.Addr(), 3, uintptr(deviceInfoSet), uintptr(unsafe.Pointer(deviceInfoData)), uintptr(unsafe.Pointer(driverInfoData))) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + +func setupUninstallOEMInf(infFileName *uint16, flags SUOI, reserved uintptr) (err error) { + r1, _, e1 := syscall.Syscall(procSetupUninstallOEMInfW.Addr(), 3, uintptr(unsafe.Pointer(infFileName)), uintptr(flags), uintptr(reserved)) + if r1 == 0 { + err = errnoErr(e1) + } + return +} + func CommandLineToArgv(cmd *uint16, argc *int32) (argv *[8192]*[8192]uint16, err error) { r0, _, e1 := syscall.Syscall(procCommandLineToArgvW.Addr(), 2, uintptr(unsafe.Pointer(cmd)), uintptr(unsafe.Pointer(argc)), 0) argv = (*[8192]*[8192]uint16)(unsafe.Pointer(r0)) diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt index 0c107cd5ea..5ce2fe2f63 100644 --- a/src/cmd/vendor/modules.txt +++ b/src/cmd/vendor/modules.txt @@ -42,7 +42,7 @@ golang.org/x/mod/zip # golang.org/x/sync v0.0.0-20210220032951-036812b2e83c ## explicit golang.org/x/sync/semaphore -# golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e +# golang.org/x/sys v0.0.0-20211205182925-97ca703d548d ## explicit; go 1.17 golang.org/x/sys/internal/unsafeheader golang.org/x/sys/plan9 diff --git a/src/go.mod b/src/go.mod index d26e4960b3..24d034b810 100644 --- a/src/go.mod +++ b/src/go.mod @@ -8,6 +8,6 @@ require ( ) require ( - golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e // indirect + golang.org/x/sys v0.0.0-20211205182925-97ca703d548d // indirect golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2 // indirect ) diff --git a/src/go.sum b/src/go.sum index fddc4fbe93..d063e65530 100644 --- a/src/go.sum +++ b/src/go.sum @@ -2,7 +2,7 @@ golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa h1:idItI2DDfCokpg0N51B2Vt golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/net v0.0.0-20211123203042-d83791d6bcd9 h1:0qxwC5n+ttVOINCBeRHO0nq9X7uy8SDsPoi5OaCdIEI= golang.org/x/net v0.0.0-20211123203042-d83791d6bcd9/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e h1:i6Vklmyu+fZMFYpum+sR4ZWABGW7MyIxfJZXYvcnbns= -golang.org/x/sys v0.0.0-20211109065445-02f5c0300f6e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.0.0-20211205182925-97ca703d548d h1:FjkYO/PPp4Wi0EAUOVLxePm7qVW4r4ctbWpURyuOD0E= +golang.org/x/sys v0.0.0-20211205182925-97ca703d548d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2 h1:GLw7MR8AfAG2GmGcmVgObFOHXYypgGjnGno25RDwn3Y= golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2/go.mod h1:EFNZuWvGYxIRUEX+K8UmCFwYmZjqcrnq15ZuVldZkZ0= diff --git a/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go b/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go index 3298a87e98..fa7cdb9bcd 100644 --- a/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go +++ b/src/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go @@ -15,7 +15,3 @@ func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) // xgetbv with ecx = 0 is implemented in cpu_x86.s for gc compiler // and in cpu_gccgo.c for gccgo. func xgetbv() (eax, edx uint32) - -// darwinSupportsAVX512 is implemented in cpu_x86.s for gc compiler -// and in cpu_gccgo_x86.go for gccgo. -func darwinSupportsAVX512() bool diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt index 2650806683..bef622891e 100644 --- a/src/vendor/modules.txt +++ b/src/vendor/modules.txt @@ -19,7 +19,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-20211109065445-02f5c0300f6e +# golang.org/x/sys v0.0.0-20211205182925-97ca703d548d ## explicit; go 1.17 golang.org/x/sys/cpu # golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2 From f8a8a73096a4d36ce7d35e9643db89e669bbee1f Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Sun, 5 Dec 2021 22:18:04 -0500 Subject: [PATCH 394/752] go/types, types2: unexport NewTypeList NewTypeList was not part of the go/types API proposal, and was left in by accident. It also shouldn't be necessary, so remove it. Updates #47916 Change-Id: I4db3ccf036ccfb708ecf2c176ea4921fe68089a4 Reviewed-on: https://go-review.googlesource.com/c/go/+/369475 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Gopher Robot Reviewed-by: Robert Griesemer --- doc/go1.18.html | 4 +--- src/cmd/compile/internal/types2/check.go | 2 +- src/cmd/compile/internal/types2/instantiate.go | 2 +- src/cmd/compile/internal/types2/typelists.go | 4 ++-- src/cmd/compile/internal/types2/typexpr.go | 4 ++-- src/go/types/check.go | 2 +- src/go/types/instantiate.go | 2 +- src/go/types/typelists.go | 4 ++-- src/go/types/typexpr.go | 4 ++-- 9 files changed, 13 insertions(+), 15 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 16a5a6723c..35b3d744ec 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -516,9 +516,7 @@ Do not send CLs removing the interior tags from such phrases.
  • The new type - TypeList and factory function - NewTypeList facilitate storing - a list of types. + TypeList holds a list of types.
  • ignoring struct tags (see below), - x's type and T have identical - underlying types. + x's type and T are not + type parameters but have + identical underlying types.
  • ignoring struct tags (see below), x's type and T are pointer types that are not named types, - and their pointer base types have identical underlying types. + and their pointer base types are not type parameters but + have identical underlying types.
  • The new factory function diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go index 38fc25c74d..aacbb25b3b 100644 --- a/src/cmd/compile/internal/types2/check.go +++ b/src/cmd/compile/internal/types2/check.go @@ -494,7 +494,7 @@ func (check *Checker) recordInstance(expr syntax.Expr, targs []Type, typ Type) { assert(ident != nil) assert(typ != nil) if m := check.Instances; m != nil { - m[ident] = Instance{NewTypeList(targs), typ} + m[ident] = Instance{newTypeList(targs), typ} } } diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go index f9423dd70e..cda6c7baf4 100644 --- a/src/cmd/compile/internal/types2/instantiate.go +++ b/src/cmd/compile/internal/types2/instantiate.go @@ -77,7 +77,7 @@ func (check *Checker) instance(pos syntax.Pos, orig Type, targs []Type, ctxt *Co case *Named: tname := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil) named := check.newNamed(tname, orig, nil, nil, nil) // underlying, tparams, and methods are set when named is resolved - named.targs = NewTypeList(targs) + named.targs = newTypeList(targs) named.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) { return expandNamed(ctxt, n, pos) } diff --git a/src/cmd/compile/internal/types2/typelists.go b/src/cmd/compile/internal/types2/typelists.go index ababe85909..0b77edbde2 100644 --- a/src/cmd/compile/internal/types2/typelists.go +++ b/src/cmd/compile/internal/types2/typelists.go @@ -29,8 +29,8 @@ func (l *TypeParamList) list() []*TypeParam { // TypeList holds a list of types. type TypeList struct{ types []Type } -// NewTypeList returns a new TypeList with the types in list. -func NewTypeList(list []Type) *TypeList { +// newTypeList returns a new TypeList with the types in list. +func newTypeList(list []Type) *TypeList { if len(list) == 0 { return nil } diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go index 56a7dcd203..9121c2c1f6 100644 --- a/src/cmd/compile/internal/types2/typexpr.go +++ b/src/cmd/compile/internal/types2/typexpr.go @@ -442,7 +442,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, xlist []syntax.Expr, def * if inst == nil { tname := NewTypeName(x.Pos(), orig.obj.pkg, orig.obj.name, nil) inst = check.newNamed(tname, orig, nil, nil, nil) // underlying, methods and tparams are set when named is resolved - inst.targs = NewTypeList(targs) + inst.targs = newTypeList(targs) inst = ctxt.update(h, orig, targs, inst).(*Named) } def.setUnderlying(inst) @@ -456,7 +456,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, xlist []syntax.Expr, def * // be set to Typ[Invalid] in expandNamed. inferred = check.infer(x.Pos(), tparams, targs, nil, nil) if len(inferred) > len(targs) { - inst.targs = NewTypeList(inferred) + inst.targs = newTypeList(inferred) } } diff --git a/src/go/types/check.go b/src/go/types/check.go index 38508c77a9..d967c0bd25 100644 --- a/src/go/types/check.go +++ b/src/go/types/check.go @@ -487,7 +487,7 @@ func (check *Checker) recordInstance(expr ast.Expr, targs []Type, typ Type) { assert(ident != nil) assert(typ != nil) if m := check.Instances; m != nil { - m[ident] = Instance{NewTypeList(targs), typ} + m[ident] = Instance{newTypeList(targs), typ} } } diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go index 597a6da624..e91d08cc5e 100644 --- a/src/go/types/instantiate.go +++ b/src/go/types/instantiate.go @@ -77,7 +77,7 @@ func (check *Checker) instance(pos token.Pos, orig Type, targs []Type, ctxt *Con case *Named: tname := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil) named := check.newNamed(tname, orig, nil, nil, nil) // underlying, tparams, and methods are set when named is resolved - named.targs = NewTypeList(targs) + named.targs = newTypeList(targs) named.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) { return expandNamed(ctxt, n, pos) } diff --git a/src/go/types/typelists.go b/src/go/types/typelists.go index ba74b8d45a..aea19e946d 100644 --- a/src/go/types/typelists.go +++ b/src/go/types/typelists.go @@ -29,8 +29,8 @@ func (l *TypeParamList) list() []*TypeParam { // TypeList holds a list of types. type TypeList struct{ types []Type } -// NewTypeList returns a new TypeList with the types in list. -func NewTypeList(list []Type) *TypeList { +// newTypeList returns a new TypeList with the types in list. +func newTypeList(list []Type) *TypeList { if len(list) == 0 { return nil } diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go index 0a74a875bc..b961f7c47f 100644 --- a/src/go/types/typexpr.go +++ b/src/go/types/typexpr.go @@ -427,7 +427,7 @@ func (check *Checker) instantiatedType(ix *typeparams.IndexExpr, def *Named) (re if inst == nil { tname := NewTypeName(ix.X.Pos(), orig.obj.pkg, orig.obj.name, nil) inst = check.newNamed(tname, orig, nil, nil, nil) // underlying, methods and tparams are set when named is resolved - inst.targs = NewTypeList(targs) + inst.targs = newTypeList(targs) inst = ctxt.update(h, orig, targs, inst).(*Named) } def.setUnderlying(inst) @@ -441,7 +441,7 @@ func (check *Checker) instantiatedType(ix *typeparams.IndexExpr, def *Named) (re // be set to Typ[Invalid] in expandNamed. inferred = check.infer(ix.Orig, tparams, targs, nil, nil) if len(inferred) > len(targs) { - inst.targs = NewTypeList(inferred) + inst.targs = newTypeList(inferred) } } From 2cb9042dc2d5fdf6013305a077d013dbbfbaac06 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Mon, 6 Dec 2021 11:43:48 -0500 Subject: [PATCH 395/752] doc/go1.18: cite CLs for more efficient scavenging For #47694. Change-Id: Ic6088b1811600670a57f28426f4158a7c7517c82 Reviewed-on: https://go-review.googlesource.com/c/go/+/369616 Trust: Austin Clements Reviewed-by: Michael Knyszek --- doc/go1.18.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 35b3d744ec..e4e0d2300d 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -282,7 +282,7 @@ Do not send CLs removing the interior tags from such phrases. GOGC where necessary.

    -

    +

    The runtime now returns memory to the operating system more efficiently and has been tuned to work more aggressively as a result.

    From 7a840664fe9d8d4c11b943dba77c513dba5207a1 Mon Sep 17 00:00:00 2001 From: Roi Martin Date: Tue, 30 Nov 2021 19:35:47 +0100 Subject: [PATCH 396/752] cmd/go: update "go help doc" docs This CL updates "go help doc" docs so they reflect the following changes: - CL 59413 modified "go doc", so the behavior of the two-args case is consistent with the one-arg one. - CL 141397 removed godoc's command-line interface in favor of "go doc". Fixes #49830. Change-Id: I0923634291d34ae663fe2944d69757462b814919 Reviewed-on: https://go-review.googlesource.com/c/go/+/367497 Reviewed-by: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Trust: Russ Cox --- src/cmd/go/alldocs.go | 5 ++--- src/cmd/go/internal/doc/doc.go | 5 ++--- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index 12b64d309c..b9fca791be 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -368,9 +368,8 @@ // path. The go tool's usual package mechanism does not apply: package path // elements like . and ... are not implemented by go doc. // -// When run with two arguments, the first must be a full package path (not just a -// suffix), and the second is a symbol, or symbol with method or struct field. -// This is similar to the syntax accepted by godoc: +// When run with two arguments, the first is a package path (full path or suffix), +// and the second is a symbol, or symbol with method or struct field: // // go doc [.] // diff --git a/src/cmd/go/internal/doc/doc.go b/src/cmd/go/internal/doc/doc.go index 8580a5dc4d..7741a9022c 100644 --- a/src/cmd/go/internal/doc/doc.go +++ b/src/cmd/go/internal/doc/doc.go @@ -60,9 +60,8 @@ The package path must be either a qualified path or a proper suffix of a path. The go tool's usual package mechanism does not apply: package path elements like . and ... are not implemented by go doc. -When run with two arguments, the first must be a full package path (not just a -suffix), and the second is a symbol, or symbol with method or struct field. -This is similar to the syntax accepted by godoc: +When run with two arguments, the first is a package path (full path or suffix), +and the second is a symbol, or symbol with method or struct field: go doc [.] From c27a3592aec5f46ae18f7fd3d9ba18e69e2f1dcb Mon Sep 17 00:00:00 2001 From: Michael Anthony Knyszek Date: Mon, 23 Aug 2021 17:27:40 +0000 Subject: [PATCH 397/752] runtime: set iOS addr space to 40 bits with incremental pagealloc In iOS <14, the address space is strictly limited to 8 GiB, or 33 bits. As a result, the page allocator also assumes all heap memory lives in this region. This is especially necessary because the page allocator has a PROT_NONE mapping proportional to the size of the usable address space, so this keeps that mapping very small. However starting with iOS 14, this restriction is relaxed, and mmap may start returning addresses outside of the <14 range. Today this means that in iOS 14 and later, users experience an error in the page allocator when a heap arena is mapped outside of the old range. This change increases the ios/arm64 heapAddrBits to 40 while simultaneously making ios/arm64 use the 64-bit pagealloc implementation (with reservations and incremental mapping) to accommodate both iOS versions <14 and 14+. Once iOS <14 is deprecated, we can remove these exceptions and treat ios/arm64 like any other arm64 platform. This change also makes the BaseChunkIdx expression a little bit easier to read, while we're here. Fixes #46860. Change-Id: I13865f799777739109585f14f1cc49d6d57e096b Reviewed-on: https://go-review.googlesource.com/c/go/+/344401 Trust: Michael Knyszek Run-TryBot: Michael Knyszek TryBot-Result: Gopher Robot Reviewed-by: Cherry Mui Reviewed-by: Austin Clements --- src/runtime/export_test.go | 14 +++++++++++++- src/runtime/malloc.go | 20 +++++++++++++------- src/runtime/mgcscavenge_test.go | 5 ++++- src/runtime/mpagealloc_32bit.go | 8 +------- src/runtime/mpagealloc_64bit.go | 4 +--- src/runtime/mpagealloc_test.go | 9 +++++++-- src/runtime/mpagecache_test.go | 5 ++++- 7 files changed, 43 insertions(+), 22 deletions(-) diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go index ef601f770c..4a03f24ded 100644 --- a/src/runtime/export_test.go +++ b/src/runtime/export_test.go @@ -1048,7 +1048,19 @@ func FreePageAlloc(pp *PageAlloc) { // // This should not be higher than 0x100*pallocChunkBytes to support // mips and mipsle, which only have 31-bit address spaces. -var BaseChunkIdx = ChunkIdx(chunkIndex(((0xc000*pageAlloc64Bit + 0x100*pageAlloc32Bit) * pallocChunkBytes) + arenaBaseOffset*goos.IsAix)) +var BaseChunkIdx = func() ChunkIdx { + var prefix uintptr + if pageAlloc64Bit != 0 { + prefix = 0xc000 + } else { + prefix = 0x100 + } + baseAddr := prefix * pallocChunkBytes + if goos.IsAix != 0 { + baseAddr += arenaBaseOffset + } + return ChunkIdx(chunkIndex(baseAddr)) +}() // PageBase returns an address given a chunk index and a page index // relative to that chunk. diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go index e267e2df23..6ed6ceade2 100644 --- a/src/runtime/malloc.go +++ b/src/runtime/malloc.go @@ -201,15 +201,21 @@ const ( // we further limit it to 31 bits. // // On ios/arm64, although 64-bit pointers are presumably - // available, pointers are truncated to 33 bits. Furthermore, - // only the top 4 GiB of the address space are actually available - // to the application, but we allow the whole 33 bits anyway for - // simplicity. - // TODO(mknyszek): Consider limiting it to 32 bits and using - // arenaBaseOffset to offset into the top 4 GiB. + // available, pointers are truncated to 33 bits in iOS <14. + // Furthermore, only the top 4 GiB of the address space are + // actually available to the application. In iOS >=14, more + // of the address space is available, and the OS can now + // provide addresses outside of those 33 bits. Pick 40 bits + // as a reasonable balance between address space usage by the + // page allocator, and flexibility for what mmap'd regions + // we'll accept for the heap. We can't just move to the full + // 48 bits because this uses too much address space for older + // iOS versions. + // TODO(mknyszek): Once iOS <14 is deprecated, promote ios/arm64 + // to a 48-bit address space like every other arm64 platform. // // WebAssembly currently has a limit of 4GB linear memory. - heapAddrBits = (_64bit*(1-goarch.IsWasm)*(1-goos.IsIos*goarch.IsArm64))*48 + (1-_64bit+goarch.IsWasm)*(32-(goarch.IsMips+goarch.IsMipsle)) + 33*goos.IsIos*goarch.IsArm64 + heapAddrBits = (_64bit*(1-goarch.IsWasm)*(1-goos.IsIos*goarch.IsArm64))*48 + (1-_64bit+goarch.IsWasm)*(32-(goarch.IsMips+goarch.IsMipsle)) + 40*goos.IsIos*goarch.IsArm64 // maxAlloc is the maximum size of an allocation. On 64-bit, // it's theoretically possible to allocate 1< Date: Sun, 5 Dec 2021 16:39:20 +0000 Subject: [PATCH 398/752] src/cmd/go/internal/work: lock Builder output mutex consistently To prevent interleaving of output when 'go build' compiles several packages in parallel, the output mutex in the Builder struct must be locked around any calls to Builder.Print which could generate arbitrary amounts of text (ie more than is guaranteed to be written atomically to a pipe). Fixes #49987 For #49338 Change-Id: I7947df57667deeff3f03f231824298d823f8a943 Reviewed-on: https://go-review.googlesource.com/c/go/+/369018 Reviewed-by: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Trust: Russ Cox --- src/cmd/go/internal/work/buildid.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/cmd/go/internal/work/buildid.go b/src/cmd/go/internal/work/buildid.go index 4e9189a363..76335e9bb1 100644 --- a/src/cmd/go/internal/work/buildid.go +++ b/src/cmd/go/internal/work/buildid.go @@ -570,6 +570,8 @@ func showStdout(b *Builder, c *cache.Cache, actionID cache.ActionID, key string) b.Showcmd("", "%s # internal", joinUnambiguously(str.StringList("cat", c.OutputFile(stdoutEntry.OutputID)))) } if !cfg.BuildN { + b.output.Lock() + defer b.output.Unlock() b.Print(string(stdout)) } } @@ -578,6 +580,8 @@ func showStdout(b *Builder, c *cache.Cache, actionID cache.ActionID, key string) // flushOutput flushes the output being queued in a. func (b *Builder) flushOutput(a *Action) { + b.output.Lock() + defer b.output.Unlock() b.Print(string(a.output)) a.output = nil } From 9ecb853cf2252f3cd9ed2e7b3401d17df2d1ab06 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Mon, 6 Dec 2021 13:33:54 -0500 Subject: [PATCH 399/752] doc/go1.18: minor tweaks to generics section This CL reorders the bullet points in the generics section to more closely match what I think users will consider most important. I put the ~ token before the mention of ~T in interfaces to avoid a forward reference, though I wonder if we actually want to spent a couple more sentences saying what union and ~T types are, since most people are going to care about that a lot more than they care about the low-level detail that there's a new token. For #47694. Change-Id: Ib84f096ef6346a711801268ce362b64fa423d3f2 Reviewed-on: https://go-review.googlesource.com/c/go/+/369734 Trust: Austin Clements Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index e4e0d2300d..15cec4e1f0 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -41,10 +41,6 @@ Do not send CLs removing the interior tags from such phrases. For details see the language spec.

      -
    • - The new token ~ is added to the set of - operators and punctuation. -
    • The syntax for Function and @@ -52,6 +48,14 @@ Do not send CLs removing the interior tags from such phrases. now accepts type parameters.
      • +
    • + Parameterized functions and types can be instantiated by following them with a list of + type arguments in square brackets. +
      • +
    • + The new token ~ has been added to the set of + operators and punctuation. +
    • The syntax for Interface types @@ -60,10 +64,6 @@ Do not send CLs removing the interior tags from such phrases. as type constraints. An interface now defines a set of types as well as a set of methods.
      • -
    • - Parameterized functions and types can be instantiated by following them with a list of - type arguments in square brackets. -
    • The new predeclared identifier From 0bbb74b5ac8c01def959ef2e32ac3295d4f2707e Mon Sep 17 00:00:00 2001 From: Jeremy Faller Date: Thu, 2 Dec 2021 13:22:46 -0500 Subject: [PATCH 400/752] doc/go1.18: add changes to regexp to release notes CL 354569 Updates #47694 Change-Id: I78536c110215b3c9f247c1420bcaa5fc3d8fb930 Reviewed-on: https://go-review.googlesource.com/c/go/+/368795 Trust: Jeremy Faller Run-TryBot: Jeremy Faller Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 15cec4e1f0..82facf3845 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -696,7 +696,8 @@ Do not send CLs removing the interior tags from such phrases.
      regexp

      - TODO: https://golang.org/cl/354569: document and implement that invalid UTF-8 bytes are the same as U+FFFD + regexp + now treats each invalid byte of a UTF-8 string as U+FFFD.

      From 1c4cf50e113f402eb6986a2007cd9c820b1bb69f Mon Sep 17 00:00:00 2001 From: Jeremy Faller Date: Thu, 2 Dec 2021 13:41:37 -0500 Subject: [PATCH 401/752] doc/go1.18: add docs for js.Wrapper's removal CL 356430 Updates #47694 Change-Id: I802cd50f2827caa0549c25685c0b1bb8dfc40968 Reviewed-on: https://go-review.googlesource.com/c/go/+/368799 Trust: Jeremy Faller Run-TryBot: Jeremy Faller Reviewed-by: Cherry Mui --- doc/go1.18.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 82facf3845..818f7c7dcb 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -769,7 +769,7 @@ Do not send CLs removing the interior tags from such phrases.
      syscall/js

      - TODO: https://golang.org/cl/356430: remove Wrapper interface + Wrapper interface has been removed.

      From 870f33f6efcbb5db7b556cbe3438aa7925270825 Mon Sep 17 00:00:00 2001 From: Jeremy Faller Date: Thu, 2 Dec 2021 13:26:51 -0500 Subject: [PATCH 402/752] doc/go1.18: add changes to strconv.Unquote to release notes CL 343877 Updates #47694 Change-Id: I37a0a0d1f7ab937b12812981ecddc89eb8c99c24 Reviewed-on: https://go-review.googlesource.com/c/go/+/368796 Trust: Jeremy Faller Run-TryBot: Jeremy Faller Reviewed-by: Joe Tsai --- doc/go1.18.html | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 818f7c7dcb..7a4869cf6a 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -705,7 +705,8 @@ Do not send CLs removing the interior tags from such phrases.
      strconv

      - TODO: https://golang.org/cl/343877: reject surrogate halves in Unquote + strconv.Unquote + now rejects Unicode surrogate halves.

      From d16a57542a83adfb8182508291ddcfe99c406818 Mon Sep 17 00:00:00 2001 From: Jeremy Faller Date: Thu, 2 Dec 2021 13:33:18 -0500 Subject: [PATCH 403/752] doc/go1.18: add new sync.[RW]Mutex methods CL 319769 Updates #47694 Change-Id: I9655af0d249926617645c33617d53b73f985aa19 Reviewed-on: https://go-review.googlesource.com/c/go/+/368797 Trust: Jeremy Faller Run-TryBot: Jeremy Faller Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 7a4869cf6a..77c26bc257 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -740,7 +740,11 @@ Do not send CLs removing the interior tags from such phrases.
      sync

      - TODO: https://golang.org/cl/319769: add Mutex.TryLock, RWMutex.TryLock, RWMutex.TryRLock + The new methods + Mutex.TryLock, + RWMutex.TryLock, and + RWMutex.TryRLock, + will acquire the lock if it is not currently held.

      From 6180c4f5ebae4635377dfa778e05097cf8fc69a8 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Tue, 23 Nov 2021 17:02:10 -0500 Subject: [PATCH 404/752] log/syslog: create unix sockets in unique directories startServer was invoking os.Remove on the temporary file for a unix socket after creating it. Since the files were created in the global temp directory, that could cause two tests to arrive at colliding names. (Noticed while looking into the failure at https://storage.googleapis.com/go-build-log/af2c83b1/solaris-amd64-oraclerel_3e01fda8.log, but I would be surprised if this solves that failure.) This change uses unique temporary directories, and attempts to keep name lengths minimal to avoid accidentally running into socket-name length limitations. Updates #34611 Change-Id: I21743f245e5c14645e03f09795013e058b984471 Reviewed-on: https://go-review.googlesource.com/c/go/+/366774 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/log/syslog/syslog_test.go | 96 ++++++++++++++++++++--------------- 1 file changed, 56 insertions(+), 40 deletions(-) diff --git a/src/log/syslog/syslog_test.go b/src/log/syslog/syslog_test.go index 26530480ee..de1681d653 100644 --- a/src/log/syslog/syslog_test.go +++ b/src/log/syslog/syslog_test.go @@ -10,9 +10,9 @@ import ( "bufio" "fmt" "io" - "log" "net" "os" + "path/filepath" "runtime" "sync" "testing" @@ -81,28 +81,36 @@ func runStreamSyslog(l net.Listener, done chan<- string, wg *sync.WaitGroup) { } } -func startServer(n, la string, done chan<- string) (addr string, sock io.Closer, wg *sync.WaitGroup) { +func startServer(t *testing.T, n, la string, done chan<- string) (addr string, sock io.Closer, wg *sync.WaitGroup) { if n == "udp" || n == "tcp" { la = "127.0.0.1:0" } else { - // unix and unixgram: choose an address if none given + // unix and unixgram: choose an address if none given. if la == "" { - // use os.CreateTemp to get a name that is unique - f, err := os.CreateTemp("", "syslogtest") + // The address must be short to fit in the sun_path field of the + // sockaddr_un passed to the underlying system calls, so we use + // os.MkdirTemp instead of t.TempDir: t.TempDir generally includes all or + // part of the test name in the directory, which can be much more verbose + // and risks running up against the limit. + dir, err := os.MkdirTemp("", "") if err != nil { - log.Fatal("TempFile: ", err) + t.Fatal(err) } - f.Close() - la = f.Name() + t.Cleanup(func() { + if err := os.RemoveAll(dir); err != nil { + t.Errorf("failed to remove socket temp directory: %v", err) + } + }) + la = filepath.Join(dir, "sock") } - os.Remove(la) } wg = new(sync.WaitGroup) if n == "udp" || n == "unixgram" { l, e := net.ListenPacket(n, la) if e != nil { - log.Fatalf("startServer failed: %v", e) + t.Helper() + t.Fatalf("startServer failed: %v", e) } addr = l.LocalAddr().String() sock = l @@ -114,7 +122,8 @@ func startServer(n, la string, done chan<- string) (addr string, sock io.Closer, } else { l, e := net.Listen(n, la) if e != nil { - log.Fatalf("startServer failed: %v", e) + t.Helper() + t.Fatalf("startServer failed: %v", e) } addr = l.Addr().String() sock = l @@ -129,32 +138,35 @@ func startServer(n, la string, done chan<- string) (addr string, sock io.Closer, func TestWithSimulated(t *testing.T) { t.Parallel() - msg := "Test 123" - var transport []string - for _, n := range []string{"unix", "unixgram", "udp", "tcp"} { - if testableNetwork(n) { - transport = append(transport, n) - } - } - for _, tr := range transport { - done := make(chan string) - addr, sock, srvWG := startServer(tr, "", done) - defer srvWG.Wait() - defer sock.Close() - if tr == "unix" || tr == "unixgram" { - defer os.Remove(addr) + msg := "Test 123" + for _, tr := range []string{"unix", "unixgram", "udp", "tcp"} { + if !testableNetwork(tr) { + continue } - s, err := Dial(tr, addr, LOG_INFO|LOG_USER, "syslog_test") - if err != nil { - t.Fatalf("Dial() failed: %v", err) - } - err = s.Info(msg) - if err != nil { - t.Fatalf("log failed: %v", err) - } - check(t, msg, <-done, tr) - s.Close() + + tr := tr + t.Run(tr, func(t *testing.T) { + t.Parallel() + + done := make(chan string) + addr, sock, srvWG := startServer(t, tr, "", done) + defer srvWG.Wait() + defer sock.Close() + if tr == "unix" || tr == "unixgram" { + defer os.Remove(addr) + } + s, err := Dial(tr, addr, LOG_INFO|LOG_USER, "syslog_test") + if err != nil { + t.Fatalf("Dial() failed: %v", err) + } + err = s.Info(msg) + if err != nil { + t.Fatalf("log failed: %v", err) + } + check(t, msg, <-done, tr) + s.Close() + }) } } @@ -165,7 +177,7 @@ func TestFlap(t *testing.T) { } done := make(chan string) - addr, sock, srvWG := startServer(net, "", done) + addr, sock, srvWG := startServer(t, net, "", done) defer srvWG.Wait() defer os.Remove(addr) defer sock.Close() @@ -182,7 +194,10 @@ func TestFlap(t *testing.T) { check(t, msg, <-done, net) // restart the server - _, sock2, srvWG2 := startServer(net, addr, done) + if err := os.Remove(addr); err != nil { + t.Fatal(err) + } + _, sock2, srvWG2 := startServer(t, net, addr, done) defer srvWG2.Wait() defer sock2.Close() @@ -282,6 +297,7 @@ func check(t *testing.T, in, out, transport string) { func TestWrite(t *testing.T) { t.Parallel() + tests := []struct { pri Priority pre string @@ -299,7 +315,7 @@ func TestWrite(t *testing.T) { } else { for _, test := range tests { done := make(chan string) - addr, sock, srvWG := startServer("udp", "", done) + addr, sock, srvWG := startServer(t, "udp", "", done) defer srvWG.Wait() defer sock.Close() l, err := Dial("udp", addr, test.pri, test.pre) @@ -323,7 +339,7 @@ func TestWrite(t *testing.T) { } func TestConcurrentWrite(t *testing.T) { - addr, sock, srvWG := startServer("udp", "", make(chan string, 1)) + addr, sock, srvWG := startServer(t, "udp", "", make(chan string, 1)) defer srvWG.Wait() defer sock.Close() w, err := Dial("udp", addr, LOG_USER|LOG_ERR, "how's it going?") @@ -359,7 +375,7 @@ func TestConcurrentReconnect(t *testing.T) { } } done := make(chan string, N*M) - addr, sock, srvWG := startServer(net, "", done) + addr, sock, srvWG := startServer(t, net, "", done) if net == "unix" { defer os.Remove(addr) } From 8ea0ffb84a5807438061d34256448df9948a3809 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 3 Dec 2021 17:09:06 -0500 Subject: [PATCH 405/752] net: clarify that conn.LocalAddr and conn.RemoteAddr might not be known For #34611 Change-Id: I9a1357f53124c98ad017b58774696d0377dbea27 Reviewed-on: https://go-review.googlesource.com/c/go/+/369160 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/net/net.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/net/net.go b/src/net/net.go index ab6aeaac2f..77e54a9125 100644 --- a/src/net/net.go +++ b/src/net/net.go @@ -125,10 +125,10 @@ type Conn interface { // Any blocked Read or Write operations will be unblocked and return errors. Close() error - // LocalAddr returns the local network address. + // LocalAddr returns the local network address, if known. LocalAddr() Addr - // RemoteAddr returns the remote network address. + // RemoteAddr returns the remote network address, if known. RemoteAddr() Addr // SetDeadline sets the read and write deadlines associated @@ -328,7 +328,7 @@ type PacketConn interface { // Any blocked ReadFrom or WriteTo operations will be unblocked and return errors. Close() error - // LocalAddr returns the local network address. + // LocalAddr returns the local network address, if known. LocalAddr() Addr // SetDeadline sets the read and write deadlines associated From 871d63fb73476bc3bf52ceec9aa8bef3ffc85d51 Mon Sep 17 00:00:00 2001 From: Michael Anthony Knyszek Date: Mon, 6 Dec 2021 17:35:58 -0500 Subject: [PATCH 406/752] runtime: call runtime.GC in several tests that disable GC These tests disable GC because of the potential for a deadlock, but don't consider that a GC could be in progress due to other tests. The likelihood of this case was increased when the minimum heap size was lowered during the Go 1.18 cycle. The issue was then mitigated by CL 368137 but in theory is always a problem. This change is intended specifically for #45867, but I just walked over a whole bunch of other tests that don't take this precaution where it seems like it could be relevant (some tests it's not, like the UserForcedGC test, or testprogs where no other code has run before it). Fixes #45867. Change-Id: I6a1b4ae73e05cab5a0b2d2cce14126bd13be0ba5 Reviewed-on: https://go-review.googlesource.com/c/go/+/369747 Reviewed-by: Michael Pratt Reviewed-by: David Chase Trust: Michael Knyszek Run-TryBot: Michael Knyszek TryBot-Result: Gopher Robot --- src/runtime/proc_test.go | 9 +++++++++ src/runtime/testdata/testprog/badtraceback.go | 3 +++ src/runtime/testdata/testprog/preempt.go | 3 +++ 3 files changed, 15 insertions(+) diff --git a/src/runtime/proc_test.go b/src/runtime/proc_test.go index 53cafe8907..9198022ace 100644 --- a/src/runtime/proc_test.go +++ b/src/runtime/proc_test.go @@ -119,6 +119,9 @@ func TestGoroutineParallelism(t *testing.T) { // since the goroutines can't be stopped/preempted. // Disable GC for this test (see issue #10958). defer debug.SetGCPercent(debug.SetGCPercent(-1)) + // Now that GCs are disabled, block until any outstanding GCs + // are also done. + runtime.GC() for try := 0; try < N; try++ { done := make(chan bool) x := uint32(0) @@ -163,6 +166,9 @@ func testGoroutineParallelism2(t *testing.T, load, netpoll bool) { // since the goroutines can't be stopped/preempted. // Disable GC for this test (see issue #10958). defer debug.SetGCPercent(debug.SetGCPercent(-1)) + // Now that GCs are disabled, block until any outstanding GCs + // are also done. + runtime.GC() for try := 0; try < N; try++ { if load { // Create P goroutines and wait until they all run. @@ -623,6 +629,9 @@ func TestSchedLocalQueueEmpty(t *testing.T) { // If runtime triggers a forced GC during this test then it will deadlock, // since the goroutines can't be stopped/preempted during spin wait. defer debug.SetGCPercent(debug.SetGCPercent(-1)) + // Now that GCs are disabled, block until any outstanding GCs + // are also done. + runtime.GC() iters := int(1e5) if testing.Short() { diff --git a/src/runtime/testdata/testprog/badtraceback.go b/src/runtime/testdata/testprog/badtraceback.go index d558adceec..09aa2b877e 100644 --- a/src/runtime/testdata/testprog/badtraceback.go +++ b/src/runtime/testdata/testprog/badtraceback.go @@ -17,6 +17,9 @@ func init() { func BadTraceback() { // Disable GC to prevent traceback at unexpected time. debug.SetGCPercent(-1) + // Out of an abundance of caution, also make sure that there are + // no GCs actively in progress. + runtime.GC() // Run badLR1 on its own stack to minimize the stack size and // exercise the stack bounds logic in the hex dump. diff --git a/src/runtime/testdata/testprog/preempt.go b/src/runtime/testdata/testprog/preempt.go index 1c74d0e435..eb9f59053c 100644 --- a/src/runtime/testdata/testprog/preempt.go +++ b/src/runtime/testdata/testprog/preempt.go @@ -20,6 +20,9 @@ func AsyncPreempt() { runtime.GOMAXPROCS(1) // Disable GC so we have complete control of what we're testing. debug.SetGCPercent(-1) + // Out of an abundance of caution, also make sure that there are + // no GCs actively in progress. + runtime.GC() // Start a goroutine with no sync safe-points. var ready, ready2 uint32 From 79b425e9fca11d189142504bc81cf4e009092f6d Mon Sep 17 00:00:00 2001 From: Dmitri Shuralyov Date: Mon, 6 Dec 2021 18:05:53 -0500 Subject: [PATCH 407/752] misc/cgo/testplugin: remove skip in TestIssue25756pie Though this was a problem for Go 1.17, it appears not to be a problem on tip. This reverts change made in CL 321349. For #46239. Change-Id: Ie4d6649fbabce3bb2c1cf04d97760ba6ceadaca5 Reviewed-on: https://go-review.googlesource.com/c/go/+/369752 Run-TryBot: Dmitri Shuralyov Reviewed-by: Cherry Mui TryBot-Result: Gopher Robot Trust: Dmitri Shuralyov --- misc/cgo/testplugin/plugin_test.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/misc/cgo/testplugin/plugin_test.go b/misc/cgo/testplugin/plugin_test.go index 9697dbf7a7..a6accc1dfb 100644 --- a/misc/cgo/testplugin/plugin_test.go +++ b/misc/cgo/testplugin/plugin_test.go @@ -265,10 +265,6 @@ func TestIssue25756(t *testing.T) { // Test with main using -buildmode=pie with plugin for issue #43228 func TestIssue25756pie(t *testing.T) { - if os.Getenv("GO_BUILDER_NAME") == "darwin-arm64-11_0-toothrot" { - t.Skip("broken on darwin/arm64 builder in sharded mode; see issue 46239") - } - goCmd(t, "build", "-buildmode=plugin", "-o", "life.so", "./issue25756/plugin") goCmd(t, "build", "-buildmode=pie", "-o", "issue25756pie.exe", "./issue25756/main.go") run(t, "./issue25756pie.exe") From 6f65d470d8b688573891420f7a428191d8c6cd49 Mon Sep 17 00:00:00 2001 From: Michael Anthony Knyszek Date: Mon, 6 Dec 2021 17:53:35 -0500 Subject: [PATCH 408/752] runtime: clean up redundant calls to SetGCPercent in debug_test.go SetGCPercent(-1) is called by several tests in debug_test.go (followed by a call to runtime.GC) due to #49370. However, startDebugCallWorker already actually has this, just without the runtime.GC call (allowing an in-progress GC to still mess up the test). This CL consolidates SetGCPercent into startDebugDebugCallWorker where applicable. Change-Id: Ifa12d6a911f1506e252d3ddf03004cf2ab3f4ee4 Reviewed-on: https://go-review.googlesource.com/c/go/+/369751 Trust: Michael Knyszek Run-TryBot: Michael Knyszek TryBot-Result: Gopher Robot Reviewed-by: David Chase --- src/runtime/debug_test.go | 35 +++++------------------------------ 1 file changed, 5 insertions(+), 30 deletions(-) diff --git a/src/runtime/debug_test.go b/src/runtime/debug_test.go index 89ea577d64..44585b1744 100644 --- a/src/runtime/debug_test.go +++ b/src/runtime/debug_test.go @@ -34,12 +34,15 @@ func startDebugCallWorker(t *testing.T) (g *runtime.G, after func()) { skipUnderDebugger(t) // This can deadlock if there aren't enough threads or if a GC - // tries to interrupt an atomic loop (see issue #10958). We + // tries to interrupt an atomic loop (see issue #10958). A GC + // could also actively be in progress (see issue #49370), so we + // need to call runtime.GC to block until it has complete. We // use 8 Ps so there's room for the debug call worker, // something that's trying to preempt the call worker, and the // goroutine that's trying to stop the call worker. ogomaxprocs := runtime.GOMAXPROCS(8) ogcpercent := debug.SetGCPercent(-1) + runtime.GC() // ready is a buffered channel so debugCallWorker won't block // on sending to it. This makes it less likely we'll catch @@ -114,13 +117,6 @@ func skipUnderDebugger(t *testing.T) { } func TestDebugCall(t *testing.T) { - // InjectDebugCall cannot be executed while a GC is actively in - // progress. Wait until the current GC is done, and turn it off. - // - // See #49370. - runtime.GC() - defer debug.SetGCPercent(debug.SetGCPercent(-1)) - g, after := startDebugCallWorker(t) defer after() @@ -172,13 +168,6 @@ func TestDebugCall(t *testing.T) { } func TestDebugCallLarge(t *testing.T) { - // InjectDebugCall cannot be executed while a GC is actively in - // progress. Wait until the current GC is done, and turn it off. - // - // See #49370. - runtime.GC() - defer debug.SetGCPercent(debug.SetGCPercent(-1)) - g, after := startDebugCallWorker(t) defer after() @@ -208,13 +197,6 @@ func TestDebugCallLarge(t *testing.T) { } func TestDebugCallGC(t *testing.T) { - // InjectDebugCall cannot be executed while a GC is actively in - // progress. Wait until the current GC is done, and turn it off. - // - // See #49370. - runtime.GC() - defer debug.SetGCPercent(debug.SetGCPercent(-1)) - g, after := startDebugCallWorker(t) defer after() @@ -225,13 +207,6 @@ func TestDebugCallGC(t *testing.T) { } func TestDebugCallGrowStack(t *testing.T) { - // InjectDebugCall cannot be executed while a GC is actively in - // progress. Wait until the current GC is done, and turn it off. - // - // See #49370. - runtime.GC() - defer debug.SetGCPercent(debug.SetGCPercent(-1)) - g, after := startDebugCallWorker(t) defer after() @@ -294,7 +269,7 @@ func TestDebugCallPanic(t *testing.T) { // InjectDebugCall cannot be executed while a GC is actively in // progress. Wait until the current GC is done, and turn it off. // - // See #49370. + // See #10958 and #49370. runtime.GC() defer debug.SetGCPercent(debug.SetGCPercent(-1)) From 0eb39ca1f0ca118e78648fb6844d35d0a96e5eee Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Mon, 6 Dec 2021 18:41:49 -0500 Subject: [PATCH 409/752] cmd/dist: enable plugin test on Linux/ARM64 The test was skipped because with the old gold linker on the builder it fails with an internal error in gold. The builders now have gold 2.31 and the test passes. Enable it. Fixes #17138. Change-Id: Ia0054030dd12f1d003c7420bf7ed8b112715baa9 Reviewed-on: https://go-review.googlesource.com/c/go/+/369814 Trust: Cherry Mui Run-TryBot: Cherry Mui Reviewed-by: Than McIntosh TryBot-Result: Gopher Robot --- src/cmd/dist/test.go | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go index aea1ee6f25..50a2e5936c 100644 --- a/src/cmd/dist/test.go +++ b/src/cmd/dist/test.go @@ -1043,10 +1043,8 @@ func (t *tester) supportedBuildmode(mode string) bool { } return false case "plugin": - // linux-arm64 is missing because it causes the external linker - // to crash, see https://golang.org/issue/17138 switch pair { - case "linux-386", "linux-amd64", "linux-arm", "linux-s390x", "linux-ppc64le": + case "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-s390x", "linux-ppc64le": return true case "darwin-amd64", "darwin-arm64": return true From e07b02ff87af594a68484dcb1e3a78d1c39abc56 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Tue, 23 Nov 2021 10:27:30 -0500 Subject: [PATCH 410/752] net: in (*netFD).dial, use the passed in local address if getsockname fails 'man getsockname' lists a number of possible failure modes, including ENOBUFS (for resource exhaustion) and EBADF (which we could possibly see in the event of a bug or race condition elsewhere in the program). If getsockname fails for an explicit user-provided local address, the user is probably not expecting LocalAddr on the returned net.Conn to return nil. This may or may not fix #34611, but should at least help us diagnose it more clearly. While we're add it, also add more nil-checking logic in the test based on the stack traces posted to https://golang.org/issue/34611#issuecomment-975923748. For #34611 Change-Id: Iba870b96787811e4b9959b74ef648afce9316602 Reviewed-on: https://go-review.googlesource.com/c/go/+/366536 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Ian Lance Taylor TryBot-Result: Gopher Robot --- src/net/server_test.go | 10 +++++++++- src/net/sock_posix.go | 16 +++++++++++----- 2 files changed, 20 insertions(+), 6 deletions(-) diff --git a/src/net/server_test.go b/src/net/server_test.go index 33d33b0337..b69cd29289 100644 --- a/src/net/server_test.go +++ b/src/net/server_test.go @@ -200,9 +200,17 @@ func TestUnixAndUnixpacketServer(t *testing.T) { if c == nil { panic("Dial returned a nil Conn") } - if rc := reflect.ValueOf(c); rc.Kind() == reflect.Pointer && rc.IsNil() { + rc := reflect.ValueOf(c) + if rc.IsNil() { panic(fmt.Sprintf("Dial returned a nil %T", c)) } + fd := rc.Elem().FieldByName("fd") + if fd.IsNil() { + panic(fmt.Sprintf("Dial returned a %T with a nil fd", c)) + } + if addr := fd.Elem().FieldByName("laddr"); addr.IsNil() { + panic(fmt.Sprintf("Dial returned a %T whose fd has a nil laddr", c)) + } addr := c.LocalAddr() if addr == nil { panic(fmt.Sprintf("(%T).LocalAddr returned a nil Addr", c)) diff --git a/src/net/sock_posix.go b/src/net/sock_posix.go index 98a48229c7..603fb2bb64 100644 --- a/src/net/sock_posix.go +++ b/src/net/sock_posix.go @@ -156,18 +156,24 @@ func (fd *netFD) dial(ctx context.Context, laddr, raddr sockaddr, ctrlFn func(st } } // Record the local and remote addresses from the actual socket. - // Get the local address by calling Getsockname. + // For the local address, use + // 1) the one returned by Getsockname, if that succeeds; or + // 2) the one passed to us as the laddr parameter; or + // 3) nil. // For the remote address, use // 1) the one returned by the connect method, if any; or // 2) the one from Getpeername, if it succeeds; or // 3) the one passed to us as the raddr parameter. - lsa, _ = syscall.Getsockname(fd.pfd.Sysfd) + var laddrName Addr = laddr + if lsa, err := syscall.Getsockname(fd.pfd.Sysfd); err == nil { + laddrName = fd.addrFunc()(lsa) + } if crsa != nil { - fd.setAddr(fd.addrFunc()(lsa), fd.addrFunc()(crsa)) + fd.setAddr(laddrName, fd.addrFunc()(crsa)) } else if rsa, _ = syscall.Getpeername(fd.pfd.Sysfd); rsa != nil { - fd.setAddr(fd.addrFunc()(lsa), fd.addrFunc()(rsa)) + fd.setAddr(laddrName, fd.addrFunc()(rsa)) } else { - fd.setAddr(fd.addrFunc()(lsa), raddr) + fd.setAddr(laddrName, raddr) } return nil } From dc65c489cc5a795a68d844ed7a45e5d16562401d Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 6 Dec 2021 17:25:34 -0500 Subject: [PATCH 411/752] cmd/go: fix tests broken in CL 358539 CL 358539 revised the build-stamp format, and updated the git and hg tests to match. However, the fossil and bzr tests were missed, and were not caught on the builders due to the fact that none of the builder images have the necessary VCS tools installed. Updates #48802 Updates #49168 Change-Id: I6b9fd0e19b81cb539864c94ab0860f74e7be6748 Reviewed-on: https://go-review.googlesource.com/c/go/+/369743 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Russ Cox --- .../testdata/script/version_buildvcs_bzr.txt | 33 ++++++++++--------- .../script/version_buildvcs_fossil.txt | 21 +++++++----- 2 files changed, 30 insertions(+), 24 deletions(-) diff --git a/src/cmd/go/testdata/script/version_buildvcs_bzr.txt b/src/cmd/go/testdata/script/version_buildvcs_bzr.txt index 83069713d7..85db9bab6d 100644 --- a/src/cmd/go/testdata/script/version_buildvcs_bzr.txt +++ b/src/cmd/go/testdata/script/version_buildvcs_bzr.txt @@ -31,14 +31,15 @@ cd .. env PATH=$oldpath rm .bzr -# If there is an empty repository in a parent directory, only "uncommitted" is tagged. +# If there is an empty repository in a parent directory, only "modified" is tagged. exec bzr init cd a go install go version -m $GOBIN/a$GOEXE -! stdout bzrrevision -! stdout bzrcommittime -stdout '^\tbuild\tbzruncommitted\ttrue$' +stdout '^\tbuild\tvcs=bzr$' +! stdout vcs.revision +! stdout vcs.time +stdout '^\tbuild\tvcs.modified=true$' cd .. # Revision and commit time are tagged for repositories with commits. @@ -47,9 +48,10 @@ exec bzr commit -m 'initial commit' cd a go install go version -m $GOBIN/a$GOEXE -stdout '^\tbuild\tbzrrevision\t' -stdout '^\tbuild\tbzrcommittime\t' -stdout '^\tbuild\tbzruncommitted\tfalse$' +stdout '^\tbuild\tvcs=bzr$' +stdout '^\tbuild\tvcs.revision=' +stdout '^\tbuild\tvcs.time=' +stdout '^\tbuild\tvcs.modified=false$' rm $GOBIN/a$GOEXE # Building an earlier commit should still build clean. @@ -59,29 +61,30 @@ exec bzr commit -m 'add NEWS' exec bzr update -r1 go install go version -m $GOBIN/a$GOEXE -stdout '^\tbuild\tbzrrevision\t' -stdout '^\tbuild\tbzrcommittime\t' -stdout '^\tbuild\tbzruncommitted\tfalse$' +stdout '^\tbuild\tvcs=bzr$' +stdout '^\tbuild\tvcs.revision=' +stdout '^\tbuild\tvcs.time=' +stdout '^\tbuild\tvcs.modified=false$' # Building with -buildvcs=false suppresses the info. go install -buildvcs=false go version -m $GOBIN/a$GOEXE -! stdout bzrrevision +! stdout vcs.revision rm $GOBIN/a$GOEXE -# An untracked file is shown as uncommitted, even if it isn't part of the build. +# An untracked file is shown as modified, even if it isn't part of the build. cp ../../outside/empty.txt . go install go version -m $GOBIN/a$GOEXE -stdout '^\tbuild\tbzruncommitted\ttrue$' +stdout '^\tbuild\tvcs.modified=true$' rm empty.txt rm $GOBIN/a$GOEXE -# An edited file is shown as uncommitted, even if it isn't part of the build. +# An edited file is shown as modified, even if it isn't part of the build. cp ../../outside/empty.txt ../README go install go version -m $GOBIN/a$GOEXE -stdout '^\tbuild\tbzruncommitted\ttrue$' +stdout '^\tbuild\tvcs.modified=true$' exec bzr revert ../README rm $GOBIN/a$GOEXE diff --git a/src/cmd/go/testdata/script/version_buildvcs_fossil.txt b/src/cmd/go/testdata/script/version_buildvcs_fossil.txt index 3a4bde883f..720306868b 100644 --- a/src/cmd/go/testdata/script/version_buildvcs_fossil.txt +++ b/src/cmd/go/testdata/script/version_buildvcs_fossil.txt @@ -19,7 +19,7 @@ cd repo/a # If there's no local repository, there's no VCS info. go install go version -m $GOBIN/a$GOEXE -! stdout fossilrevision +! stdout vcs.revision rm $GOBIN/a$GOEXE # If there is a repository, but it can't be used for some reason, @@ -44,30 +44,33 @@ exec fossil commit -m 'initial commit' cd a go install go version -m $GOBIN/a$GOEXE -stdout '^\tbuild\tfossilrevision\t' -stdout '^\tbuild\tfossilcommittime\t' -stdout '^\tbuild\tfossiluncommitted\tfalse$' +stdout '^\tbuild\tvcs=fossil\n' +stdout '^\tbuild\tvcs.revision=' +stdout '^\tbuild\tvcs.time=' +stdout '^\tbuild\tvcs.modified=false$' rm $GOBIN/a$GOEXE # Building with -buildvcs=false suppresses the info. go install -buildvcs=false go version -m $GOBIN/a$GOEXE -! stdout fossilrevision +! stdout vcs.revision rm $GOBIN/a$GOEXE -# An untracked file is shown as uncommitted, even if it isn't part of the build. +# An untracked file is shown as modified, even if it isn't part of the build. cp ../../outside/empty.txt . go install go version -m $GOBIN/a$GOEXE -stdout '^\tbuild\tfossiluncommitted\ttrue$' +stdout '^\tbuild\tvcs=fossil\n' +stdout '^\tbuild\tvcs.modified=true$' rm empty.txt rm $GOBIN/a$GOEXE -# An edited file is shown as uncommitted, even if it isn't part of the build. +# An edited file is shown as modified, even if it isn't part of the build. cp ../../outside/empty.txt ../README go install go version -m $GOBIN/a$GOEXE -stdout '^\tbuild\tfossiluncommitted\ttrue$' +stdout '^\tbuild\tvcs=fossil\n' +stdout '^\tbuild\tvcs.modified=true$' exec fossil revert ../README rm $GOBIN/a$GOEXE From 4c943abb95578da4bfd70d365814a130da8d5aa2 Mon Sep 17 00:00:00 2001 From: Michael Anthony Knyszek Date: Tue, 7 Dec 2021 00:24:54 -0500 Subject: [PATCH 412/752] runtime: fix comments on the behavior of SetGCPercent Fixes for #49680, #49695, #45867, and #49370 all assumed that SetGCPercent(-1) doesn't block until the GC's mark phase is done, but it actually does. The cause of 3 of those 4 failures comes from the fact that at the beginning of the sweep phase, the GC does try to preempt every P once, and this may run concurrently with test code. In the fourth case, the issue was likely that only *one* of the debug_test.go tests was missing a call to SetGCPercent(-1). Just to be safe, leave a TODO there for now to remove the extraneous runtime.GC calls, but leave the calls in. Updates #49680, #49695, #45867, and #49370. Change-Id: Ibf4e64addfba18312526968bcf40f1f5d54eb3f1 Reviewed-on: https://go-review.googlesource.com/c/go/+/369815 Reviewed-by: Austin Clements Trust: Michael Knyszek Run-TryBot: Michael Knyszek TryBot-Result: Gopher Robot --- misc/cgo/test/testdata/issue9400_linux.go | 4 +++- src/runtime/debug_test.go | 23 ++++++++++++++++++----- src/runtime/proc_test.go | 15 +++++++++------ src/runtime/rwmutex_test.go | 4 +++- src/runtime/testdata/testprog/preempt.go | 3 ++- 5 files changed, 35 insertions(+), 14 deletions(-) diff --git a/misc/cgo/test/testdata/issue9400_linux.go b/misc/cgo/test/testdata/issue9400_linux.go index 47f224dc4f..051b9ab0bb 100644 --- a/misc/cgo/test/testdata/issue9400_linux.go +++ b/misc/cgo/test/testdata/issue9400_linux.go @@ -50,7 +50,9 @@ func test9400(t *testing.T) { // Disable GC for the duration of the test. // This avoids a potential GC deadlock when spinning in uninterruptable ASM below #49695. defer debug.SetGCPercent(debug.SetGCPercent(-1)) - // And finish any pending GC after we pause, if any. + // SetGCPercent waits until the mark phase is over, but the runtime + // also preempts at the start of the sweep phase, so make sure that's + // done too. See #49695. runtime.GC() // Temporarily rewind the stack and trigger SIGSETXID diff --git a/src/runtime/debug_test.go b/src/runtime/debug_test.go index 44585b1744..5bb0c5cee3 100644 --- a/src/runtime/debug_test.go +++ b/src/runtime/debug_test.go @@ -34,10 +34,17 @@ func startDebugCallWorker(t *testing.T) (g *runtime.G, after func()) { skipUnderDebugger(t) // This can deadlock if there aren't enough threads or if a GC - // tries to interrupt an atomic loop (see issue #10958). A GC - // could also actively be in progress (see issue #49370), so we - // need to call runtime.GC to block until it has complete. We - // use 8 Ps so there's room for the debug call worker, + // tries to interrupt an atomic loop (see issue #10958). Execute + // an extra GC to ensure even the sweep phase is done (out of + // caution to prevent #49370 from happening). + // TODO(mknyszek): This extra GC cycle is likely unnecessary + // because preemption (which may happen during the sweep phase) + // isn't much of an issue anymore thanks to asynchronous preemption. + // The biggest risk is having a write barrier in the debug call + // injection test code fire, because it runs in a signal handler + // and may not have a P. + // + // We use 8 Ps so there's room for the debug call worker, // something that's trying to preempt the call worker, and the // goroutine that's trying to stop the call worker. ogomaxprocs := runtime.GOMAXPROCS(8) @@ -270,8 +277,14 @@ func TestDebugCallPanic(t *testing.T) { // progress. Wait until the current GC is done, and turn it off. // // See #10958 and #49370. - runtime.GC() defer debug.SetGCPercent(debug.SetGCPercent(-1)) + // TODO(mknyszek): This extra GC cycle is likely unnecessary + // because preemption (which may happen during the sweep phase) + // isn't much of an issue anymore thanks to asynchronous preemption. + // The biggest risk is having a write barrier in the debug call + // injection test code fire, because it runs in a signal handler + // and may not have a P. + runtime.GC() ready := make(chan *runtime.G) var stop uint32 diff --git a/src/runtime/proc_test.go b/src/runtime/proc_test.go index 9198022ace..cc899a24c6 100644 --- a/src/runtime/proc_test.go +++ b/src/runtime/proc_test.go @@ -119,8 +119,9 @@ func TestGoroutineParallelism(t *testing.T) { // since the goroutines can't be stopped/preempted. // Disable GC for this test (see issue #10958). defer debug.SetGCPercent(debug.SetGCPercent(-1)) - // Now that GCs are disabled, block until any outstanding GCs - // are also done. + // SetGCPercent waits until the mark phase is over, but the runtime + // also preempts at the start of the sweep phase, so make sure that's + // done too. See #45867. runtime.GC() for try := 0; try < N; try++ { done := make(chan bool) @@ -166,8 +167,9 @@ func testGoroutineParallelism2(t *testing.T, load, netpoll bool) { // since the goroutines can't be stopped/preempted. // Disable GC for this test (see issue #10958). defer debug.SetGCPercent(debug.SetGCPercent(-1)) - // Now that GCs are disabled, block until any outstanding GCs - // are also done. + // SetGCPercent waits until the mark phase is over, but the runtime + // also preempts at the start of the sweep phase, so make sure that's + // done too. See #45867. runtime.GC() for try := 0; try < N; try++ { if load { @@ -629,8 +631,9 @@ func TestSchedLocalQueueEmpty(t *testing.T) { // If runtime triggers a forced GC during this test then it will deadlock, // since the goroutines can't be stopped/preempted during spin wait. defer debug.SetGCPercent(debug.SetGCPercent(-1)) - // Now that GCs are disabled, block until any outstanding GCs - // are also done. + // SetGCPercent waits until the mark phase is over, but the runtime + // also preempts at the start of the sweep phase, so make sure that's + // done too. See #45867. runtime.GC() iters := int(1e5) diff --git a/src/runtime/rwmutex_test.go b/src/runtime/rwmutex_test.go index 33ddd7d1d5..f15d367b32 100644 --- a/src/runtime/rwmutex_test.go +++ b/src/runtime/rwmutex_test.go @@ -55,7 +55,9 @@ func TestParallelRWMutexReaders(t *testing.T) { // since the goroutines can't be stopped/preempted. // Disable GC for this test (see issue #10958). defer debug.SetGCPercent(debug.SetGCPercent(-1)) - // Finish any in-progress GCs and get ourselves to a clean slate. + // SetGCPercent waits until the mark phase is over, but the runtime + // also preempts at the start of the sweep phase, so make sure that's + // done too. GC() doTestParallelReaders(1) diff --git a/src/runtime/testdata/testprog/preempt.go b/src/runtime/testdata/testprog/preempt.go index eb9f59053c..fb6755a372 100644 --- a/src/runtime/testdata/testprog/preempt.go +++ b/src/runtime/testdata/testprog/preempt.go @@ -21,7 +21,8 @@ func AsyncPreempt() { // Disable GC so we have complete control of what we're testing. debug.SetGCPercent(-1) // Out of an abundance of caution, also make sure that there are - // no GCs actively in progress. + // no GCs actively in progress. The sweep phase of a GC cycle + // for instance tries to preempt Ps at the very beginning. runtime.GC() // Start a goroutine with no sync safe-points. From e5ba7d3abf1e356f8cb7d760f95a389dd08c63ae Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 6 Dec 2021 22:09:12 -0500 Subject: [PATCH 413/752] net/http: remove arbitrary timeout in TestServerHijackGetsBackgroundByte_big This test fails with "timeout" once per couple of months. It may be that the arbitrary timeout is too short, or it may be that the test is detecting a real bug (perhaps a deadlock) and reporting it without sufficient information to debug. Either way, the arbitrary timeout is doing only harm: either it is too short, or it is preventing us from getting a useful goroutine dump when the test inevitably times out. Fixes #35498 (hopefully). Change-Id: Ic6bbb1ef8df2c111b9888ba9903f58633e7cb95d Reviewed-on: https://go-review.googlesource.com/c/go/+/369854 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor Reviewed-by: Damien Neil --- src/net/http/serve_test.go | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go index 82c1a6716f..d46400ef75 100644 --- a/src/net/http/serve_test.go +++ b/src/net/http/serve_test.go @@ -5998,11 +5998,7 @@ func TestServerHijackGetsBackgroundByte_big(t *testing.T) { t.Fatal(err) } - select { - case <-done: - case <-time.After(2 * time.Second): - t.Error("timeout") - } + <-done } // Issue 18319: test that the Server validates the request method. From 085d6ff5312a789b8c34c51e84e4a2b39a6631ca Mon Sep 17 00:00:00 2001 From: Jeremy Faller Date: Thu, 2 Dec 2021 13:47:39 -0500 Subject: [PATCH 414/752] doc/go1.18: add docs for -count when benchmarking CL 356669 Updates #47694 Change-Id: I49e0cdd3b34e81e9e44020a8eb1304d78249cd66 Reviewed-on: https://go-review.googlesource.com/c/go/+/368677 Trust: Jeremy Faller Run-TryBot: Jeremy Faller Reviewed-by: Michael Pratt TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 77c26bc257..4a09cb6773 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -782,11 +782,17 @@ Do not send CLs removing the interior tags from such phrases.
      testing

      - TODO: https://golang.org/cl/343883: increase alternation precedence + The precedence of / in the argument for -run and + -bench has been increased. A/B|C/D used to be + treated as A/(B|C)/D and is now treated as + (A/B)/(C/D).

      - TODO: https://golang.org/cl/356669: skip extra -count iterations if there are no tests + If the -run option does not select any tests, the + -count option is ignored. This could change the behavior of + existing tests in the unlikely case that a test changes the set of subtests + that are run each time the test function itself is run.

      From a08bbd964dd037331b2693aff731ec2d8376a721 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 18 Oct 2021 14:59:05 -0400 Subject: [PATCH 415/752] cmd/go: add missing cgo conditions in script tests Change-Id: I7cd1643b2dd5c00be84574d17830b1d5383643fa Reviewed-on: https://go-review.googlesource.com/c/go/+/356610 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Michael Matloob --- src/cmd/go/testdata/script/build_overlay.txt | 28 +++++++++---------- src/cmd/go/testdata/script/list_swigcxx.txt | 6 ++-- .../go/testdata/script/test_build_failure.txt | 2 +- 3 files changed, 19 insertions(+), 17 deletions(-) diff --git a/src/cmd/go/testdata/script/build_overlay.txt b/src/cmd/go/testdata/script/build_overlay.txt index 2932b94e6c..56e812f44b 100644 --- a/src/cmd/go/testdata/script/build_overlay.txt +++ b/src/cmd/go/testdata/script/build_overlay.txt @@ -31,17 +31,17 @@ exec ./print_trimpath_two_files$GOEXE stdout $WORK[/\\]gopath[/\\]src[/\\]m[/\\]printpath[/\\]main.go stdout $WORK[/\\]gopath[/\\]src[/\\]m[/\\]printpath[/\\]other.go -go build -overlay overlay.json -o main_cgo_replace$GOEXE ./cgo_hello_replace -exec ./main_cgo_replace$GOEXE -stdout '^hello cgo\r?\n' +[cgo] go build -overlay overlay.json -o main_cgo_replace$GOEXE ./cgo_hello_replace +[cgo] exec ./main_cgo_replace$GOEXE +[cgo] stdout '^hello cgo\r?\n' -go build -overlay overlay.json -o main_cgo_quote$GOEXE ./cgo_hello_quote -exec ./main_cgo_quote$GOEXE -stdout '^hello cgo\r?\n' +[cgo] go build -overlay overlay.json -o main_cgo_quote$GOEXE ./cgo_hello_quote +[cgo] exec ./main_cgo_quote$GOEXE +[cgo] stdout '^hello cgo\r?\n' -go build -overlay overlay.json -o main_cgo_angle$GOEXE ./cgo_hello_angle -exec ./main_cgo_angle$GOEXE -stdout '^hello cgo\r?\n' +[cgo] go build -overlay overlay.json -o main_cgo_angle$GOEXE ./cgo_hello_angle +[cgo] exec ./main_cgo_angle$GOEXE +[cgo] stdout '^hello cgo\r?\n' go build -overlay overlay.json -o main_call_asm$GOEXE ./call_asm exec ./main_call_asm$GOEXE @@ -55,11 +55,11 @@ cp overlay/test_cache_different.go overlay/test_cache.go go list -overlay overlay.json -f '{{.Stale}}' ./test_cache stdout '^true$' -go list -compiled -overlay overlay.json -f '{{range .CompiledGoFiles}}{{. | printf "%s\n"}}{{end}}' ./cgo_hello_replace -cp stdout compiled_cgo_sources.txt -go run ../print_line_comments.go compiled_cgo_sources.txt -stdout $GOPATH[/\\]src[/\\]m[/\\]cgo_hello_replace[/\\]cgo_hello_replace.go -! stdout $GOPATH[/\\]src[/\\]m[/\\]overlay[/\\]hello.c +[cgo] go list -compiled -overlay overlay.json -f '{{range .CompiledGoFiles}}{{. | printf "%s\n"}}{{end}}' ./cgo_hello_replace +[cgo] cp stdout compiled_cgo_sources.txt +[cgo] go run ../print_line_comments.go compiled_cgo_sources.txt +[cgo] stdout $GOPATH[/\\]src[/\\]m[/\\]cgo_hello_replace[/\\]cgo_hello_replace.go +[cgo] ! stdout $GOPATH[/\\]src[/\\]m[/\\]overlay[/\\]hello.c # Run same tests but with gccgo. env GO111MODULE=off diff --git a/src/cmd/go/testdata/script/list_swigcxx.txt b/src/cmd/go/testdata/script/list_swigcxx.txt index c6acd9ecdb..d4227a80e8 100644 --- a/src/cmd/go/testdata/script/list_swigcxx.txt +++ b/src/cmd/go/testdata/script/list_swigcxx.txt @@ -2,17 +2,19 @@ [!exec:swig] skip [!exec:g++] skip +[!cgo] skip # CompiledGoFiles should contain 4 files: # a.go # a.swigcxx.go # _cgo_gotypes.go # a.cgo1.go +# +# These names we see here, other than a.go, will be from the build cache, +# so we just count them. go list -f '{{.CompiledGoFiles}}' -compiled=true example/swig -# These names we see here, other than a.go, will be from the build cache, -# so we just count them. stdout a\.go stdout -count=3 $GOCACHE diff --git a/src/cmd/go/testdata/script/test_build_failure.txt b/src/cmd/go/testdata/script/test_build_failure.txt index 8d13634c8c..e8c984f272 100644 --- a/src/cmd/go/testdata/script/test_build_failure.txt +++ b/src/cmd/go/testdata/script/test_build_failure.txt @@ -3,7 +3,7 @@ ! go test -x coverbad ! stderr '[\\/]coverbad\.test( |$)' # 'go test' should not claim to have run the test. stderr 'undefined: g' -stderr 'undefined: j' +[cgo] stderr 'undefined: j' -- go.mod -- module coverbad From 4300f105147dc0da9d1034704ad1cd24bedde5da Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Mon, 6 Dec 2021 13:36:42 -0500 Subject: [PATCH 416/752] build: for default bootstrap, use Go 1.17 if present, falling back to Go 1.4 Preparation for #44505, but safe for Go 1.18. Also fixes the default build on Macs, at least for people who have a $HOME/go1.17 or have run go install golang.org/dl/go1.17@latest go1.17 download Change-Id: I822f93e75498620fad87db2436376148c42f6bff Reviewed-on: https://go-review.googlesource.com/c/go/+/369914 Trust: Russ Cox Reviewed-by: Ian Lance Taylor --- src/cmd/dist/buildtool.go | 13 ++++++++++++- src/make.bash | 9 ++++++++- src/make.bat | 2 ++ src/make.rc | 3 +++ 4 files changed, 25 insertions(+), 2 deletions(-) diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go index 75f04a975c..17538ad5a4 100644 --- a/src/cmd/dist/buildtool.go +++ b/src/cmd/dist/buildtool.go @@ -93,10 +93,21 @@ var ignoreSuffixes = []string{ "_test.go", } +var tryDirs = []string{ + "sdk/go1.17", + "go1.17", +} + func bootstrapBuildTools() { goroot_bootstrap := os.Getenv("GOROOT_BOOTSTRAP") if goroot_bootstrap == "" { - goroot_bootstrap = pathf("%s/go1.4", os.Getenv("HOME")) + home := os.Getenv("HOME") + goroot_bootstrap = pathf("%s/go1.4", home) + for _, d := range tryDirs { + if p := pathf("%s/%s", home, d); isdir(p) { + goroot_bootstrap = p + } + } } xprintf("Building Go toolchain1 using %s.\n", goroot_bootstrap) diff --git a/src/make.bash b/src/make.bash index 3310692a18..2d6c47272e 100755 --- a/src/make.bash +++ b/src/make.bash @@ -153,7 +153,14 @@ if [ "$1" = "-v" ]; then fi goroot_bootstrap_set=${GOROOT_BOOTSTRAP+"true"} -export GOROOT_BOOTSTRAP=${GOROOT_BOOTSTRAP:-$HOME/go1.4} +if [ -z "$GOROOT_BOOTSTRAP" ]; then + GOROOT_BOOTSTRAP="$HOME/go1.4" + for d in sdk/go1.17 go1.17; do + if [ -d "$HOME/$d" ]; then + GOROOT_BOOTSTRAP="$HOME/$d" + fi + done +fi export GOROOT="$(cd .. && pwd)" IFS=$'\n'; for go_exe in $(type -ap go); do if [ ! -x "$GOROOT_BOOTSTRAP/bin/go" ]; then diff --git a/src/make.bat b/src/make.bat index 8f2825b09a..6bffee050e 100644 --- a/src/make.bat +++ b/src/make.bat @@ -83,6 +83,8 @@ for /f "tokens=*" %%g in ('where go 2^>nul') do ( ) ) ) +if "x%GOROOT_BOOTSTRAP%"=="x" if exist "%HOMEDRIVE%%HOMEPATH%\go1.17" set GOROOT_BOOTSTRAP=%HOMEDRIVE%%HOMEPATH%\go1.17 +if "x%GOROOT_BOOTSTRAP%"=="x" if exist "%HOMEDRIVE%%HOMEPATH%\sdk\go1.17" set GOROOT_BOOTSTRAP=%HOMEDRIVE%%HOMEPATH%\sdk\go1.17 if "x%GOROOT_BOOTSTRAP%"=="x" set GOROOT_BOOTSTRAP=%HOMEDRIVE%%HOMEPATH%\Go1.4 :bootstrapset diff --git a/src/make.rc b/src/make.rc index ba8c5db2d9..37087d6357 100755 --- a/src/make.rc +++ b/src/make.rc @@ -55,6 +55,9 @@ goroot_bootstrap_set = 'true' if(! ~ $#GOROOT_BOOTSTRAP 1){ goroot_bootstrap_set = 'false' GOROOT_BOOTSTRAP = $home/go1.4 + for(d in sdk/go1.17 go1.17) + if(test -d $home/$d) + GOROOT_BOOTSTRAP = $home/$d } for(p in $path){ if(! test -x $GOROOT_BOOTSTRAP/bin/go){ From b37a5391f9e452aa779205add12bd89f44e3fcf0 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Mon, 6 Dec 2021 13:38:04 -0500 Subject: [PATCH 417/752] cmd/link, cmd/go: make version info easier to extract Reading the version information to date has required evaluating two pointers to strings (which themselves contain pointers to data), which means applying relocations, which can be very system-dependent. To simplify the lookup, inline the string data into the build info blob. This makes go version work on binaries built with external linking on darwin/arm64. Also test that at least the very basics work on a trivial binary, even in short mode. Change-Id: I463088c19e837ae0ce57e1278c7b72e74a80b2c4 Reviewed-on: https://go-review.googlesource.com/c/go/+/369977 Trust: Russ Cox Run-TryBot: Russ Cox TryBot-Result: Gopher Robot Reviewed-by: Cherry Mui --- src/cmd/go/internal/modload/build.go | 35 ++++++----------- src/cmd/go/internal/work/exec.go | 10 +++-- src/cmd/go/testdata/script/version.txt | 13 ++++++- src/cmd/link/internal/ld/data.go | 29 ++++++++------ src/cmd/link/internal/ld/deadcode.go | 6 --- src/cmd/link/internal/ld/ld.go | 6 +++ src/debug/buildinfo/buildinfo.go | 54 ++++++++++++++++++-------- 7 files changed, 93 insertions(+), 60 deletions(-) diff --git a/src/cmd/go/internal/modload/build.go b/src/cmd/go/internal/modload/build.go index 0e0292ec15..bfc73cc2f9 100644 --- a/src/cmd/go/internal/modload/build.go +++ b/src/cmd/go/internal/modload/build.go @@ -346,33 +346,22 @@ func findModule(ld *loader, path string) (module.Version, bool) { } func ModInfoProg(info string, isgccgo bool) []byte { - // Inject a variable with the debug information as runtime.modinfo, - // but compile it in package main so that it is specific to the binary. - // The variable must be a literal so that it will have the correct value - // before the initializer for package main runs. - // - // The runtime startup code refers to the variable, which keeps it live - // in all binaries. - // - // Note: we use an alternate recipe below for gccgo (based on an - // init function) due to the fact that gccgo does not support - // applying a "//go:linkname" directive to a variable. This has - // drawbacks in that other packages may want to look at the module - // info in their init functions (see issue 29628), which won't - // work for gccgo. See also issue 30344. - - if !isgccgo { - return []byte(fmt.Sprintf(`package main -import _ "unsafe" -//go:linkname __debug_modinfo__ runtime.modinfo -var __debug_modinfo__ = %q -`, string(infoStart)+info+string(infoEnd))) - } else { + // Inject an init function to set runtime.modinfo. + // This is only used for gccgo - with gc we hand the info directly to the linker. + // The init function has the drawback that packages may want to + // look at the module info in their init functions (see issue 29628), + // which won't work. See also issue 30344. + if isgccgo { return []byte(fmt.Sprintf(`package main import _ "unsafe" //go:linkname __set_debug_modinfo__ runtime.setmodinfo func __set_debug_modinfo__(string) func init() { __set_debug_modinfo__(%q) } -`, string(infoStart)+info+string(infoEnd))) +`, ModInfoData(info))) } + return nil +} + +func ModInfoData(info string) []byte { + return []byte(string(infoStart) + info + string(infoEnd)) } diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go index 03f8866cf2..2c040b8ff4 100644 --- a/src/cmd/go/internal/work/exec.go +++ b/src/cmd/go/internal/work/exec.go @@ -794,10 +794,13 @@ OverlayLoop: } if p.Internal.BuildInfo != "" && cfg.ModulesEnabled { - if err := b.writeFile(objdir+"_gomod_.go", modload.ModInfoProg(p.Internal.BuildInfo, cfg.BuildToolchainName == "gccgo")); err != nil { - return err + prog := modload.ModInfoProg(p.Internal.BuildInfo, cfg.BuildToolchainName == "gccgo") + if len(prog) > 0 { + if err := b.writeFile(objdir+"_gomod_.go", prog); err != nil { + return err + } + gofiles = append(gofiles, objdir+"_gomod_.go") } - gofiles = append(gofiles, objdir+"_gomod_.go") } // Compile Go. @@ -1394,6 +1397,7 @@ func (b *Builder) writeLinkImportcfg(a *Action, file string) error { fmt.Fprintf(&icfg, "packageshlib %s=%s\n", p1.ImportPath, p1.Shlib) } } + fmt.Fprintf(&icfg, "modinfo %q\n", modload.ModInfoData(a.Package.Internal.BuildInfo)) return b.writeFile(file, icfg.Bytes()) } diff --git a/src/cmd/go/testdata/script/version.txt b/src/cmd/go/testdata/script/version.txt index 8c08bae725..adca7af7a9 100644 --- a/src/cmd/go/testdata/script/version.txt +++ b/src/cmd/go/testdata/script/version.txt @@ -16,7 +16,14 @@ stdout '^go version' env GOFLAGS= env GO111MODULE=on -# Skip the builds below if we are running in short mode. + +# Check that very basic version lookup succeeds. +go build empty.go +go version empty$GOEXE +[cgo] go build -ldflags=-linkmode=external empty.go +[cgo] go version empty$GOEXE + +# Skip the remaining builds if we are running in short mode. [short] skip # Check that 'go version' and 'go version -m' work on a binary built in module mode. @@ -57,3 +64,7 @@ stdout '^\tmod\trsc.io/fortune\tv1.0.0' -- go.mod -- module m + +-- empty.go -- +package main +func main(){} diff --git a/src/cmd/link/internal/ld/data.go b/src/cmd/link/internal/ld/data.go index 4d85977d43..95a8e0facb 100644 --- a/src/cmd/link/internal/ld/data.go +++ b/src/cmd/link/internal/ld/data.go @@ -2169,11 +2169,10 @@ func (ctxt *Link) buildinfo() { return } + // Write the buildinfo symbol, which go version looks for. + // The code reading this data is in package debug/buildinfo. ldr := ctxt.loader s := ldr.CreateSymForUpdate(".go.buildinfo", 0) - // On AIX, .go.buildinfo must be in the symbol table as - // it has relocations. - s.SetNotInSymbolTable(!ctxt.IsAIX()) s.SetType(sym.SBUILDINFO) s.SetAlign(16) // The \xff is invalid UTF-8, meant to make it less likely @@ -2186,16 +2185,24 @@ func (ctxt *Link) buildinfo() { if ctxt.Arch.ByteOrder == binary.BigEndian { data[len(prefix)+1] = 1 } + data[len(prefix)+1] |= 2 // signals new pointer-free format + data = appendString(data, strdata["runtime.buildVersion"]) + data = appendString(data, strdata["runtime.modinfo"]) + // MacOS linker gets very upset if the size os not a multiple of alignment. + for len(data)%16 != 0 { + data = append(data, 0) + } s.SetData(data) s.SetSize(int64(len(data))) - r, _ := s.AddRel(objabi.R_ADDR) - r.SetOff(16) - r.SetSiz(uint8(ctxt.Arch.PtrSize)) - r.SetSym(ldr.LookupOrCreateSym("runtime.buildVersion", 0)) - r, _ = s.AddRel(objabi.R_ADDR) - r.SetOff(16 + int32(ctxt.Arch.PtrSize)) - r.SetSiz(uint8(ctxt.Arch.PtrSize)) - r.SetSym(ldr.LookupOrCreateSym("runtime.modinfo", 0)) +} + +// appendString appends s to data, prefixed by its varint-encoded length. +func appendString(data []byte, s string) []byte { + var v [binary.MaxVarintLen64]byte + n := binary.PutUvarint(v[:], uint64(len(s))) + data = append(data, v[:n]...) + data = append(data, s...) + return data } // assign addresses to text diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go index 7b57a85cde..dba22323b0 100644 --- a/src/cmd/link/internal/ld/deadcode.go +++ b/src/cmd/link/internal/ld/deadcode.go @@ -71,12 +71,6 @@ func (d *deadcodePass) init() { // runtime.unreachableMethod is a function that will throw if called. // We redirect unreachable methods to it. names = append(names, "runtime.unreachableMethod") - if !d.ctxt.linkShared && d.ctxt.BuildMode != BuildModePlugin { - // runtime.buildVersion and runtime.modinfo are referenced in .go.buildinfo section - // (see function buildinfo in data.go). They should normally be reachable from the - // runtime. Just make it explicit, in case. - names = append(names, "runtime.buildVersion", "runtime.modinfo") - } if d.ctxt.BuildMode == BuildModePlugin { names = append(names, objabi.PathToPrefix(*flagPluginPath)+"..inittask", objabi.PathToPrefix(*flagPluginPath)+".main", "go.plugin.tabs") diff --git a/src/cmd/link/internal/ld/ld.go b/src/cmd/link/internal/ld/ld.go index 7ff9c41f96..954921844c 100644 --- a/src/cmd/link/internal/ld/ld.go +++ b/src/cmd/link/internal/ld/ld.go @@ -85,6 +85,12 @@ func (ctxt *Link) readImportCfg(file string) { log.Fatalf(`%s:%d: invalid packageshlib: syntax is "packageshlib path=filename"`, file, lineNum) } ctxt.PackageShlib[before] = after + case "modinfo": + s, err := strconv.Unquote(args) + if err != nil { + log.Fatalf("%s:%d: invalid modinfo: %v", file, lineNum, err) + } + addstrdata1(ctxt, "runtime.modinfo="+s) } } } diff --git a/src/debug/buildinfo/buildinfo.go b/src/debug/buildinfo/buildinfo.go index f84429a342..2c0200e8dc 100644 --- a/src/debug/buildinfo/buildinfo.go +++ b/src/debug/buildinfo/buildinfo.go @@ -146,12 +146,18 @@ func readRawBuildInfo(r io.ReaderAt) (vers, mod string, err error) { } const ( buildInfoAlign = 16 - buildinfoSize = 32 + buildInfoSize = 32 ) - for ; !bytes.HasPrefix(data, buildInfoMagic); data = data[buildInfoAlign:] { - if len(data) < 32 { + for { + i := bytes.Index(data, buildInfoMagic) + if i < 0 || len(data)-i < buildInfoSize { return "", "", errNotGoExe } + if i%buildInfoAlign == 0 && len(data)-i >= buildInfoSize { + data = data[i:] + break + } + data = data[(i+buildInfoAlign-1)&^buildInfoAlign:] } // Decode the blob. @@ -161,25 +167,33 @@ func readRawBuildInfo(r io.ReaderAt) (vers, mod string, err error) { // Two virtual addresses to Go strings follow that: runtime.buildVersion, // and runtime.modinfo. // On 32-bit platforms, the last 8 bytes are unused. + // If the endianness has the 2 bit set, then the pointers are zero + // and the 32-byte header is followed by varint-prefixed string data + // for the two string values we care about. ptrSize := int(data[14]) - bigEndian := data[15] != 0 - var bo binary.ByteOrder - if bigEndian { - bo = binary.BigEndian + if data[15]&2 != 0 { + vers, data = decodeString(data[32:]) + mod, data = decodeString(data) } else { - bo = binary.LittleEndian + bigEndian := data[15] != 0 + var bo binary.ByteOrder + if bigEndian { + bo = binary.BigEndian + } else { + bo = binary.LittleEndian + } + var readPtr func([]byte) uint64 + if ptrSize == 4 { + readPtr = func(b []byte) uint64 { return uint64(bo.Uint32(b)) } + } else { + readPtr = bo.Uint64 + } + vers = readString(x, ptrSize, readPtr, readPtr(data[16:])) + mod = readString(x, ptrSize, readPtr, readPtr(data[16+ptrSize:])) } - var readPtr func([]byte) uint64 - if ptrSize == 4 { - readPtr = func(b []byte) uint64 { return uint64(bo.Uint32(b)) } - } else { - readPtr = bo.Uint64 - } - vers = readString(x, ptrSize, readPtr, readPtr(data[16:])) if vers == "" { return "", "", errNotGoExe } - mod = readString(x, ptrSize, readPtr, readPtr(data[16+ptrSize:])) if len(mod) >= 33 && mod[len(mod)-17] == '\n' { // Strip module framing: sentinel strings delimiting the module info. // These are cmd/go/internal/modload.infoStart and infoEnd. @@ -191,6 +205,14 @@ func readRawBuildInfo(r io.ReaderAt) (vers, mod string, err error) { return vers, mod, nil } +func decodeString(data []byte) (s string, rest []byte) { + u, n := binary.Uvarint(data) + if n <= 0 || u >= uint64(len(data)-n) { + return "", nil + } + return string(data[n : uint64(n)+u]), data[uint64(n)+u:] +} + // readString returns the string at address addr in the executable x. func readString(x exe, ptrSize int, readPtr func([]byte) uint64, addr uint64) string { hdr, err := x.ReadData(addr, uint64(2*ptrSize)) From 2ebe081288377fa4e9f71b1dab8557a042a9a670 Mon Sep 17 00:00:00 2001 From: Katie Hockman Date: Wed, 1 Dec 2021 11:25:16 -0500 Subject: [PATCH 418/752] internal/fuzz: handle unrecoverable errors during minimization Previously, if an unrecoverable error occurred during minimization, then the input that caused the failure could not be retrieved by the coordinator. This was fine if minimizing a crash, since the coordinator could simply report the original error, and ignore the new one. However, if an error occurred while minimizing an interesting input, then we may lose an important error that would be better to report. This changes is a pretty major refactor of the minimization logic in order to support this. It removes minimization support of all types except []byte and string. There isn't compelling evidence that minimizing types like int or float64 are actually beneficial, so removing this seems fine. With this change, the coordinator requests that the worker minimize a single value at a time. The worker updates shared memory directly during minimzation, writing the *unmarshaled* bytes to the shared memory region. If a nonrecoverable error occurs during minimization, then the coordinator can get the unmarshaled value out of shared memory for that type being minimized. Fixes #48731 Change-Id: I4d1d449c411129b3c83b148e666bc70f09e95828 Reviewed-on: https://go-review.googlesource.com/c/go/+/367848 Trust: Bryan Mills Reviewed-by: Roland Shoemaker Trust: Katie Hockman Run-TryBot: Katie Hockman TryBot-Result: Gopher Robot --- .../script/test_fuzz_minimize_interesting.txt | 40 ++- src/internal/fuzz/mem.go | 8 +- src/internal/fuzz/minimize.go | 44 +-- src/internal/fuzz/minimize_test.go | 156 +---------- src/internal/fuzz/worker.go | 252 ++++++++---------- src/internal/fuzz/worker_test.go | 48 ++++ 6 files changed, 215 insertions(+), 333 deletions(-) diff --git a/src/cmd/go/testdata/script/test_fuzz_minimize_interesting.txt b/src/cmd/go/testdata/script/test_fuzz_minimize_interesting.txt index e017a4cad3..c9b04d02ea 100644 --- a/src/cmd/go/testdata/script/test_fuzz_minimize_interesting.txt +++ b/src/cmd/go/testdata/script/test_fuzz_minimize_interesting.txt @@ -17,12 +17,13 @@ env GOCACHE=$WORK/gocache exec ./fuzz.test$GOEXE -test.fuzzcachedir=$GOCACHE/fuzz -test.fuzz=FuzzMinCache -test.fuzztime=1000x go run check_cache.go $GOCACHE/fuzz/FuzzMinCache +go test -c -fuzz=. # Build using shared build cache for speed. +env GOCACHE=$WORK/gocache + # Test that minimization occurs for a crash that appears while minimizing a # newly found interesting input. There must be only one worker for this test to # be flaky like we want. -go test -c -fuzz=. # Build using shared build cache for speed. -env GOCACHE=$WORK/gocache -! exec ./fuzz.test$GOEXE -test.fuzzcachedir=$GOCACHE/fuzz -test.fuzz=FuzzMinimizerCrashInMinimization -test.fuzztime=10000x -test.parallel=1 +! exec ./fuzz.test$GOEXE -test.fuzzcachedir=$GOCACHE/fuzz -test.fuzz=FuzzMinimizerCrashInMinimization -test.run=FuzzMinimizerCrashInMinimization -test.fuzztime=10000x -test.parallel=1 ! stdout '^ok' stdout 'got the minimum size!' stdout -count=1 'flaky failure' @@ -31,6 +32,17 @@ stdout FAIL # Make sure the crash that was written will fail when run with go test ! go test -run=FuzzMinimizerCrashInMinimization . +# Test that a nonrecoverable error that occurs while minimizing an interesting +# input is reported correctly. +! exec ./fuzz.test$GOEXE -test.fuzzcachedir=$GOCACHE/fuzz -test.fuzz=FuzzMinimizerNonrecoverableCrashInMinimization -test.run=FuzzMinimizerNonrecoverableCrashInMinimization -test.fuzztime=10000x -test.parallel=1 +! stdout '^ok' +stdout -count=1 'fuzzing process hung or terminated unexpectedly while minimizing' +stdout -count=1 'EOF' +stdout FAIL + +# Make sure the crash that was written will fail when run with go test +! go test -run=FuzzMinimizerNonrecoverableCrashInMinimization . + -- go.mod -- module fuzz @@ -54,6 +66,7 @@ package fuzz import ( "bytes" "io" + "os" "testing" ) @@ -70,7 +83,7 @@ func FuzzMinimizerCrashInMinimization(f *testing.F) { // should be attempting minimization Y(io.Discard, b) } - if len(b) < 350 { + if len(b) < 55 { t.Error("flaky failure") } if len(b) == 50 { @@ -79,6 +92,25 @@ func FuzzMinimizerCrashInMinimization(f *testing.F) { }) } +func FuzzMinimizerNonrecoverableCrashInMinimization(f *testing.F) { + seed := make([]byte, 1000) + f.Add(seed) + f.Fuzz(func(t *testing.T, b []byte) { + if len(b) < 50 || len(b) > 1100 { + // Make sure that b is large enough that it can be minimized + return + } + if !bytes.Equal(b, seed) { + // This should have hit a new edge, and the interesting input + // should be attempting minimization + Y(io.Discard, b) + } + if len(b) < 55 { + os.Exit(19) + } + }) +} + func FuzzMinCache(f *testing.F) { seed := bytes.Repeat([]byte("a"), 20) f.Add(seed) diff --git a/src/internal/fuzz/mem.go b/src/internal/fuzz/mem.go index ccd4da2455..d6d45be20e 100644 --- a/src/internal/fuzz/mem.go +++ b/src/internal/fuzz/mem.go @@ -41,11 +41,17 @@ type sharedMemHeader struct { // May be reset by coordinator. count int64 - // valueLen is the length of the value that was last fuzzed. + // valueLen is the number of bytes in region which should be read. valueLen int // randState and randInc hold the state of a pseudo-random number generator. randState, randInc uint64 + + // rawInMem is true if the region holds raw bytes, which occurs during + // minimization. If true after the worker fails during minimization, this + // indicates that an unrecoverable error occurred, and the region can be + // used to retrive the raw bytes that caused the error. + rawInMem bool } // sharedMemSize returns the size needed for a shared memory buffer that can diff --git a/src/internal/fuzz/minimize.go b/src/internal/fuzz/minimize.go index c6e4559665..0e410fb86a 100644 --- a/src/internal/fuzz/minimize.go +++ b/src/internal/fuzz/minimize.go @@ -5,20 +5,14 @@ package fuzz import ( - "math" "reflect" ) func isMinimizable(t reflect.Type) bool { - for _, v := range zeroVals { - if t == reflect.TypeOf(v) { - return true - } - } - return false + return t == reflect.TypeOf("") || t == reflect.TypeOf([]byte(nil)) } -func minimizeBytes(v []byte, try func(interface{}) bool, shouldStop func() bool) { +func minimizeBytes(v []byte, try func([]byte) bool, shouldStop func() bool) { tmp := make([]byte, len(v)) // If minimization was successful at any point during minimizeBytes, // then the vals slice in (*workerServer).minimizeInput will point to @@ -99,37 +93,3 @@ func minimizeBytes(v []byte, try func(interface{}) bool, shouldStop func() bool) } } } - -func minimizeInteger(v uint, try func(interface{}) bool, shouldStop func() bool) { - // TODO(rolandshoemaker): another approach could be either unsetting/setting all bits - // (depending on signed-ness), or rotating bits? When operating on cast signed integers - // this would probably be more complex though. - for ; v != 0; v /= 10 { - if shouldStop() { - return - } - // We ignore the return value here because there is no point - // advancing the loop, since there is nothing after this check, - // and we don't return early because a smaller value could - // re-trigger the crash. - try(v) - } -} - -func minimizeFloat(v float64, try func(interface{}) bool, shouldStop func() bool) { - if math.IsNaN(v) { - return - } - minimized := float64(0) - for div := 10.0; minimized < v; div *= 10 { - if shouldStop() { - return - } - minimized = float64(int(v*div)) / div - if !try(minimized) { - // Since we are searching from least precision -> highest precision we - // can return early since we've already found the smallest value - return - } - } -} diff --git a/src/internal/fuzz/minimize_test.go b/src/internal/fuzz/minimize_test.go index 04d785ce40..f9041d1d34 100644 --- a/src/internal/fuzz/minimize_test.go +++ b/src/internal/fuzz/minimize_test.go @@ -129,150 +129,6 @@ func TestMinimizeInput(t *testing.T) { input: []interface{}{"ZZZZZ"}, expected: []interface{}{"A"}, }, - { - name: "int", - fn: func(e CorpusEntry) error { - i := e.Values[0].(int) - if i > 100 { - return fmt.Errorf("bad %v", e.Values[0]) - } - return nil - }, - input: []interface{}{123456}, - expected: []interface{}{123}, - }, - { - name: "int8", - fn: func(e CorpusEntry) error { - i := e.Values[0].(int8) - if i > 10 { - return fmt.Errorf("bad %v", e.Values[0]) - } - return nil - }, - input: []interface{}{int8(1<<7 - 1)}, - expected: []interface{}{int8(12)}, - }, - { - name: "int16", - fn: func(e CorpusEntry) error { - i := e.Values[0].(int16) - if i > 10 { - return fmt.Errorf("bad %v", e.Values[0]) - } - return nil - }, - input: []interface{}{int16(1<<15 - 1)}, - expected: []interface{}{int16(32)}, - }, - { - fn: func(e CorpusEntry) error { - i := e.Values[0].(int32) - if i > 10 { - return fmt.Errorf("bad %v", e.Values[0]) - } - return nil - }, - input: []interface{}{int32(1<<31 - 1)}, - expected: []interface{}{int32(21)}, - }, - { - name: "int32", - fn: func(e CorpusEntry) error { - i := e.Values[0].(uint) - if i > 10 { - return fmt.Errorf("bad %v", e.Values[0]) - } - return nil - }, - input: []interface{}{uint(123456)}, - expected: []interface{}{uint(12)}, - }, - { - name: "uint8", - fn: func(e CorpusEntry) error { - i := e.Values[0].(uint8) - if i > 10 { - return fmt.Errorf("bad %v", e.Values[0]) - } - return nil - }, - input: []interface{}{uint8(1<<8 - 1)}, - expected: []interface{}{uint8(25)}, - }, - { - name: "uint16", - fn: func(e CorpusEntry) error { - i := e.Values[0].(uint16) - if i > 10 { - return fmt.Errorf("bad %v", e.Values[0]) - } - return nil - }, - input: []interface{}{uint16(1<<16 - 1)}, - expected: []interface{}{uint16(65)}, - }, - { - name: "uint32", - fn: func(e CorpusEntry) error { - i := e.Values[0].(uint32) - if i > 10 { - return fmt.Errorf("bad %v", e.Values[0]) - } - return nil - }, - input: []interface{}{uint32(1<<32 - 1)}, - expected: []interface{}{uint32(42)}, - }, - { - name: "float32", - fn: func(e CorpusEntry) error { - if i := e.Values[0].(float32); i == 1.23 { - return nil - } - return fmt.Errorf("bad %v", e.Values[0]) - }, - input: []interface{}{float32(1.23456789)}, - expected: []interface{}{float32(1.2)}, - }, - { - name: "float64", - fn: func(e CorpusEntry) error { - if i := e.Values[0].(float64); i == 1.23 { - return nil - } - return fmt.Errorf("bad %v", e.Values[0]) - }, - input: []interface{}{float64(1.23456789)}, - expected: []interface{}{float64(1.2)}, - }, - } - - // If we are on a 64 bit platform add int64 and uint64 tests - if v := int64(1<<63 - 1); int64(int(v)) == v { - cases = append(cases, testcase{ - name: "int64", - fn: func(e CorpusEntry) error { - i := e.Values[0].(int64) - if i > 10 { - return fmt.Errorf("bad %v", e.Values[0]) - } - return nil - }, - input: []interface{}{int64(1<<63 - 1)}, - expected: []interface{}{int64(92)}, - }, testcase{ - name: "uint64", - fn: func(e CorpusEntry) error { - i := e.Values[0].(uint64) - if i > 10 { - return fmt.Errorf("bad %v", e.Values[0]) - } - return nil - }, - input: []interface{}{uint64(1<<64 - 1)}, - expected: []interface{}{uint64(18)}, - }) } for _, tc := range cases { @@ -284,9 +140,9 @@ func TestMinimizeInput(t *testing.T) { return time.Second, tc.fn(e) }, } - count := int64(0) + mem := &sharedMem{region: make([]byte, 100)} // big enough to hold value and header vals := tc.input - success, err := ws.minimizeInput(context.Background(), vals, &count, 0, nil) + success, err := ws.minimizeInput(context.Background(), vals, mem, minimizeArgs{}) if !success { t.Errorf("minimizeInput did not succeed") } @@ -310,17 +166,17 @@ func TestMinimizeFlaky(t *testing.T) { ws := &workerServer{fuzzFn: func(e CorpusEntry) (time.Duration, error) { return time.Second, errors.New("ohno") }} - keepCoverage := make([]byte, len(coverageSnapshot)) - count := int64(0) + mem := &sharedMem{region: make([]byte, 100)} // big enough to hold value and header vals := []interface{}{[]byte(nil)} - success, err := ws.minimizeInput(context.Background(), vals, &count, 0, keepCoverage) + args := minimizeArgs{KeepCoverage: make([]byte, len(coverageSnapshot))} + success, err := ws.minimizeInput(context.Background(), vals, mem, args) if success { t.Error("unexpected success") } if err != nil { t.Errorf("unexpected error: %v", err) } - if count != 1 { + if count := mem.header().count; count != 1 { t.Errorf("count: got %d, want 1", count) } } diff --git a/src/internal/fuzz/worker.go b/src/internal/fuzz/worker.go index 5be49d28f9..c39804cad1 100644 --- a/src/internal/fuzz/worker.go +++ b/src/internal/fuzz/worker.go @@ -15,6 +15,7 @@ import ( "io/ioutil" "os" "os/exec" + "reflect" "runtime" "sync" "time" @@ -255,7 +256,14 @@ func (w *worker) minimize(ctx context.Context, input fuzzMinimizeInput) (min fuz limit: input.limit, }, nil } - return fuzzResult{}, fmt.Errorf("fuzzing process hung or terminated unexpectedly while minimizing: %w", w.waitErr) + return fuzzResult{ + entry: entry, + crasherMsg: fmt.Sprintf("fuzzing process hung or terminated unexpectedly while minimizing: %v", err), + canMinimize: false, + limit: input.limit, + count: resp.Count, + totalDuration: resp.Duration, + }, nil } if input.crasherMsg != "" && resp.Err == "" { @@ -510,6 +518,9 @@ type minimizeArgs struct { // keep in minimized values. When provided, the worker will reject inputs that // don't cause at least one of these bits to be set. KeepCoverage []byte + + // Index is the index of the fuzz target parameter to be minimized. + Index int } // minimizeResponse contains results from workerServer.minimize. @@ -797,11 +808,10 @@ func (ws *workerServer) minimize(ctx context.Context, args minimizeArgs) (resp m // Minimize the values in vals, then write to shared memory. We only write // to shared memory after completing minimization. - // TODO(48165): If the worker terminates unexpectedly during minimization, - // the coordinator has no way of retrieving the crashing input. - success, err := ws.minimizeInput(ctx, vals, &mem.header().count, args.Limit, args.KeepCoverage) + success, err := ws.minimizeInput(ctx, vals, mem, args) if success { writeToMem(vals, mem) + mem.header().rawInMem = false resp.WroteToMem = true if err != nil { resp.Err = err.Error() @@ -813,14 +823,18 @@ func (ws *workerServer) minimize(ctx context.Context, args minimizeArgs) (resp m } // minimizeInput applies a series of minimizing transformations on the provided -// vals, ensuring that each minimization still causes an error in fuzzFn. It -// uses the context to determine how long to run, stopping once closed. It -// returns a bool indicating whether minimization was successful and an error if -// one was found. -func (ws *workerServer) minimizeInput(ctx context.Context, vals []interface{}, count *int64, limit int64, keepCoverage []byte) (success bool, retErr error) { +// vals, ensuring that each minimization still causes an error, or keeps +// coverage, in fuzzFn. It uses the context to determine how long to run, +// stopping once closed. It returns a bool indicating whether minimization was +// successful and an error if one was found. +func (ws *workerServer) minimizeInput(ctx context.Context, vals []interface{}, mem *sharedMem, args minimizeArgs) (success bool, retErr error) { + keepCoverage := args.KeepCoverage + memBytes := mem.valueRef() + bPtr := &memBytes + count := &mem.header().count shouldStop := func() bool { return ctx.Err() != nil || - (limit > 0 && *count >= limit) + (args.Limit > 0 && *count >= args.Limit) } if shouldStop() { return false, nil @@ -838,64 +852,25 @@ func (ws *workerServer) minimizeInput(ctx context.Context, vals []interface{}, c } else if retErr == nil { return false, nil } + mem.header().rawInMem = true - var valI int // tryMinimized runs the fuzz function with candidate replacing the value // at index valI. tryMinimized returns whether the input with candidate is // interesting for the same reason as the original input: it returns // an error if one was expected, or it preserves coverage. - tryMinimized := func(candidate interface{}) bool { - prev := vals[valI] - // Set vals[valI] to the candidate after it has been - // properly cast. We know that candidate must be of - // the same type as prev, so use that as a reference. - switch c := candidate.(type) { - case float64: - switch prev.(type) { - case float32: - vals[valI] = float32(c) - case float64: - vals[valI] = c - default: - panic("impossible") - } - case uint: - switch prev.(type) { - case uint: - vals[valI] = c - case uint8: - vals[valI] = uint8(c) - case uint16: - vals[valI] = uint16(c) - case uint32: - vals[valI] = uint32(c) - case uint64: - vals[valI] = uint64(c) - case int: - vals[valI] = int(c) - case int8: - vals[valI] = int8(c) - case int16: - vals[valI] = int16(c) - case int32: - vals[valI] = int32(c) - case int64: - vals[valI] = int64(c) - default: - panic("impossible") - } + tryMinimized := func(candidate []byte) bool { + prev := vals[args.Index] + switch prev.(type) { case []byte: - switch prev.(type) { - case []byte: - vals[valI] = c - case string: - vals[valI] = string(c) - default: - panic("impossible") - } + vals[args.Index] = candidate + case string: + vals[args.Index] = string(candidate) default: panic("impossible") } + copy(*bPtr, candidate) + *bPtr = (*bPtr)[:len(candidate)] + mem.setValueLen(len(candidate)) *count++ _, err := ws.fuzzFn(CorpusEntry{Values: vals}) if err != nil { @@ -911,58 +886,16 @@ func (ws *workerServer) minimizeInput(ctx context.Context, vals []interface{}, c if keepCoverage != nil && hasCoverageBit(keepCoverage, coverageSnapshot) { return true } - vals[valI] = prev + vals[args.Index] = prev return false } - - for valI = range vals { - if shouldStop() { - break - } - switch v := vals[valI].(type) { - case bool: - continue // can't minimize - case float32: - minimizeFloat(float64(v), tryMinimized, shouldStop) - case float64: - minimizeFloat(v, tryMinimized, shouldStop) - case uint: - minimizeInteger(v, tryMinimized, shouldStop) - case uint8: - minimizeInteger(uint(v), tryMinimized, shouldStop) - case uint16: - minimizeInteger(uint(v), tryMinimized, shouldStop) - case uint32: - minimizeInteger(uint(v), tryMinimized, shouldStop) - case uint64: - if uint64(uint(v)) != v { - // Skip minimizing a uint64 on 32 bit platforms, since we'll truncate the - // value when casting - continue - } - minimizeInteger(uint(v), tryMinimized, shouldStop) - case int: - minimizeInteger(uint(v), tryMinimized, shouldStop) - case int8: - minimizeInteger(uint(v), tryMinimized, shouldStop) - case int16: - minimizeInteger(uint(v), tryMinimized, shouldStop) - case int32: - minimizeInteger(uint(v), tryMinimized, shouldStop) - case int64: - if int64(int(v)) != v { - // Skip minimizing a int64 on 32 bit platforms, since we'll truncate the - // value when casting - continue - } - minimizeInteger(uint(v), tryMinimized, shouldStop) - case string: - minimizeBytes([]byte(v), tryMinimized, shouldStop) - case []byte: - minimizeBytes(v, tryMinimized, shouldStop) - default: - panic("unreachable") - } + switch v := vals[args.Index].(type) { + case string: + minimizeBytes([]byte(v), tryMinimized, shouldStop) + case []byte: + minimizeBytes(v, tryMinimized, shouldStop) + default: + panic("impossible") } return true, retErr } @@ -983,8 +916,14 @@ func (ws *workerServer) ping(ctx context.Context, args pingArgs) pingResponse { // workerServer). type workerClient struct { workerComm + m *mutator + + // mu is the mutex protecting the workerComm.fuzzIn pipe. This must be + // locked before making calls to the workerServer. It prevents + // workerClient.Close from closing fuzzIn while workerClient methods are + // writing to it concurrently, and prevents multiple callers from writing to + // fuzzIn concurrently. mu sync.Mutex - m *mutator } func newWorkerClient(comm workerComm, m *mutator) *workerClient { @@ -1025,7 +964,7 @@ var errSharedMemClosed = errors.New("internal error: shared memory was closed an // minimize tells the worker to call the minimize method. See // workerServer.minimize. -func (wc *workerClient) minimize(ctx context.Context, entryIn CorpusEntry, args minimizeArgs) (entryOut CorpusEntry, resp minimizeResponse, err error) { +func (wc *workerClient) minimize(ctx context.Context, entryIn CorpusEntry, args minimizeArgs) (entryOut CorpusEntry, resp minimizeResponse, retErr error) { wc.mu.Lock() defer wc.mu.Unlock() @@ -1039,34 +978,75 @@ func (wc *workerClient) minimize(ctx context.Context, entryIn CorpusEntry, args return CorpusEntry{}, minimizeResponse{}, err } mem.setValue(inp) - wc.memMu <- mem - - c := call{Minimize: &args} - callErr := wc.callLocked(ctx, c, &resp) - mem, ok = <-wc.memMu - if !ok { - return CorpusEntry{}, minimizeResponse{}, errSharedMemClosed - } defer func() { wc.memMu <- mem }() - resp.Count = mem.header().count - if resp.WroteToMem { - entryOut.Data = mem.valueCopy() - entryOut.Values, err = unmarshalCorpusFile(entryOut.Data) - h := sha256.Sum256(entryOut.Data) - name := fmt.Sprintf("%x", h[:4]) - entryOut.Path = name - entryOut.Parent = entryIn.Parent - entryOut.Generation = entryIn.Generation - if err != nil { - return CorpusEntry{}, minimizeResponse{}, fmt.Errorf("workerClient.minimize unmarshaling minimized value: %v", err) - } - } else { - // Did not minimize, but the original input may still be interesting, - // for example, if there was an error. - entryOut = entryIn + entryOut = entryIn + entryOut.Values, err = unmarshalCorpusFile(inp) + if err != nil { + return CorpusEntry{}, minimizeResponse{}, fmt.Errorf("workerClient.minimize unmarshaling provided value: %v", err) } + for i, v := range entryOut.Values { + if !isMinimizable(reflect.TypeOf(v)) { + continue + } - return entryOut, resp, callErr + wc.memMu <- mem + args.Index = i + c := call{Minimize: &args} + callErr := wc.callLocked(ctx, c, &resp) + mem, ok = <-wc.memMu + if !ok { + return CorpusEntry{}, minimizeResponse{}, errSharedMemClosed + } + + if callErr != nil { + retErr = callErr + if !mem.header().rawInMem { + // An unrecoverable error occurred before minimization began. + return entryIn, minimizeResponse{}, retErr + } + // An unrecoverable error occurred during minimization. mem now + // holds the raw, unmarshalled bytes of entryIn.Values[i] that + // caused the error. + switch entryOut.Values[i].(type) { + case string: + entryOut.Values[i] = string(mem.valueCopy()) + case []byte: + entryOut.Values[i] = mem.valueCopy() + default: + panic("impossible") + } + entryOut.Data = marshalCorpusFile(entryOut.Values...) + // Stop minimizing; another unrecoverable error is likely to occur. + break + } + + if resp.WroteToMem { + // Minimization succeeded, and mem holds the marshaled data. + entryOut.Data = mem.valueCopy() + entryOut.Values, err = unmarshalCorpusFile(entryOut.Data) + if err != nil { + return CorpusEntry{}, minimizeResponse{}, fmt.Errorf("workerClient.minimize unmarshaling minimized value: %v", err) + } + } + + // Prepare for next iteration of the loop. + if args.Timeout != 0 { + args.Timeout -= resp.Duration + if args.Timeout <= 0 { + break + } + } + if args.Limit != 0 { + args.Limit -= mem.header().count + if args.Limit <= 0 { + break + } + } + } + resp.Count = mem.header().count + h := sha256.Sum256(entryOut.Data) + entryOut.Path = fmt.Sprintf("%x", h[:4]) + return entryOut, resp, retErr } // fuzz tells the worker to call the fuzz method. See workerServer.fuzz. diff --git a/src/internal/fuzz/worker_test.go b/src/internal/fuzz/worker_test.go index ed9722f43a..e2ecf0a9c3 100644 --- a/src/internal/fuzz/worker_test.go +++ b/src/internal/fuzz/worker_test.go @@ -6,6 +6,7 @@ package fuzz import ( "context" + "errors" "flag" "fmt" "internal/race" @@ -13,6 +14,7 @@ import ( "os" "os/signal" "reflect" + "strconv" "testing" "time" ) @@ -156,3 +158,49 @@ func runBenchmarkWorker() { panic(err) } } + +func BenchmarkWorkerMinimize(b *testing.B) { + if race.Enabled { + b.Skip("TODO(48504): fix and re-enable") + } + + ws := &workerServer{ + workerComm: workerComm{memMu: make(chan *sharedMem, 1)}, + } + + mem, err := sharedMemTempFile(workerSharedMemSize) + if err != nil { + b.Fatalf("failed to create temporary shared memory file: %s", err) + } + defer func() { + if err := mem.Close(); err != nil { + b.Error(err) + } + }() + ws.memMu <- mem + + bytes := make([]byte, 1024) + ctx := context.Background() + for sz := 1; sz <= len(bytes); sz <<= 1 { + sz := sz + input := []interface{}{bytes[:sz]} + encodedVals := marshalCorpusFile(input...) + mem = <-ws.memMu + mem.setValue(encodedVals) + ws.memMu <- mem + b.Run(strconv.Itoa(sz), func(b *testing.B) { + i := 0 + ws.fuzzFn = func(_ CorpusEntry) (time.Duration, error) { + if i == 0 { + i++ + return time.Second, errors.New("initial failure for deflake") + } + return time.Second, nil + } + for i := 0; i < b.N; i++ { + b.SetBytes(int64(sz)) + ws.minimize(ctx, minimizeArgs{}) + } + }) + } +} From daf901810553b0ccdd9562523ecfad7d11e9b001 Mon Sep 17 00:00:00 2001 From: Katie Hockman Date: Tue, 7 Dec 2021 13:50:51 -0500 Subject: [PATCH 419/752] cmd/go: fix flaky test Change-Id: I641c7b8bcf8b9a8f0637995b26eea0fbe2900ef9 Reviewed-on: https://go-review.googlesource.com/c/go/+/369978 Reviewed-by: Roland Shoemaker Reviewed-by: Bryan Mills Trust: Katie Hockman Run-TryBot: Katie Hockman TryBot-Result: Gopher Robot --- .../script/test_fuzz_minimize_interesting.txt | 123 +++++++++++++----- 1 file changed, 92 insertions(+), 31 deletions(-) diff --git a/src/cmd/go/testdata/script/test_fuzz_minimize_interesting.txt b/src/cmd/go/testdata/script/test_fuzz_minimize_interesting.txt index c9b04d02ea..5d0de17f6b 100644 --- a/src/cmd/go/testdata/script/test_fuzz_minimize_interesting.txt +++ b/src/cmd/go/testdata/script/test_fuzz_minimize_interesting.txt @@ -1,3 +1,4 @@ +[short] skip [!fuzz-instrumented] skip # Test that when an interesting value is discovered (one that expands coverage), @@ -15,7 +16,7 @@ go test -c -fuzz=. # Build using shared build cache for speed. env GOCACHE=$WORK/gocache exec ./fuzz.test$GOEXE -test.fuzzcachedir=$GOCACHE/fuzz -test.fuzz=FuzzMinCache -test.fuzztime=1000x -go run check_cache.go $GOCACHE/fuzz/FuzzMinCache +go run check_cache/check_cache.go $GOCACHE/fuzz/FuzzMinCache go test -c -fuzz=. # Build using shared build cache for speed. env GOCACHE=$WORK/gocache @@ -25,12 +26,12 @@ env GOCACHE=$WORK/gocache # be flaky like we want. ! exec ./fuzz.test$GOEXE -test.fuzzcachedir=$GOCACHE/fuzz -test.fuzz=FuzzMinimizerCrashInMinimization -test.run=FuzzMinimizerCrashInMinimization -test.fuzztime=10000x -test.parallel=1 ! stdout '^ok' -stdout 'got the minimum size!' +stdout -count=1 'got the minimum size!' stdout -count=1 'flaky failure' stdout FAIL - -# Make sure the crash that was written will fail when run with go test -! go test -run=FuzzMinimizerCrashInMinimization . +# Check that the input written to testdata will reproduce the error, and is the +# smallest possible. +go run check_testdata/check_testdata.go FuzzMinimizerCrashInMinimization 50 # Test that a nonrecoverable error that occurs while minimizing an interesting # input is reported correctly. @@ -39,9 +40,8 @@ stdout FAIL stdout -count=1 'fuzzing process hung or terminated unexpectedly while minimizing' stdout -count=1 'EOF' stdout FAIL - -# Make sure the crash that was written will fail when run with go test -! go test -run=FuzzMinimizerNonrecoverableCrashInMinimization . +# Check that the input written to testdata will reproduce the error. +go run check_testdata/check_testdata.go FuzzMinimizerNonrecoverableCrashInMinimization 100 -- go.mod -- module fuzz @@ -55,8 +55,8 @@ import ( "io" ) -func Y(w io.Writer, b []byte) { - if !bytes.Equal(b, []byte("y")) { +func Y(w io.Writer, s string) { + if !bytes.Equal([]byte(s), []byte("y")) { w.Write([]byte("not equal")) } } @@ -67,45 +67,54 @@ import ( "bytes" "io" "os" + "strings" "testing" + "unicode/utf8" ) func FuzzMinimizerCrashInMinimization(f *testing.F) { - seed := make([]byte, 1000) + seed := strings.Repeat("A", 1000) f.Add(seed) - f.Fuzz(func(t *testing.T, b []byte) { - if len(b) < 50 || len(b) > 1100 { + i := 3 + f.Fuzz(func(t *testing.T, s string) { + if len(s) < 50 || len(s) > 1100 { // Make sure that b is large enough that it can be minimized return } - if !bytes.Equal(b, seed) { - // This should have hit a new edge, and the interesting input - // should be attempting minimization - Y(io.Discard, b) + if s != seed { + // This should hit a new edge, and the interesting input + // should attempt minimization + Y(io.Discard, s) } - if len(b) < 55 { + if i > 0 { + // Don't let it fail right away. + i-- + } else if utf8.RuneCountInString(s) == len(s) && len(s) <= 100 { + // Make sure this only fails if the number of bytes in the + // marshaled string is the same as the unmarshaled string, + // so that we can check the length of the testdata file. t.Error("flaky failure") - } - if len(b) == 50 { - t.Log("got the minimum size!") + if len(s) == 50 { + t.Error("got the minimum size!") + } } }) } func FuzzMinimizerNonrecoverableCrashInMinimization(f *testing.F) { - seed := make([]byte, 1000) + seed := strings.Repeat("A", 1000) f.Add(seed) - f.Fuzz(func(t *testing.T, b []byte) { - if len(b) < 50 || len(b) > 1100 { - // Make sure that b is large enough that it can be minimized + i := 3 + f.Fuzz(func(t *testing.T, s string) { + if len(s) < 50 || len(s) > 1100 { return } - if !bytes.Equal(b, seed) { - // This should have hit a new edge, and the interesting input - // should be attempting minimization - Y(io.Discard, b) + if s != seed { + Y(io.Discard, s) } - if len(b) < 55 { + if i > 0 { + i-- + } else if utf8.RuneCountInString(s) == len(s) && len(s) <= 100 { os.Exit(19) } }) @@ -131,7 +140,59 @@ func sum(buf []byte) int { } return n } --- check_cache.go -- +-- check_testdata/check_testdata.go -- +//go:build ignore +// +build ignore + +// check_testdata.go checks that the string written +// is not longer than the provided length. +package main + +import ( + "fmt" + "io/ioutil" + "os" + "path/filepath" + "strconv" +) + +func main() { + wantLen, err := strconv.Atoi(os.Args[2]) + if err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } + testName := os.Args[1] + dir := filepath.Join("testdata/fuzz", testName) + + files, err := ioutil.ReadDir(dir) + if err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } + + if len(files) == 0 { + fmt.Fprintf(os.Stderr, "expect at least one failure to be written to testdata\n") + os.Exit(1) + } + + fname := files[0].Name() + contents, err := ioutil.ReadFile(filepath.Join(dir, fname)) + if err != nil { + fmt.Fprintln(os.Stderr, err) + os.Exit(1) + } + contentsLen := len(contents) - len(`go test fuzz v1 +string("") +`) + if got, want := contentsLen, wantLen; got > want { + fmt.Fprintf(os.Stderr, "expect length <= %d, got %d\n", want, got) + os.Exit(1) + } + fmt.Fprintf(os.Stderr, "%s\n", contents) +} + +-- check_cache/check_cache.go -- //go:build ignore // +build ignore From dc50d69119ca8070dd16fb968b46f21f854d89fb Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Tue, 7 Dec 2021 14:37:37 -0500 Subject: [PATCH 420/752] doc/go1.18: drop TODO for "Changes to the language" For #47694 Change-Id: I142776001eecb451e8722163cfd3f2ecb0ecf35c Reviewed-on: https://go-review.googlesource.com/c/go/+/369980 Trust: Austin Clements Reviewed-by: Jeremy Faller --- doc/go1.18.html | 4 ---- 1 file changed, 4 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 4a09cb6773..8131afffdb 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -25,10 +25,6 @@ Do not send CLs removing the interior tags from such phrases.

      Changes to the language

      -

      - TODO: complete this section -

      -

      Generics

      From e08d1fba37ad32fbe7e8d57cd75c9a88dfdde87f Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Tue, 7 Dec 2021 14:51:45 -0500 Subject: [PATCH 421/752] doc/go1.18: mention bytes.Cut and strings.Cut For #47694. Updates #46336. Change-Id: Ibbd058a1fd4d6b0aa38d3e8dc15b560d1e149f7e Reviewed-on: https://go-review.googlesource.com/c/go/+/369981 Trust: Austin Clements Reviewed-by: Jeremy Faller --- doc/go1.18.html | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 8131afffdb..06c6786bf2 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -403,6 +403,16 @@ Do not send CLs removing the interior tags from such phrases.

      bytes
      +

      + The new Cut function + slices a []byte around a separator. It can replace + and simplify many common uses of + Index, + IndexByte, + IndexRune, + and SplitN. +

      +

      Trim, TrimLeft, and TrimRight are now allocation free and, especially for @@ -414,10 +424,6 @@ Do not send CLs removing the interior tags from such phrases. handle Unicode punctuation and language-specific capitalization rules, and is superseded by the golang.org/x/text/cases package.

      - -

      - TODO: bytes.Cut. -

      @@ -709,6 +715,16 @@ Do not send CLs removing the interior tags from such phrases.
      strings
      +

      + The new Cut function + slices a string around a separator. It can replace + and simplify many common uses of + Index, + IndexByte, + IndexRune, + and SplitN. +

      +

      The new Clone function copies the input string without the returned cloned string referencing @@ -726,10 +742,6 @@ Do not send CLs removing the interior tags from such phrases. handle Unicode punctuation and language-specific capitalization rules, and is superseded by the golang.org/x/text/cases package.

      - -

      - TODO: strings.Cut. -

      From cf1ec173603f950aaccb549602ed0fee57e6b709 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Mon, 6 Dec 2021 16:30:19 -0800 Subject: [PATCH 422/752] cmd/compile: deal with unsatisfiable type assertion in some instantiations Deal with case where a certain instantiation of a generic function/method leads to an unsatisfiable type assertion or type case. In that case, the compiler was causing a fatal error while trying to create an impossible itab for the dictionary. To deal with that case, allow ITabLsym() to create a dummy itab even when the concrete type doesn't implement the interface. This dummy itab is analogous to the "negative" itabs created on-the-fly by the runtime. We will use the dummy itab in type asserts and type switches in instantiations that use that dictionary entry. Since the dummy itab can never be used for any real value at runtime (since the concrete type doesn't implement the interface), there will always be a failure for the corresponding type assertion or a non-match for the corresponding type-switch case. Fixes #50002 Change-Id: I1df05b1019533e1fc93dd7ab29f331a74fab9202 Reviewed-on: https://go-review.googlesource.com/c/go/+/369894 Reviewed-by: Keith Randall Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot --- .../compile/internal/reflectdata/reflect.go | 30 ++++++--- test/run.go | 1 + test/typeparam/issue50002.go | 64 +++++++++++++++++++ 3 files changed, 86 insertions(+), 9 deletions(-) create mode 100644 test/typeparam/issue50002.go diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go index 142b289dae..b1e2902385 100644 --- a/src/cmd/compile/internal/reflectdata/reflect.go +++ b/src/cmd/compile/internal/reflectdata/reflect.go @@ -846,14 +846,19 @@ func TypePtr(t *types.Type) *ir.AddrExpr { return typecheck.Expr(typecheck.NodAddr(n)).(*ir.AddrExpr) } -// ITabLsym returns the LSym representing the itab for concreate type typ -// implementing interface iface. +// ITabLsym returns the LSym representing the itab for concrete type typ implementing +// interface iface. A dummy tab will be created in the unusual case where typ doesn't +// implement iface. Normally, this wouldn't happen, because the typechecker would +// have reported a compile-time error. This situation can only happen when the +// destination type of a type assert or a type in a type switch is parameterized, so +// it may sometimes, but not always, be a type that can't implement the specified +// interface. func ITabLsym(typ, iface *types.Type) *obj.LSym { s, existed := ir.Pkgs.Itab.LookupOK(typ.LinkString() + "," + iface.LinkString()) lsym := s.Linksym() if !existed { - writeITab(lsym, typ, iface) + writeITab(lsym, typ, iface, true) } return lsym } @@ -865,7 +870,7 @@ func ITabAddr(typ, iface *types.Type) *ir.AddrExpr { lsym := s.Linksym() if !existed { - writeITab(lsym, typ, iface) + writeITab(lsym, typ, iface, false) } n := ir.NewLinksymExpr(base.Pos, lsym, types.Types[types.TUINT8]) @@ -1277,9 +1282,10 @@ func WriteRuntimeTypes() { } } -// writeITab writes the itab for concrete type typ implementing -// interface iface. -func writeITab(lsym *obj.LSym, typ, iface *types.Type) { +// writeITab writes the itab for concrete type typ implementing interface iface. If +// allowNonImplement is true, allow the case where typ does not implement iface, and just +// create a dummy itab with zeroed-out method entries. +func writeITab(lsym *obj.LSym, typ, iface *types.Type, allowNonImplement bool) { // TODO(mdempsky): Fix methodWrapper, geneq, and genhash (and maybe // others) to stop clobbering these. oldpos, oldfn := base.Pos, ir.CurFunc @@ -1306,7 +1312,8 @@ func writeITab(lsym *obj.LSym, typ, iface *types.Type) { } } } - if len(sigs) != 0 { + completeItab := len(sigs) == 0 + if !allowNonImplement && !completeItab { base.Fatalf("incomplete itab") } @@ -1323,7 +1330,12 @@ func writeITab(lsym *obj.LSym, typ, iface *types.Type) { o = objw.Uint32(lsym, o, types.TypeHash(typ)) // copy of type hash o += 4 // skip unused field for _, fn := range entries { - o = objw.SymPtrWeak(lsym, o, fn, 0) // method pointer for each method + if !completeItab { + // If typ doesn't implement iface, make method entries be zero. + o = objw.Uintptr(lsym, o, 0) + } else { + o = objw.SymPtrWeak(lsym, o, fn, 0) // method pointer for each method + } } // Nothing writes static itabs, so they are read only. objw.Global(lsym, int32(o), int16(obj.DUPOK|obj.RODATA)) diff --git a/test/run.go b/test/run.go index e17d9729bc..2ff7117ea9 100644 --- a/test/run.go +++ b/test/run.go @@ -2182,6 +2182,7 @@ var unifiedFailures = setOf( "fixedbugs/issue42058b.go", // unified IR doesn't report channel element too large "fixedbugs/issue49767.go", // unified IR doesn't report channel element too large "fixedbugs/issue49814.go", // unified IR doesn't report array type too large + "typeparam/issue50002.go", // pure stenciling leads to a static type assertion error ) func setOf(keys ...string) map[string]bool { diff --git a/test/typeparam/issue50002.go b/test/typeparam/issue50002.go new file mode 100644 index 0000000000..670fc2eae3 --- /dev/null +++ b/test/typeparam/issue50002.go @@ -0,0 +1,64 @@ +// run -gcflags=-G=3 + +// 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 for cases where certain instantiations of a generic function (F in this +// example) will always fail on a type assertion or mismatch on a type case. + +package main + +import "fmt" + +type S struct{} + +func (S) M() byte { + return 0 +} + +type I[T any] interface { + M() T +} + +func F[T, A any](x I[T], shouldMatch bool) { + switch x.(type) { + case A: + if !shouldMatch { + fmt.Printf("wanted mis-match, got match") + } + default: + if shouldMatch { + fmt.Printf("wanted match, got mismatch") + } + } + + _, ok := x.(A) + if ok != shouldMatch { + fmt.Printf("ok: got %v, wanted %v", ok, shouldMatch) + } + + if !shouldMatch { + defer func() { + if shouldMatch { + fmt.Printf("Shouldn't have panicked") + } + recover() + }() + } + _ = x.(A) + if !shouldMatch { + fmt.Printf("Should have panicked") + } +} + +func main() { + // Test instantiation where the type switch/type asserts can't possibly succeed + // (since string does not implement I[byte]). + F[byte, string](S{}, false) + + // Test instantiation where the type switch/type asserts should succeed + // (since S does implement I[byte]) + F[byte, S](S{}, true) + F[byte, S](I[byte](S{}), true) +} From a3ae45ebe1b3576428f5eb27347704b2d099eab0 Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Mon, 6 Dec 2021 16:05:55 -0500 Subject: [PATCH 423/752] runtime/pprof: consume tag for first CPU record profBuf.write uses an index in b.tags for each entry, even if that entry has no tag (that slice entry just remains 0). profBuf.read similarly returns a tags slice with exactly as many entries as there are records in data. profileBuilder.addCPUData iterates through the tags in lockstep with the data records. Except in the special case of the first record, where it forgets to increment tags. Thus the first read of profiling data has all tags off-by-one. To help avoid regressions, addCPUData is changed to assert that tags contains exactly the correct number of tags. For #50007. Change-Id: I5f32f93003297be8d6e33ad472c185d924a63256 Reviewed-on: https://go-review.googlesource.com/c/go/+/369741 Reviewed-by: Austin Clements Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot --- src/runtime/cpuprof.go | 2 ++ src/runtime/pprof/pprof_test.go | 12 +++++++++++- src/runtime/pprof/proto.go | 22 +++++++++++++++------- src/runtime/pprof/proto_test.go | 14 +++++++++----- 4 files changed, 37 insertions(+), 13 deletions(-) diff --git a/src/runtime/cpuprof.go b/src/runtime/cpuprof.go index 6076564716..48cef46fe9 100644 --- a/src/runtime/cpuprof.go +++ b/src/runtime/cpuprof.go @@ -200,6 +200,8 @@ func runtime_pprof_runtime_cyclesPerSecond() int64 { // If profiling is turned off and all the profile data accumulated while it was // on has been returned, readProfile returns eof=true. // The caller must save the returned data and tags before calling readProfile again. +// The returned data contains a whole number of records, and tags contains +// exactly one entry per record. // //go:linkname runtime_pprof_readProfile runtime/pprof.readProfile func runtime_pprof_readProfile() ([]uint64, []unsafe.Pointer, bool) { diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index e32928b347..913f899593 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -1608,6 +1608,7 @@ func TestTryAdd(t *testing.T) { testCases := []struct { name string input []uint64 // following the input format assumed by profileBuilder.addCPUData. + count int // number of records in input. wantLocs [][]string // ordered location entries with function names. wantSamples []*profile.Sample // ordered samples, we care only about Value and the profile location IDs. }{{ @@ -1617,6 +1618,7 @@ func TestTryAdd(t *testing.T) { 3, 0, 500, // hz = 500. Must match the period. 5, 0, 50, inlinedCallerStack[0], inlinedCallerStack[1], }, + count: 2, wantLocs: [][]string{ {"runtime/pprof.inlinedCalleeDump", "runtime/pprof.inlinedCallerDump"}, }, @@ -1633,6 +1635,7 @@ func TestTryAdd(t *testing.T) { 7, 0, 10, inlinedCallerStack[0], inlinedCallerStack[1], inlinedCallerStack[0], inlinedCallerStack[1], 5, 0, 20, inlinedCallerStack[0], inlinedCallerStack[1], }, + count: 3, wantLocs: [][]string{{"runtime/pprof.inlinedCalleeDump", "runtime/pprof.inlinedCallerDump"}}, wantSamples: []*profile.Sample{ {Value: []int64{10, 10 * period}, Location: []*profile.Location{{ID: 1}, {ID: 1}}}, @@ -1646,6 +1649,7 @@ func TestTryAdd(t *testing.T) { // entry. The "stk" entry is actually the count. 4, 0, 0, 4242, }, + count: 2, wantLocs: [][]string{{"runtime/pprof.lostProfileEvent"}}, wantSamples: []*profile.Sample{ {Value: []int64{4242, 4242 * period}, Location: []*profile.Location{{ID: 1}}}, @@ -1664,6 +1668,7 @@ func TestTryAdd(t *testing.T) { 5, 0, 30, inlinedCallerStack[0], inlinedCallerStack[0], 4, 0, 40, inlinedCallerStack[0], }, + count: 3, // inlinedCallerDump shows up here because // runtime_expandFinalInlineFrame adds it to the stack frame. wantLocs: [][]string{{"runtime/pprof.inlinedCalleeDump"}, {"runtime/pprof.inlinedCallerDump"}}, @@ -1677,6 +1682,7 @@ func TestTryAdd(t *testing.T) { 3, 0, 500, // hz = 500. Must match the period. 9, 0, 10, recursionStack[0], recursionStack[1], recursionStack[2], recursionStack[3], recursionStack[4], recursionStack[5], }, + count: 2, wantLocs: [][]string{ {"runtime/pprof.recursionChainBottom"}, { @@ -1700,6 +1706,7 @@ func TestTryAdd(t *testing.T) { 5, 0, 50, inlinedCallerStack[0], inlinedCallerStack[1], 4, 0, 60, inlinedCallerStack[0], }, + count: 3, wantLocs: [][]string{{"runtime/pprof.inlinedCalleeDump", "runtime/pprof.inlinedCallerDump"}}, wantSamples: []*profile.Sample{ {Value: []int64{50, 50 * period}, Location: []*profile.Location{{ID: 1}}}, @@ -1712,6 +1719,7 @@ func TestTryAdd(t *testing.T) { 4, 0, 70, inlinedCallerStack[0], 5, 0, 80, inlinedCallerStack[0], inlinedCallerStack[1], }, + count: 3, wantLocs: [][]string{{"runtime/pprof.inlinedCalleeDump", "runtime/pprof.inlinedCallerDump"}}, wantSamples: []*profile.Sample{ {Value: []int64{70, 70 * period}, Location: []*profile.Location{{ID: 1}}}, @@ -1724,6 +1732,7 @@ func TestTryAdd(t *testing.T) { 3, 0, 500, // hz = 500. Must match the period. 4, 0, 70, inlinedCallerStack[0], }, + count: 2, wantLocs: [][]string{{"runtime/pprof.inlinedCalleeDump", "runtime/pprof.inlinedCallerDump"}}, wantSamples: []*profile.Sample{ {Value: []int64{70, 70 * period}, Location: []*profile.Location{{ID: 1}}}, @@ -1739,6 +1748,7 @@ func TestTryAdd(t *testing.T) { // from getting merged into above. 5, 0, 80, inlinedCallerStack[1], inlinedCallerStack[0], }, + count: 3, wantLocs: [][]string{ {"runtime/pprof.inlinedCalleeDump", "runtime/pprof.inlinedCallerDump"}, {"runtime/pprof.inlinedCallerDump"}, @@ -1751,7 +1761,7 @@ func TestTryAdd(t *testing.T) { for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { - p, err := translateCPUProfile(tc.input) + p, err := translateCPUProfile(tc.input, tc.count) if err != nil { t.Fatalf("translating profile: %v", err) } diff --git a/src/runtime/pprof/proto.go b/src/runtime/pprof/proto.go index 54e7a80183..073a076802 100644 --- a/src/runtime/pprof/proto.go +++ b/src/runtime/pprof/proto.go @@ -266,8 +266,9 @@ func newProfileBuilder(w io.Writer) *profileBuilder { } // addCPUData adds the CPU profiling data to the profile. -// The data must be a whole number of records, -// as delivered by the runtime. +// +// The data must be a whole number of records, as delivered by the runtime. +// len(tags) must be equal to the number of records in data. func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error { if !b.havePeriod { // first record is period @@ -282,6 +283,9 @@ func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error b.period = 1e9 / int64(data[2]) b.havePeriod = true data = data[3:] + // Consume tag slot. Note that there isn't a meaningful tag + // value for this record. + tags = tags[1:] } // Parse CPU samples from the profile. @@ -306,14 +310,14 @@ func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error if data[0] < 3 || tags != nil && len(tags) < 1 { return fmt.Errorf("malformed profile") } + if len(tags) < 1 { + return fmt.Errorf("mismatched profile records and tags") + } count := data[2] stk := data[3:data[0]] data = data[data[0]:] - var tag unsafe.Pointer - if tags != nil { - tag = tags[0] - tags = tags[1:] - } + tag := tags[0] + tags = tags[1:] if count == 0 && len(stk) == 1 { // overflow record @@ -327,6 +331,10 @@ func (b *profileBuilder) addCPUData(data []uint64, tags []unsafe.Pointer) error } b.m.lookup(stk, tag).count += int64(count) } + + if len(tags) != 0 { + return fmt.Errorf("mismatched profile records and tags") + } return nil } diff --git a/src/runtime/pprof/proto_test.go b/src/runtime/pprof/proto_test.go index 4a9749a83f..ea0ed9aefd 100644 --- a/src/runtime/pprof/proto_test.go +++ b/src/runtime/pprof/proto_test.go @@ -17,16 +17,20 @@ import ( "runtime" "strings" "testing" + "unsafe" ) // translateCPUProfile parses binary CPU profiling stack trace data // generated by runtime.CPUProfile() into a profile struct. // This is only used for testing. Real conversions stream the // data into the profileBuilder as it becomes available. -func translateCPUProfile(data []uint64) (*profile.Profile, error) { +// +// count is the number of records in data. +func translateCPUProfile(data []uint64, count int) (*profile.Profile, error) { var buf bytes.Buffer b := newProfileBuilder(&buf) - if err := b.addCPUData(data, nil); err != nil { + tags := make([]unsafe.Pointer, count) + if err := b.addCPUData(data, tags); err != nil { return nil, err } b.build() @@ -46,7 +50,7 @@ func TestConvertCPUProfileEmpty(t *testing.T) { var buf bytes.Buffer b := []uint64{3, 0, 500} // empty profile at 500 Hz (2ms sample period) - p, err := translateCPUProfile(b) + p, err := translateCPUProfile(b, 1) if err != nil { t.Fatalf("translateCPUProfile: %v", err) } @@ -120,7 +124,7 @@ func TestConvertCPUProfile(t *testing.T) { 5, 0, 40, uint64(addr2 + 1), uint64(addr2 + 2), // 40 samples in addr2 5, 0, 10, uint64(addr1 + 1), uint64(addr1 + 2), // 10 samples in addr1 } - p, err := translateCPUProfile(b) + p, err := translateCPUProfile(b, 4) if err != nil { t.Fatalf("translating profile: %v", err) } @@ -429,7 +433,7 @@ func TestEmptyStack(t *testing.T) { 3, 0, 500, // hz = 500 3, 0, 10, // 10 samples with an empty stack trace } - _, err := translateCPUProfile(b) + _, err := translateCPUProfile(b, 2) if err != nil { t.Fatalf("translating profile: %v", err) } From 0a15e7851a0ea1ebe1523bb70a6cfe56488ea2ef Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Mon, 6 Dec 2021 17:26:32 -0500 Subject: [PATCH 424/752] runtime/pprof: assert that labelHog samples are always labeled With https://golang.org/issue/50007 resolved, there are no known issues with pprof labels remaining. Thus, the 10% allowed error in TestLabelSystemstack should not be required. Drop it in favor of an explicit assertion that all samples containing labelHog are properly labeled. This is no flaky in my local testing. It is possible that other bugs will appear at larger testing scale, in which case this CL will be reverted, but then at least we will be aware of additional failure modes. For #50007. Change-Id: I1ef530c303bd9a01af649b8b08d4b35505e8aada Reviewed-on: https://go-review.googlesource.com/c/go/+/369744 Reviewed-by: Bryan Mills Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot --- src/runtime/pprof/pprof_test.go | 68 +++++++++++---------------------- 1 file changed, 22 insertions(+), 46 deletions(-) diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index 913f899593..2e6165ff88 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -1425,52 +1425,8 @@ func TestLabelRace(t *testing.T) { // TestLabelSystemstack makes sure CPU profiler samples of goroutines running // on systemstack include the correct pprof labels. See issue #48577 func TestLabelSystemstack(t *testing.T) { - matchBasics := matchAndAvoidStacks(stackContainsLabeled, []string{"runtime.systemstack;key=value"}, avoidFunctions()) - matches := func(t *testing.T, prof *profile.Profile) bool { - if !matchBasics(t, prof) { - return false - } - - var withLabel, withoutLabel int64 - for _, s := range prof.Sample { - var systemstack, labelHog bool - for _, loc := range s.Location { - for _, l := range loc.Line { - switch l.Function.Name { - case "runtime.systemstack": - systemstack = true - case "runtime/pprof.labelHog": - labelHog = true - } - } - } - - if systemstack && labelHog { - if s.Label != nil && contains(s.Label["key"], "value") { - withLabel += s.Value[0] - } else { - withoutLabel += s.Value[0] - } - } - } - - // ratio on 2019 Intel MBP before/after CL 351751 for n=30 runs: - // before: mean=0.013 stddev=0.013 min=0.000 max=0.039 - // after : mean=0.996 stddev=0.007 min=0.967 max=1.000 - // - // TODO: Figure out why some samples (containing gcWriteBarrier, gcStart) - // still have labelHog without labels. Once fixed this test case can be - // simplified to just check that all samples containing labelHog() have the - // label, and no other samples do. - ratio := float64(withLabel) / float64((withLabel + withoutLabel)) - if ratio < 0.9 { - t.Logf("only %.1f%% of labelHog(systemstack()) samples have label", ratio*100) - return false - } - return true - } - - testCPUProfile(t, matches, func(dur time.Duration) { + matches := matchAndAvoidStacks(stackContainsLabeled, []string{"runtime.systemstack;key=value"}, avoidFunctions()) + p := testCPUProfile(t, matches, func(dur time.Duration) { Do(context.Background(), Labels("key", "value"), func(context.Context) { var wg sync.WaitGroup stop := make(chan struct{}) @@ -1487,6 +1443,26 @@ func TestLabelSystemstack(t *testing.T) { wg.Wait() }) }) + + // labelHog should always be labeled. + for _, s := range p.Sample { + for _, loc := range s.Location { + for _, l := range loc.Line { + if l.Function.Name != "runtime/pprof.labelHog" { + continue + } + + if s.Label == nil { + t.Errorf("labelHog sample labels got nil want key=value") + continue + } + if !contains(s.Label["key"], "value") { + t.Errorf("labelHog sample labels got %+v want contains key=value", s.Label) + continue + } + } + } + } } // labelHog is designed to burn CPU time in a way that a high number of CPU From 34573aeb9717cf20d768e640c263b294df5318a4 Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Tue, 7 Dec 2021 22:51:46 +0000 Subject: [PATCH 425/752] Revert "build: for default bootstrap, use Go 1.17 if present, falling back to Go 1.4" This reverts https://golang.org/cl/369914. Reason for revert: Breaking previously working toolchain builds. For #44505. Change-Id: I09ae20e50109a600d036358118077d27669df39c Reviewed-on: https://go-review.googlesource.com/c/go/+/370138 Reviewed-by: Dmitri Shuralyov Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot --- src/cmd/dist/buildtool.go | 13 +------------ src/make.bash | 9 +-------- src/make.bat | 2 -- src/make.rc | 3 --- 4 files changed, 2 insertions(+), 25 deletions(-) diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go index 17538ad5a4..75f04a975c 100644 --- a/src/cmd/dist/buildtool.go +++ b/src/cmd/dist/buildtool.go @@ -93,21 +93,10 @@ var ignoreSuffixes = []string{ "_test.go", } -var tryDirs = []string{ - "sdk/go1.17", - "go1.17", -} - func bootstrapBuildTools() { goroot_bootstrap := os.Getenv("GOROOT_BOOTSTRAP") if goroot_bootstrap == "" { - home := os.Getenv("HOME") - goroot_bootstrap = pathf("%s/go1.4", home) - for _, d := range tryDirs { - if p := pathf("%s/%s", home, d); isdir(p) { - goroot_bootstrap = p - } - } + goroot_bootstrap = pathf("%s/go1.4", os.Getenv("HOME")) } xprintf("Building Go toolchain1 using %s.\n", goroot_bootstrap) diff --git a/src/make.bash b/src/make.bash index 2d6c47272e..3310692a18 100755 --- a/src/make.bash +++ b/src/make.bash @@ -153,14 +153,7 @@ if [ "$1" = "-v" ]; then fi goroot_bootstrap_set=${GOROOT_BOOTSTRAP+"true"} -if [ -z "$GOROOT_BOOTSTRAP" ]; then - GOROOT_BOOTSTRAP="$HOME/go1.4" - for d in sdk/go1.17 go1.17; do - if [ -d "$HOME/$d" ]; then - GOROOT_BOOTSTRAP="$HOME/$d" - fi - done -fi +export GOROOT_BOOTSTRAP=${GOROOT_BOOTSTRAP:-$HOME/go1.4} export GOROOT="$(cd .. && pwd)" IFS=$'\n'; for go_exe in $(type -ap go); do if [ ! -x "$GOROOT_BOOTSTRAP/bin/go" ]; then diff --git a/src/make.bat b/src/make.bat index 6bffee050e..8f2825b09a 100644 --- a/src/make.bat +++ b/src/make.bat @@ -83,8 +83,6 @@ for /f "tokens=*" %%g in ('where go 2^>nul') do ( ) ) ) -if "x%GOROOT_BOOTSTRAP%"=="x" if exist "%HOMEDRIVE%%HOMEPATH%\go1.17" set GOROOT_BOOTSTRAP=%HOMEDRIVE%%HOMEPATH%\go1.17 -if "x%GOROOT_BOOTSTRAP%"=="x" if exist "%HOMEDRIVE%%HOMEPATH%\sdk\go1.17" set GOROOT_BOOTSTRAP=%HOMEDRIVE%%HOMEPATH%\sdk\go1.17 if "x%GOROOT_BOOTSTRAP%"=="x" set GOROOT_BOOTSTRAP=%HOMEDRIVE%%HOMEPATH%\Go1.4 :bootstrapset diff --git a/src/make.rc b/src/make.rc index 37087d6357..ba8c5db2d9 100755 --- a/src/make.rc +++ b/src/make.rc @@ -55,9 +55,6 @@ goroot_bootstrap_set = 'true' if(! ~ $#GOROOT_BOOTSTRAP 1){ goroot_bootstrap_set = 'false' GOROOT_BOOTSTRAP = $home/go1.4 - for(d in sdk/go1.17 go1.17) - if(test -d $home/$d) - GOROOT_BOOTSTRAP = $home/$d } for(p in $path){ if(! test -x $GOROOT_BOOTSTRAP/bin/go){ From 016e6ebb4264f4b46e505bb404953cdb410f63f2 Mon Sep 17 00:00:00 2001 From: Hana Date: Tue, 7 Dec 2021 17:50:50 -0500 Subject: [PATCH 426/752] cmd/go: fix references to old `go mod editwork` That is replaced by `go work edit`. Change-Id: I39996c7bea0182a18edf6a1f70b6616c74099a1b Reviewed-on: https://go-review.googlesource.com/c/go/+/370139 Reviewed-by: Michael Matloob Trust: Hyang-Ah Hana Kim --- src/cmd/go/alldocs.go | 10 +++++----- src/cmd/go/internal/modload/init.go | 2 +- src/cmd/go/internal/workcmd/edit.go | 10 +++++----- src/cmd/go/internal/workcmd/init.go | 6 +++--- src/cmd/go/testdata/script/work_replace_conflict.txt | 2 +- 5 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index b9fca791be..f9a2b59c05 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -1407,10 +1407,10 @@ // // go work edit [editing flags] [go.work] // -// Editwork provides a command-line interface for editing go.work, +// Edit provides a command-line interface for editing go.work, // for use primarily by tools or scripts. It only reads go.work; // it does not look up information about the modules involved. -// If no file is specified, editwork looks for a go.work file in the current +// If no file is specified, Edit looks for a go.work file in the current // directory and its parent directories // // The editing flags specify a sequence of editing operations. @@ -1418,7 +1418,7 @@ // The -fmt flag reformats the go.work file without making other changes. // This reformatting is also implied by any other modifications that use or // rewrite the go.mod file. The only time this flag is needed is if no other -// flags are specified, as in 'go mod editwork -fmt'. +// flags are specified, as in 'go work edit -fmt'. // // The -use=path and -dropuse=path flags // add and drop a use directive from the go.work file's set of module directories. @@ -1478,10 +1478,10 @@ // // go work init [moddirs] // -// go mod initwork initializes and writes a new go.work file in the current +// Init initializes and writes a new go.work file in the current // directory, in effect creating a new workspace at the current directory. // -// go mod initwork optionally accepts paths to the workspace modules as arguments. +// go work init optionally accepts paths to the workspace modules as arguments. // If the argument is omitted, an empty workspace with no modules will be created. // // See the workspaces design proposal at diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go index 943547e71b..854c17d776 100644 --- a/src/cmd/go/internal/modload/init.go +++ b/src/cmd/go/internal/modload/init.go @@ -1019,7 +1019,7 @@ func makeMainModules(ms []module.Version, rootDirs []string, modFiles []*modfile if replacedByWorkFile[r.Old.Path] { continue } else if prev, ok := replacements[r.Old]; ok && !curModuleReplaces[r.Old] && prev != r.New { - base.Fatalf("go: conflicting replacements for %v:\n\t%v\n\t%v\nuse \"go mod editwork -replace %v=[override]\" to resolve", r.Old, prev, r.New, r.Old) + base.Fatalf("go: conflicting replacements for %v:\n\t%v\n\t%v\nuse \"go work edit -replace %v=[override]\" to resolve", r.Old, prev, r.New, r.Old) } curModuleReplaces[r.Old] = true replacements[r.Old] = r.New diff --git a/src/cmd/go/internal/workcmd/edit.go b/src/cmd/go/internal/workcmd/edit.go index 03a27f2bc6..c42000710e 100644 --- a/src/cmd/go/internal/workcmd/edit.go +++ b/src/cmd/go/internal/workcmd/edit.go @@ -24,10 +24,10 @@ import ( var cmdEdit = &base.Command{ UsageLine: "go work edit [editing flags] [go.work]", Short: "edit go.work from tools or scripts", - Long: `Editwork provides a command-line interface for editing go.work, + Long: `Edit provides a command-line interface for editing go.work, for use primarily by tools or scripts. It only reads go.work; it does not look up information about the modules involved. -If no file is specified, editwork looks for a go.work file in the current +If no file is specified, Edit looks for a go.work file in the current directory and its parent directories The editing flags specify a sequence of editing operations. @@ -35,7 +35,7 @@ The editing flags specify a sequence of editing operations. The -fmt flag reformats the go.work file without making other changes. This reformatting is also implied by any other modifications that use or rewrite the go.mod file. The only time this flag is needed is if no other -flags are specified, as in 'go mod editwork -fmt'. +flags are specified, as in 'go work edit -fmt'. The -use=path and -dropuse=path flags add and drop a use directive from the go.work file's set of module directories. @@ -123,7 +123,7 @@ func runEditwork(ctx context.Context, cmd *base.Command, args []string) { len(workedits) > 0 if !anyFlags { - base.Fatalf("go: no flags specified (see 'go help mod editwork').") + base.Fatalf("go: no flags specified (see 'go help work edit').") } if *editJSON && *editPrint { @@ -131,7 +131,7 @@ func runEditwork(ctx context.Context, cmd *base.Command, args []string) { } if len(args) > 1 { - base.Fatalf("go: 'go mod editwork' accepts at most one argument") + base.Fatalf("go: 'go help work edit' accepts at most one argument") } var gowork string if len(args) == 1 { diff --git a/src/cmd/go/internal/workcmd/init.go b/src/cmd/go/internal/workcmd/init.go index fde1483efb..2297ac20d0 100644 --- a/src/cmd/go/internal/workcmd/init.go +++ b/src/cmd/go/internal/workcmd/init.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. -// go mod initwork +// go work init package workcmd @@ -20,10 +20,10 @@ import ( var cmdInit = &base.Command{ UsageLine: "go work init [moddirs]", Short: "initialize workspace file", - Long: `go mod initwork initializes and writes a new go.work file in the current + Long: `Init initializes and writes a new go.work file in the current directory, in effect creating a new workspace at the current directory. -go mod initwork optionally accepts paths to the workspace modules as arguments. +go work init optionally accepts paths to the workspace modules as arguments. If the argument is omitted, an empty workspace with no modules will be created. See the workspaces design proposal at diff --git a/src/cmd/go/testdata/script/work_replace_conflict.txt b/src/cmd/go/testdata/script/work_replace_conflict.txt index e5677b21d7..81d1fcb043 100644 --- a/src/cmd/go/testdata/script/work_replace_conflict.txt +++ b/src/cmd/go/testdata/script/work_replace_conflict.txt @@ -2,7 +2,7 @@ # overriding it in the go.work file. ! go list -m example.com/dep -stderr 'go: conflicting replacements for example.com/dep@v1.0.0:\n\t./dep1\n\t./dep2\nuse "go mod editwork -replace example.com/dep@v1.0.0=\[override\]" to resolve' +stderr 'go: conflicting replacements for example.com/dep@v1.0.0:\n\t./dep1\n\t./dep2\nuse "go work edit -replace example.com/dep@v1.0.0=\[override\]" to resolve' go work edit -replace example.com/dep@v1.0.0=./dep1 go list -m example.com/dep stdout 'example.com/dep v1.0.0 => ./dep1' From a19e72cb89fd33e5bf1474887e267806f65b7a40 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 7 Dec 2021 09:50:44 -0800 Subject: [PATCH 427/752] doc/go1.18: move fuzzing to tools section For #47694 Change-Id: Idab1a5822a096447c71776ee4339c4262183ceb7 Reviewed-on: https://go-review.googlesource.com/c/go/+/370034 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Katie Hockman Trust: Katie Hockman --- doc/go1.18.html | 42 +++++++++++++++++++++--------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 06c6786bf2..10a05ad886 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -112,27 +112,6 @@ Do not send CLs removing the interior tags from such phrases. programs is likely very small.

      -

      Fuzzing

      - -

      - Go 1.18 includes an implementation of fuzzing as described by - the fuzzing proposal. -

      - -

      - See the fuzzing landing page to get - started. -

      - -

      - Please be aware that fuzzing can consume a lot of memory and may impact your - machine’s performance while it runs. Also be aware that the fuzzing engine - writes values that expand test coverage to a fuzz cache directory within - $GOCACHE/fuzz while it runs. There is currently no limit to the - number of files or total bytes that may be written to the fuzz cache, so it - may occupy a large amount of storage (possibly several GBs). -

      -

      Ports

      AMD64

      @@ -183,6 +162,27 @@ Do not send CLs removing the interior tags from such phrases.

      Tools

      +

      Fuzzing

      + +

      + Go 1.18 includes an implementation of fuzzing as described by + the fuzzing proposal. +

      + +

      + See the fuzzing landing page to get + started. +

      + +

      + Please be aware that fuzzing can consume a lot of memory and may impact your + machine’s performance while it runs. Also be aware that the fuzzing engine + writes values that expand test coverage to a fuzz cache directory within + $GOCACHE/fuzz while it runs. There is currently no limit to the + number of files or total bytes that may be written to the fuzz cache, so it + may occupy a large amount of storage (possibly several GBs). +

      +

      Go command

      From 08025a9d6d7d33f3ac0c78b4d067bdc339225507 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 7 Dec 2021 17:09:41 -0500 Subject: [PATCH 428/752] cmd: go get golang.org/x/tools@fd2bfb7 (Dec 7 2021) cd src/cmd go get golang.org/x/tools@fd2bfb7 go mod tidy go mod vendor Brings in fixes to cmd/vet for 'any' changes. Change-Id: I70a48d451bd99f5d82f91fd079fbdd1b4bac2520 Reviewed-on: https://go-review.googlesource.com/c/go/+/370136 Trust: Russ Cox Reviewed-by: Ian Lance Taylor Run-TryBot: Ian Lance Taylor --- src/cmd/go.mod | 2 +- src/cmd/go.sum | 4 ++-- .../x/tools/go/analysis/passes/stdmethods/stdmethods.go | 6 ++++-- src/cmd/vendor/modules.txt | 2 +- 4 files changed, 8 insertions(+), 6 deletions(-) diff --git a/src/cmd/go.mod b/src/cmd/go.mod index 434081eb2f..f46c770c19 100644 --- a/src/cmd/go.mod +++ b/src/cmd/go.mod @@ -8,7 +8,7 @@ require ( golang.org/x/mod v0.6.0-dev.0.20211102181907-3a5865c02020 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 - golang.org/x/tools v0.1.8-0.20211202032535-e212aff8fd14 + golang.org/x/tools v0.1.9-0.20211207220608-fd2bfb79a16a ) require ( diff --git a/src/cmd/go.sum b/src/cmd/go.sum index 4b7aa6994c..941011fe09 100644 --- a/src/cmd/go.sum +++ b/src/cmd/go.sum @@ -18,7 +18,7 @@ golang.org/x/sys v0.0.0-20211205182925-97ca703d548d h1:FjkYO/PPp4Wi0EAUOVLxePm7q golang.org/x/sys v0.0.0-20211205182925-97ca703d548d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/tools v0.1.8-0.20211202032535-e212aff8fd14 h1:KPFD5zp3T4bZL/kdosp4tGDJ6DKwUmYSWM0twy7w/bg= -golang.org/x/tools v0.1.8-0.20211202032535-e212aff8fd14/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= +golang.org/x/tools v0.1.9-0.20211207220608-fd2bfb79a16a h1:G+TZ7v63o8mn+LBWOdnHaiypIhcgFZ6BDDnyX+RXDYg= +golang.org/x/tools v0.1.9-0.20211207220608-fd2bfb79a16a/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stdmethods/stdmethods.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stdmethods/stdmethods.go index 64a28ac0b9..cc9497179d 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stdmethods/stdmethods.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/stdmethods/stdmethods.go @@ -61,7 +61,7 @@ var Analyzer = &analysis.Analyzer{ // we let it go. But if it does have a fmt.ScanState, then the // rest has to match. var canonicalMethods = map[string]struct{ args, results []string }{ - "As": {[]string{"interface{}"}, []string{"bool"}}, // errors.As + "As": {[]string{"any"}, []string{"bool"}}, // errors.As // "Flush": {{}, {"error"}}, // http.Flusher and jpeg.writer conflict "Format": {[]string{"=fmt.State", "rune"}, []string{}}, // fmt.Formatter "GobDecode": {[]string{"[]byte"}, []string{"error"}}, // gob.GobDecoder @@ -194,7 +194,9 @@ func matchParams(pass *analysis.Pass, expect []string, actual *types.Tuple, pref func matchParamType(expect string, actual types.Type) bool { expect = strings.TrimPrefix(expect, "=") // Overkill but easy. - return typeString(actual) == expect + t := typeString(actual) + return t == expect || + (t == "any" || t == "interface{}") && (expect == "any" || expect == "interface{}") } var errorType = types.Universe.Lookup("error").Type().Underlying().(*types.Interface) diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt index 5ce2fe2f63..22dd145a55 100644 --- a/src/cmd/vendor/modules.txt +++ b/src/cmd/vendor/modules.txt @@ -51,7 +51,7 @@ golang.org/x/sys/windows # golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 ## explicit; go 1.17 golang.org/x/term -# golang.org/x/tools v0.1.8-0.20211202032535-e212aff8fd14 +# golang.org/x/tools v0.1.9-0.20211207220608-fd2bfb79a16a ## explicit; go 1.17 golang.org/x/tools/cover golang.org/x/tools/go/analysis From 9fe77de3c198848b972915245e41ff26439b08aa Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 8 Dec 2021 09:49:04 -0500 Subject: [PATCH 429/752] debug/buildinfo: update test for CL 369977 As a side effect of the changes in cmd/go/internal/work in CL 369977, binaries built in GOPATH mode now include rudimentary build metadata for at least the package path and compiler in use. That seems like a strict improvement, but the test needs to be updated to reflect the newly-available metadata. Change-Id: I657c785e3e9992ed594c9524409f2d076f9eb376 Reviewed-on: https://go-review.googlesource.com/c/go/+/370234 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Russ Cox TryBot-Result: Gopher Robot Reviewed-by: Cherry Mui --- src/debug/buildinfo/buildinfo_test.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/debug/buildinfo/buildinfo_test.go b/src/debug/buildinfo/buildinfo_test.go index fd31caf135..8346be0109 100644 --- a/src/debug/buildinfo/buildinfo_test.go +++ b/src/debug/buildinfo/buildinfo_test.go @@ -177,7 +177,9 @@ func TestReadFile(t *testing.T) { { name: "valid_gopath", build: buildWithGOPATH, - want: "go\tGOVERSION\n", + want: "go\tGOVERSION\n" + + "path\texample.com/m\n" + + "build\t-compiler=gc\n", }, { name: "invalid_gopath", From 2c85fcd47d6804d94a1fa4da65f756200ecf57a8 Mon Sep 17 00:00:00 2001 From: Bryan Mills Date: Tue, 7 Dec 2021 20:34:46 +0000 Subject: [PATCH 430/752] Revert "net: in (*netFD).dial, use the passed in local address if getsockname fails" This reverts CL 366536 Reason for revert: may have caused #50033 due to an invalid or partially-populated *TCPAddr Fixes #50033 Change-Id: Ia29ca4116503dba65d56e89caa46ba1c848d421a Reviewed-on: https://go-review.googlesource.com/c/go/+/369982 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/net/server_test.go | 10 +--------- src/net/sock_posix.go | 16 +++++----------- 2 files changed, 6 insertions(+), 20 deletions(-) diff --git a/src/net/server_test.go b/src/net/server_test.go index b69cd29289..33d33b0337 100644 --- a/src/net/server_test.go +++ b/src/net/server_test.go @@ -200,17 +200,9 @@ func TestUnixAndUnixpacketServer(t *testing.T) { if c == nil { panic("Dial returned a nil Conn") } - rc := reflect.ValueOf(c) - if rc.IsNil() { + if rc := reflect.ValueOf(c); rc.Kind() == reflect.Pointer && rc.IsNil() { panic(fmt.Sprintf("Dial returned a nil %T", c)) } - fd := rc.Elem().FieldByName("fd") - if fd.IsNil() { - panic(fmt.Sprintf("Dial returned a %T with a nil fd", c)) - } - if addr := fd.Elem().FieldByName("laddr"); addr.IsNil() { - panic(fmt.Sprintf("Dial returned a %T whose fd has a nil laddr", c)) - } addr := c.LocalAddr() if addr == nil { panic(fmt.Sprintf("(%T).LocalAddr returned a nil Addr", c)) diff --git a/src/net/sock_posix.go b/src/net/sock_posix.go index 603fb2bb64..98a48229c7 100644 --- a/src/net/sock_posix.go +++ b/src/net/sock_posix.go @@ -156,24 +156,18 @@ func (fd *netFD) dial(ctx context.Context, laddr, raddr sockaddr, ctrlFn func(st } } // Record the local and remote addresses from the actual socket. - // For the local address, use - // 1) the one returned by Getsockname, if that succeeds; or - // 2) the one passed to us as the laddr parameter; or - // 3) nil. + // Get the local address by calling Getsockname. // For the remote address, use // 1) the one returned by the connect method, if any; or // 2) the one from Getpeername, if it succeeds; or // 3) the one passed to us as the raddr parameter. - var laddrName Addr = laddr - if lsa, err := syscall.Getsockname(fd.pfd.Sysfd); err == nil { - laddrName = fd.addrFunc()(lsa) - } + lsa, _ = syscall.Getsockname(fd.pfd.Sysfd) if crsa != nil { - fd.setAddr(laddrName, fd.addrFunc()(crsa)) + fd.setAddr(fd.addrFunc()(lsa), fd.addrFunc()(crsa)) } else if rsa, _ = syscall.Getpeername(fd.pfd.Sysfd); rsa != nil { - fd.setAddr(laddrName, fd.addrFunc()(rsa)) + fd.setAddr(fd.addrFunc()(lsa), fd.addrFunc()(rsa)) } else { - fd.setAddr(laddrName, raddr) + fd.setAddr(fd.addrFunc()(lsa), raddr) } return nil } From 3042ba34db86853c7035046716c4a00b2dbef2ed Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Tue, 7 Dec 2021 17:32:55 -0500 Subject: [PATCH 431/752] net/smtp: skip TestTLSSClient on all freebsd platforms This test seems like it needs attention from a TLS and/or FreeBSD expert. In the meantime, it needs to stop causing noise on the build dashboard. For #19229 Change-Id: If7e9e3533ae7cb29006a670c3e9df90512dcf9f2 Reviewed-on: https://go-review.googlesource.com/c/go/+/370137 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/net/smtp/smtp_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/net/smtp/smtp_test.go b/src/net/smtp/smtp_test.go index 55219372d2..0f758f4a33 100644 --- a/src/net/smtp/smtp_test.go +++ b/src/net/smtp/smtp_test.go @@ -948,7 +948,7 @@ QUIT ` func TestTLSClient(t *testing.T) { - if (runtime.GOOS == "freebsd" && runtime.GOARCH == "amd64") || runtime.GOOS == "js" { + if runtime.GOOS == "freebsd" || runtime.GOOS == "js" { testenv.SkipFlaky(t, 19229) } ln := newLocalListener(t) From 46db6aa1573def4ba06dbf5c38e704d85dc303b6 Mon Sep 17 00:00:00 2001 From: Rhys Hiltner Date: Tue, 7 Dec 2021 13:32:24 -0800 Subject: [PATCH 432/752] runtime: fix flake in TestCgoPprofThread If the test's main goroutine receives a SIGPROF while creating the C-owned thread for the test, that sample will appear in the resulting profile. The root end of that stack will show a set of Go functions. The leaf end will be the C functions returned by the SetCgoTraceback handler, which will confuse the test runner. Add a label to the main goroutine while it calls in to C, so all profile samples that triggered the SetCgoTraceback handler are either correct, or can easily be excluded from the test's analysis. (The labels will not apply to the resulting C-owned thread, which does not use goroutines.) Fixes #43174 Change-Id: Ica3100ca0f191dcf91b30b0084e8541c5a25689f Reviewed-on: https://go-review.googlesource.com/c/go/+/370135 Reviewed-by: Michael Pratt Trust: Michael Pratt Run-TryBot: Michael Pratt Trust: Michael Knyszek TryBot-Result: Gopher Robot --- src/runtime/crash_cgo_test.go | 2 +- src/runtime/testdata/testprogcgo/threadpprof.go | 10 +++++++++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/src/runtime/crash_cgo_test.go b/src/runtime/crash_cgo_test.go index bfb260a143..058eae1c09 100644 --- a/src/runtime/crash_cgo_test.go +++ b/src/runtime/crash_cgo_test.go @@ -314,7 +314,7 @@ func testCgoPprof(t *testing.T, buildArg, runArg, top, bottom string) { defer os.Remove(fn) for try := 0; try < 2; try++ { - cmd := testenv.CleanCmdEnv(exec.Command(testenv.GoToolPath(t), "tool", "pprof", "-traces")) + cmd := testenv.CleanCmdEnv(exec.Command(testenv.GoToolPath(t), "tool", "pprof", "-tagignore=ignore", "-traces")) // Check that pprof works both with and without explicit executable on command line. if try == 0 { cmd.Args = append(cmd.Args, exe, fn) diff --git a/src/runtime/testdata/testprogcgo/threadpprof.go b/src/runtime/testdata/testprogcgo/threadpprof.go index 4bc84d16d0..e093f67e1e 100644 --- a/src/runtime/testdata/testprogcgo/threadpprof.go +++ b/src/runtime/testdata/testprogcgo/threadpprof.go @@ -64,6 +64,7 @@ void runCPUHogThread(void) { import "C" import ( + "context" "fmt" "os" "runtime" @@ -98,7 +99,14 @@ func pprofThread() { os.Exit(2) } - C.runCPUHogThread() + // This goroutine may receive a profiling signal while creating the C-owned + // thread. If it does, the SetCgoTraceback handler will make the leaf end of + // the stack look almost (but not exactly) like the stacks the test case is + // trying to find. Attach a profiler label so the test can filter out those + // confusing samples. + pprof.Do(context.Background(), pprof.Labels("ignore", "ignore"), func(ctx context.Context) { + C.runCPUHogThread() + }) time.Sleep(1*time.Second) From f5b5939c28ecb8b8c0897584fed78589c27348f6 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Mon, 6 Dec 2021 13:36:42 -0500 Subject: [PATCH 433/752] build: for default bootstrap, use Go 1.17 if present, falling back to Go 1.4 Preparation for #44505, but safe for Go 1.18. Also fixes the default build on Macs, at least for people who have a $HOME/go1.17 or have run go install golang.org/dl/go1.17@latest go1.17 download Replay of CL 369914 after revert in CL 370138. Only change is adding 'export GOROOT_BOOTSTRAP' in make.bash. Change-Id: I8ced4e87a9dc0f05cc49095578b401ae6212ac85 Reviewed-on: https://go-review.googlesource.com/c/go/+/370274 Trust: Russ Cox Run-TryBot: Russ Cox Reviewed-by: Cuong Manh Le TryBot-Result: Gopher Robot --- src/cmd/dist/buildtool.go | 13 ++++++++++++- src/make.bash | 11 ++++++++++- src/make.bat | 2 ++ src/make.rc | 3 +++ 4 files changed, 27 insertions(+), 2 deletions(-) diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go index 75f04a975c..17538ad5a4 100644 --- a/src/cmd/dist/buildtool.go +++ b/src/cmd/dist/buildtool.go @@ -93,10 +93,21 @@ var ignoreSuffixes = []string{ "_test.go", } +var tryDirs = []string{ + "sdk/go1.17", + "go1.17", +} + func bootstrapBuildTools() { goroot_bootstrap := os.Getenv("GOROOT_BOOTSTRAP") if goroot_bootstrap == "" { - goroot_bootstrap = pathf("%s/go1.4", os.Getenv("HOME")) + home := os.Getenv("HOME") + goroot_bootstrap = pathf("%s/go1.4", home) + for _, d := range tryDirs { + if p := pathf("%s/%s", home, d); isdir(p) { + goroot_bootstrap = p + } + } } xprintf("Building Go toolchain1 using %s.\n", goroot_bootstrap) diff --git a/src/make.bash b/src/make.bash index 3310692a18..9acf079c24 100755 --- a/src/make.bash +++ b/src/make.bash @@ -153,7 +153,16 @@ if [ "$1" = "-v" ]; then fi goroot_bootstrap_set=${GOROOT_BOOTSTRAP+"true"} -export GOROOT_BOOTSTRAP=${GOROOT_BOOTSTRAP:-$HOME/go1.4} +if [ -z "$GOROOT_BOOTSTRAP" ]; then + GOROOT_BOOTSTRAP="$HOME/go1.4" + for d in sdk/go1.17 go1.17; do + if [ -d "$HOME/$d" ]; then + GOROOT_BOOTSTRAP="$HOME/$d" + fi + done +fi +export GOROOT_BOOTSTRAP + export GOROOT="$(cd .. && pwd)" IFS=$'\n'; for go_exe in $(type -ap go); do if [ ! -x "$GOROOT_BOOTSTRAP/bin/go" ]; then diff --git a/src/make.bat b/src/make.bat index 8f2825b09a..6bffee050e 100644 --- a/src/make.bat +++ b/src/make.bat @@ -83,6 +83,8 @@ for /f "tokens=*" %%g in ('where go 2^>nul') do ( ) ) ) +if "x%GOROOT_BOOTSTRAP%"=="x" if exist "%HOMEDRIVE%%HOMEPATH%\go1.17" set GOROOT_BOOTSTRAP=%HOMEDRIVE%%HOMEPATH%\go1.17 +if "x%GOROOT_BOOTSTRAP%"=="x" if exist "%HOMEDRIVE%%HOMEPATH%\sdk\go1.17" set GOROOT_BOOTSTRAP=%HOMEDRIVE%%HOMEPATH%\sdk\go1.17 if "x%GOROOT_BOOTSTRAP%"=="x" set GOROOT_BOOTSTRAP=%HOMEDRIVE%%HOMEPATH%\Go1.4 :bootstrapset diff --git a/src/make.rc b/src/make.rc index ba8c5db2d9..37087d6357 100755 --- a/src/make.rc +++ b/src/make.rc @@ -55,6 +55,9 @@ goroot_bootstrap_set = 'true' if(! ~ $#GOROOT_BOOTSTRAP 1){ goroot_bootstrap_set = 'false' GOROOT_BOOTSTRAP = $home/go1.4 + for(d in sdk/go1.17 go1.17) + if(test -d $home/$d) + GOROOT_BOOTSTRAP = $home/$d } for(p in $path){ if(! test -x $GOROOT_BOOTSTRAP/bin/go){ From c759ec228435e387a5c863b6b886b49a055fa80a Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Tue, 7 Dec 2021 16:29:21 -0500 Subject: [PATCH 434/752] doc/go1.18: clarify additions to net package API For #47694. Updates #46518. Change-Id: Ife3a8d3d6a1c50f55b5ab15730d5a6bd3ec512e1 Reviewed-on: https://go-review.googlesource.com/c/go/+/370134 Trust: Austin Clements Reviewed-by: Damien Neil --- doc/go1.18.html | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 10a05ad886..ad08083793 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -360,9 +360,15 @@ Do not send CLs removing the interior tags from such phrases. a network CIDR prefix.

      - The net package now has methods to send and receive UDP packets - using netip.Addr values instead of the relatively heavy - *net.UDPAddr values. + The net package includes new + methods that parallel existing methods, but + return netip.AddrPort instead of the + heavier-weight net.IP or + *net.UDPAddr types. + The net package also now includes functions and methods + to convert between the existing + TCPAddr/UDPAddr + types and netip.AddrPort.

      TODO

      @@ -599,12 +605,6 @@ Do not send CLs removing the interior tags from such phrases.       net.Error.Temporary has been deprecated.

      - -
      -

      - TODO: Several new net APIs. -

      -
      net/http
      From ac7e950d385b871ca28e1ac723d6ad97ebe3a4d7 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Sat, 4 Dec 2021 09:35:34 -0500 Subject: [PATCH 435/752] go/types: sort to reduce computational complexity of initOrder MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Our calculation of initOrder builds the dependency graph and then removes function nodes approximately at random. While profiling, I noticed that this latter step introduces a superlinear algorithm into our type checking pass, which can dominate type checking for large packages such as runtime. It is hard to analyze this rigorously, but to give an idea of how such a non-linearity could arise, suppose the following assumptions hold: - Every function makes D calls at random to other functions in the package, for some fixed constant D. - The number of functions is proportional to N, the size of the package. Under these simplified assumptions, the cost of removing an arbitrary function F is P*D, where P is the expected number of functions calling F. P has a Poisson distribution with mean D. Now consider the fact that when removing a function F in position i, we recursively pay the cost of copying F's predecessors and successors for each node in the remaining unremoved subgraph of functions containing F. With our assumptions, the size of this subgraph is proportional to (N-i), the number of remaining functions to remove. Therefore, the total cost of removing functions is proportional to P*D*Σᴺ(N-i) which is proportional to N². However, if we remove functions in ascending order of cost, we can partition by the number of predecessors, and the total cost of removing functions is proportional to N*D*Σ(PMF(X)) where PMF is the probability mass function of P. In other words cost is proportional to N. Assuming the above analysis is correct, it is still the case that the initial assumptions are naive. Many large packages are more accurately characterized as combinations of many smaller packages. Nevertheless, it is intuitively clear that removing expensive nodes last should be cheaper. Therefore, we sort by cost first before removing nodes in dependencyGraph. We also move deletes to the outer loop, to avoid redundant deletes. By inspection, this avoids a bug where n may not have been removed from its successors if n had no predecessors. name old time/op new time/op delta Check/runtime/funcbodies/noinfo-8 568ms ±25% 82ms ± 1% -85.53% (p=0.000 n=8+10) name old lines/s new lines/s delta Check/runtime/funcbodies/noinfo-8 93.1k ±56% 705.1k ± 1% +657.63% (p=0.000 n=10+10) Updates #49856 Change-Id: Id2e70d67401af19205e1e0b9947baa16dd6506f0 Reviewed-on: https://go-review.googlesource.com/c/go/+/369434 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/go/types/initorder.go | 62 ++++++++++++++++++++++++++------------- src/go/types/self_test.go | 1 + 2 files changed, 42 insertions(+), 21 deletions(-) diff --git a/src/go/types/initorder.go b/src/go/types/initorder.go index 77a739c7c1..27595ae233 100644 --- a/src/go/types/initorder.go +++ b/src/go/types/initorder.go @@ -7,6 +7,7 @@ package types import ( "container/heap" "fmt" + "sort" ) // initOrder computes the Info.InitOrder for package variables. @@ -184,6 +185,12 @@ type graphNode struct { ndeps int // number of outstanding dependencies before this object can be initialized } +// cost returns the cost of removing this node, which involves copying each +// predecessor to each successor (and vice-versa). +func (n *graphNode) cost() int { + return len(n.pred) * len(n.succ) +} + type nodeSet map[*graphNode]bool func (s *nodeSet) add(p *graphNode) { @@ -221,35 +228,48 @@ func dependencyGraph(objMap map[Object]*declInfo) []*graphNode { } } + var G, funcG []*graphNode // separate non-functions and functions + for _, n := range M { + if _, ok := n.obj.(*Func); ok { + funcG = append(funcG, n) + } else { + G = append(G, n) + } + } + // remove function nodes and collect remaining graph nodes in G // (Mutually recursive functions may introduce cycles among themselves // which are permitted. Yet such cycles may incorrectly inflate the dependency // count for variables which in turn may not get scheduled for initialization // in correct order.) - var G []*graphNode - for obj, n := range M { - if _, ok := obj.(*Func); ok { - // connect each predecessor p of n with each successor s - // and drop the function node (don't collect it in G) - for p := range n.pred { - // ignore self-cycles - if p != n { - // Each successor s of n becomes a successor of p, and - // each predecessor p of n becomes a predecessor of s. - for s := range n.succ { - // ignore self-cycles - if s != n { - p.succ.add(s) - s.pred.add(p) - delete(s.pred, n) // remove edge to n - } + // + // Note that because we recursively copy predecessors and successors + // throughout the function graph, the cost of removing a function at + // position X is proportional to cost * (len(funcG)-X). Therefore, we should + // remove high-cost functions last. + sort.Slice(funcG, func(i, j int) bool { + return funcG[i].cost() < funcG[j].cost() + }) + for _, n := range funcG { + // connect each predecessor p of n with each successor s + // and drop the function node (don't collect it in G) + for p := range n.pred { + // ignore self-cycles + if p != n { + // Each successor s of n becomes a successor of p, and + // each predecessor p of n becomes a predecessor of s. + for s := range n.succ { + // ignore self-cycles + if s != n { + p.succ.add(s) + s.pred.add(p) } - delete(p.succ, n) // remove edge to n } + delete(p.succ, n) // remove edge to n } - } else { - // collect non-function nodes - G = append(G, n) + } + for s := range n.succ { + delete(s.pred, n) // remove edge to n } } diff --git a/src/go/types/self_test.go b/src/go/types/self_test.go index 55436d3b62..a1af85f27b 100644 --- a/src/go/types/self_test.go +++ b/src/go/types/self_test.go @@ -36,6 +36,7 @@ func BenchmarkCheck(b *testing.B) { "net/http", "go/parser", "go/constant", + "runtime", filepath.Join("go", "internal", "gcimporter"), } { b.Run(path.Base(p), func(b *testing.B) { From 6b609110fdfab4a496c246889f1e67fd7cba61df Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Sun, 5 Dec 2021 22:09:32 -0500 Subject: [PATCH 436/752] cmd/compile/internal/types2: sort to reduce computational complexity of initOrder This is a clean port of CL 369434 to types2. Change-Id: I3f9f80757bfbefb7b0417eef9e7b7c74c4c100b9 Reviewed-on: https://go-review.googlesource.com/c/go/+/369474 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Gopher Robot Reviewed-by: Robert Griesemer --- src/cmd/compile/internal/types2/initorder.go | 62 +++++++++++++------- src/cmd/compile/internal/types2/self_test.go | 1 + 2 files changed, 42 insertions(+), 21 deletions(-) diff --git a/src/cmd/compile/internal/types2/initorder.go b/src/cmd/compile/internal/types2/initorder.go index 4081627666..cf6110baa9 100644 --- a/src/cmd/compile/internal/types2/initorder.go +++ b/src/cmd/compile/internal/types2/initorder.go @@ -7,6 +7,7 @@ package types2 import ( "container/heap" "fmt" + "sort" ) // initOrder computes the Info.InitOrder for package variables. @@ -190,6 +191,12 @@ type graphNode struct { ndeps int // number of outstanding dependencies before this object can be initialized } +// cost returns the cost of removing this node, which involves copying each +// predecessor to each successor (and vice-versa). +func (n *graphNode) cost() int { + return len(n.pred) * len(n.succ) +} + type nodeSet map[*graphNode]bool func (s *nodeSet) add(p *graphNode) { @@ -227,35 +234,48 @@ func dependencyGraph(objMap map[Object]*declInfo) []*graphNode { } } + var G, funcG []*graphNode // separate non-functions and functions + for _, n := range M { + if _, ok := n.obj.(*Func); ok { + funcG = append(funcG, n) + } else { + G = append(G, n) + } + } + // remove function nodes and collect remaining graph nodes in G // (Mutually recursive functions may introduce cycles among themselves // which are permitted. Yet such cycles may incorrectly inflate the dependency // count for variables which in turn may not get scheduled for initialization // in correct order.) - var G []*graphNode - for obj, n := range M { - if _, ok := obj.(*Func); ok { - // connect each predecessor p of n with each successor s - // and drop the function node (don't collect it in G) - for p := range n.pred { - // ignore self-cycles - if p != n { - // Each successor s of n becomes a successor of p, and - // each predecessor p of n becomes a predecessor of s. - for s := range n.succ { - // ignore self-cycles - if s != n { - p.succ.add(s) - s.pred.add(p) - delete(s.pred, n) // remove edge to n - } + // + // Note that because we recursively copy predecessors and successors + // throughout the function graph, the cost of removing a function at + // position X is proportional to cost * (len(funcG)-X). Therefore, we should + // remove high-cost functions last. + sort.Slice(funcG, func(i, j int) bool { + return funcG[i].cost() < funcG[j].cost() + }) + for _, n := range funcG { + // connect each predecessor p of n with each successor s + // and drop the function node (don't collect it in G) + for p := range n.pred { + // ignore self-cycles + if p != n { + // Each successor s of n becomes a successor of p, and + // each predecessor p of n becomes a predecessor of s. + for s := range n.succ { + // ignore self-cycles + if s != n { + p.succ.add(s) + s.pred.add(p) } - delete(p.succ, n) // remove edge to n } + delete(p.succ, n) // remove edge to n } - } else { - // collect non-function nodes - G = append(G, n) + } + for s := range n.succ { + delete(s.pred, n) // remove edge to n } } diff --git a/src/cmd/compile/internal/types2/self_test.go b/src/cmd/compile/internal/types2/self_test.go index e0d2e1b07a..9a01ccdf7a 100644 --- a/src/cmd/compile/internal/types2/self_test.go +++ b/src/cmd/compile/internal/types2/self_test.go @@ -33,6 +33,7 @@ func BenchmarkCheck(b *testing.B) { filepath.Join("src", "net", "http"), filepath.Join("src", "go", "parser"), filepath.Join("src", "go", "constant"), + filepath.Join("src", "runtime"), filepath.Join("src", "go", "internal", "gcimporter"), } { b.Run(path.Base(p), func(b *testing.B) { From 85a8e1786a669efe525fd4555edb77a60bac2ffe Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Tue, 23 Nov 2021 17:36:21 -0500 Subject: [PATCH 437/752] cmd/go: fix hang in workspaces golang.org/cl/365234 incorrectly had pruningForGoVersion always return workspace pruning instead of just returning workspace pruning at the top level, which broke the proper determination of pruning for dependency packages. Fix that code, and also fix a hang that resulted because the module loading code keeps loading dependencies until it reaches a pruned module or an unpruned module it already saw, so it could get stuck in a cycle. Change-Id: I8911f7d83aaee5870c43ef0355abbd439f15d4f7 Reviewed-on: https://go-review.googlesource.com/c/go/+/366775 Trust: Michael Matloob Run-TryBot: Michael Matloob Reviewed-by: Bryan Mills TryBot-Result: Gopher Robot --- src/cmd/go/internal/modload/init.go | 6 +- src/cmd/go/internal/modload/modfile.go | 3 - .../testdata/script/work_regression_hang.txt | 71 +++++++++++++++++++ 3 files changed, 76 insertions(+), 4 deletions(-) create mode 100644 src/cmd/go/testdata/script/work_regression_hang.txt diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go index 854c17d776..df083e7fcc 100644 --- a/src/cmd/go/internal/modload/init.go +++ b/src/cmd/go/internal/modload/init.go @@ -694,7 +694,11 @@ func LoadModFile(ctx context.Context) *Requirements { MainModules = makeMainModules([]module.Version{mainModule}, []string{""}, []*modfile.File{nil}, []*modFileIndex{nil}, "", nil) goVersion := LatestGoVersion() rawGoVersion.Store(mainModule, goVersion) - requirements = newRequirements(pruningForGoVersion(goVersion), nil, nil) + pruning := pruningForGoVersion(goVersion) + if inWorkspaceMode() { + pruning = workspace + } + requirements = newRequirements(pruning, nil, nil) return requirements } diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go index 7cc2272ea0..40e6ed787d 100644 --- a/src/cmd/go/internal/modload/modfile.go +++ b/src/cmd/go/internal/modload/modfile.go @@ -124,9 +124,6 @@ const ( ) func pruningForGoVersion(goVersion string) modPruning { - if inWorkspaceMode() { - return workspace - } if semver.Compare("v"+goVersion, ExplicitIndirectVersionV) < 0 { // The go.mod file does not duplicate relevant information about transitive // dependencies, so they cannot be pruned out. diff --git a/src/cmd/go/testdata/script/work_regression_hang.txt b/src/cmd/go/testdata/script/work_regression_hang.txt new file mode 100644 index 0000000000..a7661b68ad --- /dev/null +++ b/src/cmd/go/testdata/script/work_regression_hang.txt @@ -0,0 +1,71 @@ +# This test makes checks against a regression of a bug in the Go command +# where the module loader hung forever because all main module dependencies +# kept workspace pruning instead of adopting the pruning in their go.mod +# files, and the loader kept adding dependencies on the queue until they +# were either pruned or unpruned, never breaking a module dependency cycle. +# +# This is the module graph in the test: +# +# /-------------------------\ +# | | +# V | +# example.com/a -> example.com/b v1.0.0 -> example.com/c v1.1.0 + +go list -m -f '{{.Version}}' example.com/c + +-- go.work -- +go 1.16 + +use ( + ./a +) +-- a/go.mod -- +module example.com/a + +go 1.18 + +require example.com/b v1.0.0 + +replace example.com/b v1.0.0 => ../b +replace example.com/c v1.0.0 => ../c +-- a/foo.go -- +package main + +import "example.com/b" + +func main() { + b.B() +} +-- b/go.mod -- +module example.com/b + +go 1.18 + +require example.com/c v1.0.0 +-- b/b.go -- +package b + +func B() { +} +-- b/cmd/main.go -- +package main + +import "example.com/c" + +func main() { + c.C() +} +-- c/go.mod -- +module example.com/c + +go 1.18 + +require example.com/b v1.0.0 +-- c/c.go -- +package c + +import "example.com/b" + +func C() { + b.B() +} \ No newline at end of file From c1c303f6f8b77d3ed4e135583f3d60b159907245 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Tue, 7 Dec 2021 15:59:22 -0800 Subject: [PATCH 438/752] test: add extra typeswitch tests that cause duplicate cases Augmented some of the typeswitch*.go tests so that some instantiations have duplicate cases, in order to ensure we're testing that. Spacing changes in the tests are due to gofmt. Change-Id: I5d3678813505c520c544281d4ac8a62ce7e236ad Reviewed-on: https://go-review.googlesource.com/c/go/+/370155 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: Keith Randall --- test/run.go | 4 ++++ test/typeparam/typeswitch1.go | 6 ++++-- test/typeparam/typeswitch1.out | 2 ++ test/typeparam/typeswitch2.go | 2 ++ test/typeparam/typeswitch2.out | 2 ++ test/typeparam/typeswitch3.go | 7 ++++++- test/typeparam/typeswitch3.out | 3 +++ test/typeparam/typeswitch4.go | 11 ++++++++--- test/typeparam/typeswitch4.out | 3 +++ 9 files changed, 34 insertions(+), 6 deletions(-) diff --git a/test/run.go b/test/run.go index 2ff7117ea9..37be958959 100644 --- a/test/run.go +++ b/test/run.go @@ -2183,6 +2183,10 @@ var unifiedFailures = setOf( "fixedbugs/issue49767.go", // unified IR doesn't report channel element too large "fixedbugs/issue49814.go", // unified IR doesn't report array type too large "typeparam/issue50002.go", // pure stenciling leads to a static type assertion error + "typeparam/typeswitch1.go", // duplicate case failure due to stenciling + "typeparam/typeswitch2.go", // duplicate case failure due to stenciling + "typeparam/typeswitch3.go", // duplicate case failure due to stenciling + "typeparam/typeswitch4.go", // duplicate case failure due to stenciling ) func setOf(keys ...string) map[string]bool { diff --git a/test/typeparam/typeswitch1.go b/test/typeparam/typeswitch1.go index 27161b3db8..834302e37a 100644 --- a/test/typeparam/typeswitch1.go +++ b/test/typeparam/typeswitch1.go @@ -14,7 +14,7 @@ func f[T any](i interface{}) { println("int") case int32, int16: println("int32/int16") - case struct { a, b T }: + case struct{ a, b T }: println("struct{T,T}") default: println("other") @@ -24,6 +24,8 @@ func main() { f[float64](float64(6)) f[float64](int(7)) f[float64](int32(8)) - f[float64](struct{a, b float64}{a:1, b:2}) + f[float64](struct{ a, b float64 }{a: 1, b: 2}) f[float64](int8(9)) + f[int32](int32(7)) + f[int](int32(7)) } diff --git a/test/typeparam/typeswitch1.out b/test/typeparam/typeswitch1.out index 4bdbccfddb..dc5dfdb761 100644 --- a/test/typeparam/typeswitch1.out +++ b/test/typeparam/typeswitch1.out @@ -3,3 +3,5 @@ int int32/int16 struct{T,T} other +T +int32/int16 diff --git a/test/typeparam/typeswitch2.go b/test/typeparam/typeswitch2.go index 0e434e1383..ce4af34f04 100644 --- a/test/typeparam/typeswitch2.go +++ b/test/typeparam/typeswitch2.go @@ -28,4 +28,6 @@ func main() { f[float64](int32(8)) f[float64](struct{ a, b float64 }{a: 1, b: 2}) f[float64](int8(9)) + f[int32](int32(7)) + f[int](int32(7)) } diff --git a/test/typeparam/typeswitch2.out b/test/typeparam/typeswitch2.out index 944cc04cc6..85b54e38ae 100644 --- a/test/typeparam/typeswitch2.out +++ b/test/typeparam/typeswitch2.out @@ -3,3 +3,5 @@ int 7 int32/int16 8 struct{T,T} +1.000000e+000 +2.000000e+000 other 9 +T 7 +int32/int16 7 diff --git a/test/typeparam/typeswitch3.go b/test/typeparam/typeswitch3.go index 6ab0301140..0527a83eb0 100644 --- a/test/typeparam/typeswitch3.go +++ b/test/typeparam/typeswitch3.go @@ -6,16 +6,18 @@ package main -type I interface { foo() int } +type I interface{ foo() int } type myint int func (x myint) foo() int { return int(x) } type myfloat float64 + func (x myfloat) foo() int { return int(x) } type myint32 int32 + func (x myint32) foo() int { return int(x) } func f[T I](i I) { @@ -32,4 +34,7 @@ func main() { f[myfloat](myint(6)) f[myfloat](myfloat(7)) f[myfloat](myint32(8)) + f[myint32](myint32(8)) + f[myint32](myfloat(7)) + f[myint](myint32(9)) } diff --git a/test/typeparam/typeswitch3.out b/test/typeparam/typeswitch3.out index 2c69c72c30..ed59987e6d 100644 --- a/test/typeparam/typeswitch3.out +++ b/test/typeparam/typeswitch3.out @@ -1,3 +1,6 @@ myint 6 T 7 other 8 +T 8 +other 7 +other 9 diff --git a/test/typeparam/typeswitch4.go b/test/typeparam/typeswitch4.go index 6113026b65..08de2a1d41 100644 --- a/test/typeparam/typeswitch4.go +++ b/test/typeparam/typeswitch4.go @@ -6,16 +6,18 @@ package main -type I interface { foo() int } +type I interface{ foo() int } type myint int -func (x myint) foo() int {return int(x)} +func (x myint) foo() int { return int(x) } type myfloat float64 -func (x myfloat) foo() int {return int(x)} + +func (x myfloat) foo() int { return int(x) } type myint32 int32 + func (x myint32) foo() int { return int(x) } func f[T I](i I) { @@ -30,4 +32,7 @@ func main() { f[myfloat](myint(6)) f[myfloat](myfloat(7)) f[myfloat](myint32(8)) + f[myint32](myint32(9)) + f[myint](myint32(10)) + f[myint](myfloat(42)) } diff --git a/test/typeparam/typeswitch4.out b/test/typeparam/typeswitch4.out index b0d54077c9..d6121d077c 100644 --- a/test/typeparam/typeswitch4.out +++ b/test/typeparam/typeswitch4.out @@ -1,3 +1,6 @@ other 6 T/myint32 7 T/myint32 8 +T/myint32 9 +T/myint32 10 +other 42 From 7b7efd7a7c952f8b372c861c94acd159ee371acb Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Tue, 7 Dec 2021 13:32:36 -0800 Subject: [PATCH 439/752] doc: add in release note about compiler being roughly 15% slower Updates #49569 Change-Id: Ifba769993c50bb547cb355f56934fb572ec17a1a Reviewed-on: https://go-review.googlesource.com/c/go/+/370154 Reviewed-by: Austin Clements Trust: Dan Scales --- doc/go1.18.html | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index ad08083793..a3c2da059b 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -321,8 +321,11 @@ Do not send CLs removing the interior tags from such phrases. new go command -asan option.

      -

      - TODO: Mention build speed impact. +

      + Because of changes in the compiler related to supporting generics, the + Go 1.18 compile speed can be roughly 15% slower than the Go 1.17 compile speed. + The execution time of the compiled code is not affected. We + intend to improve the speed of the compiler in Go 1.19.

      Linker

      From 61011de1af0bc6ab286c4722632719d3da2cf746 Mon Sep 17 00:00:00 2001 From: David Chase Date: Tue, 23 Nov 2021 13:29:13 -0500 Subject: [PATCH 440/752] cmd/compile: try to preserve IsStmt marks from OpConvert Note when a statement mark was not consumed during Prog generation, and try to use it on a subsequent opcode so that the statement marker will not be lost. And a test. Fixes #49628. Change-Id: I03f7782a9809cc4a0a5870df92b3e182cf124554 Reviewed-on: https://go-review.googlesource.com/c/go/+/366694 Trust: David Chase Run-TryBot: David Chase Trust: Dan Scales Reviewed-by: Dan Scales TryBot-Result: Gopher Robot --- .../compile/internal/ssa/debug_lines_test.go | 19 +++++++++++++++++++ .../internal/ssa/testdata/convertline.go | 16 ++++++++++++++++ src/cmd/compile/internal/ssagen/ssa.go | 17 +++++++++++++++++ 3 files changed, 52 insertions(+) create mode 100644 src/cmd/compile/internal/ssa/testdata/convertline.go diff --git a/src/cmd/compile/internal/ssa/debug_lines_test.go b/src/cmd/compile/internal/ssa/debug_lines_test.go index 0df56f5d4b..c0ccdb1c93 100644 --- a/src/cmd/compile/internal/ssa/debug_lines_test.go +++ b/src/cmd/compile/internal/ssa/debug_lines_test.go @@ -82,6 +82,25 @@ func TestDebugLinesPushback(t *testing.T) { } } +func TestDebugLinesConvert(t *testing.T) { + if runtime.GOOS != "linux" && runtime.GOOS != "darwin" { // in particular, it could be windows. + t.Skip("this test depends on creating a file with a wonky name, only works for sure on Linux and Darwin") + } + + switch testGoArch() { + default: + t.Skip("skipped for many architectures") + + case "arm64", "amd64": // register ABI + fn := "G[go.shape.int_0]" + if buildcfg.Experiment.Unified { + // Unified mangles differently + fn = "G[int]" + } + testDebugLines(t, "-N -l -G=3", "convertline.go", fn, []int{9, 10, 11}, true) + } +} + func TestInlineLines(t *testing.T) { if runtime.GOARCH != "amd64" && *testGoArchFlag == "" { // As of september 2021, works for everything except mips64, but still potentially fragile diff --git a/src/cmd/compile/internal/ssa/testdata/convertline.go b/src/cmd/compile/internal/ssa/testdata/convertline.go new file mode 100644 index 0000000000..08f3ae8a35 --- /dev/null +++ b/src/cmd/compile/internal/ssa/testdata/convertline.go @@ -0,0 +1,16 @@ +package main + +import "fmt" + +func F[T any](n T) { + fmt.Printf("called\n") +} + +func G[T any](n T) { + F(n) + fmt.Printf("after\n") +} + +func main() { + G(3) +} diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go index d6407af334..265ef1aab3 100644 --- a/src/cmd/compile/internal/ssagen/ssa.go +++ b/src/cmd/compile/internal/ssagen/ssa.go @@ -6577,6 +6577,22 @@ func (s *State) DebugFriendlySetPosFrom(v *ssa.Value) { // explicit statement boundaries should appear // in the generated code. if p.IsStmt() != src.PosIsStmt { + if s.pp.Pos.IsStmt() == src.PosIsStmt && s.pp.Pos.SameFileAndLine(p) { + // If s.pp.Pos already has a statement mark, then it was set here (below) for + // the previous value. If an actual instruction had been emitted for that + // value, then the statement mark would have been reset. Since the statement + // mark of s.pp.Pos was not reset, this position (file/line) still needs a + // statement mark on an instruction. If file and line for this value are + // the same as the previous value, then the first instruction for this + // value will work to take the statement mark. Return early to avoid + // resetting the statement mark. + // + // The reset of s.pp.Pos occurs in (*Progs).Prog() -- if it emits + // an instruction, and the instruction's statement mark was set, + // and it is not one of the LosesStmtMark instructions, + // then Prog() resets the statement mark on the (*Progs).Pos. + return + } p = p.WithNotStmt() // Calls use the pos attached to v, but copy the statement mark from State } @@ -6818,6 +6834,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) { for i, b := range f.Blocks { s.bstart[b.ID] = s.pp.Next s.lineRunStart = nil + s.SetPos(s.pp.Pos.WithNotStmt()) // It needs a non-empty Pos, but cannot be a statement boundary (yet). // Attach a "default" liveness info. Normally this will be // overwritten in the Values loop below for each Value. But From 9e29dd42df18141506dcfc2513e8a653564fdbf1 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 7 Dec 2021 14:29:21 -0500 Subject: [PATCH 441/752] doc: document cmd/vet changes for generics in 1.18 Fixes #50011 Updates #47694 Change-Id: Id3d43f2f72de61b360b79c2b375ca1372d5f4692 Reviewed-on: https://go-review.googlesource.com/c/go/+/369979 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Gopher Robot Reviewed-by: Tim King --- doc/go1.18.html | 22 ++++++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index a3c2da059b..2813ddc12c 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -266,6 +266,28 @@ Do not send CLs removing the interior tags from such phrases. multiple CPUs, gofmt should now be significantly faster.

      +

      vet

      + +

      Updates for Generics

      + +

      + The vet tool is updated to support generic code. In most cases, + it reports an error in generic code whenever it would report an error in the + equivalent non-generic code after substituting for type parameters with a + type from their + type set. + + For example, vet reports a format error in + 

      func Print[T ~int|~string](t T) {
+	fmt.Printf("%d", t)
+}
      + because it would report a format error in the non-generic equivalent of + Print[string]: + 
      func PrintString(x string) {
+	fmt.Printf("%d", x)
+}
      +

      +

      Runtime

      From bb9b20a15d637667614ec4a312f216bd4c67b76a Mon Sep 17 00:00:00 2001 From: Heschi Kreinick Date: Wed, 8 Dec 2021 15:29:12 -0500 Subject: [PATCH 442/752] cmd/api: run half as many go list calls in parallel We currently run one 'go list' invocation per GOMAXPROC. Since the go command uses memory and has its own internal parallelism, that's unlikely to be an efficient use of resources. Run half as many. I suspect that's still too many but this should fix our OOMs. For #49957. Change-Id: Id06b6e0f0d96387a2a050e400f38bde6ba71aa60 Reviewed-on: https://go-review.googlesource.com/c/go/+/370376 Trust: Heschi Kreinick Run-TryBot: Heschi Kreinick Reviewed-by: Bryan Mills --- src/cmd/api/goapi.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go index 0c61b1b489..a55e51cc9b 100644 --- a/src/cmd/api/goapi.go +++ b/src/cmd/api/goapi.go @@ -460,7 +460,7 @@ type listImports struct { var listCache sync.Map // map[string]listImports, keyed by contextName // listSem is a semaphore restricting concurrent invocations of 'go list'. -var listSem = make(chan semToken, runtime.GOMAXPROCS(0)) +var listSem = make(chan semToken, ((runtime.GOMAXPROCS(0)-1)/2)+1) type semToken struct{} From f5ddd94334a63ac8107c976aa4bd6ee2171d7d64 Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Wed, 8 Dec 2021 15:30:28 -0500 Subject: [PATCH 443/752] runtime/pprof: increase systemstack calls in TestLabelSystemstack TestLabelSystemstack needs to collect samples within runtime.systemstack to complete the test. The current approach uses fmt.Fprintf, which gets into systemstack through the allocator and GC, but also does lots of other work. In my measurements, approximately 2% of samples contain runtime.systemstack. The new approach uses debug.SetGCPercent, which uses systemstack for most of its work, including contention on mheap_.lock, which extends usage even more. In my measurements, approximately 99% of samples contain runtime.systemstack. Fixes #50050 Change-Id: I59e5bb756341b716a12e13d2e3fe0adadd7fe956 Reviewed-on: https://go-review.googlesource.com/c/go/+/370375 Reviewed-by: Bryan Mills Trust: Michael Pratt Run-TryBot: Michael Pratt Reviewed-by: Michael Knyszek TryBot-Result: Gopher Robot --- src/runtime/pprof/pprof_test.go | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index 2e6165ff88..b3a8927dc7 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -1425,6 +1425,11 @@ func TestLabelRace(t *testing.T) { // TestLabelSystemstack makes sure CPU profiler samples of goroutines running // on systemstack include the correct pprof labels. See issue #48577 func TestLabelSystemstack(t *testing.T) { + // Grab and re-set the initial value before continuing to ensure + // GOGC doesn't actually change following the test. + gogc := debug.SetGCPercent(100) + debug.SetGCPercent(gogc) + matches := matchAndAvoidStacks(stackContainsLabeled, []string{"runtime.systemstack;key=value"}, avoidFunctions()) p := testCPUProfile(t, matches, func(dur time.Duration) { Do(context.Background(), Labels("key", "value"), func(context.Context) { @@ -1434,7 +1439,7 @@ func TestLabelSystemstack(t *testing.T) { wg.Add(1) go func() { defer wg.Done() - labelHog(stop) + labelHog(stop, gogc) }() } @@ -1467,13 +1472,13 @@ func TestLabelSystemstack(t *testing.T) { // labelHog is designed to burn CPU time in a way that a high number of CPU // samples end up running on systemstack. -func labelHog(stop chan struct{}) { +func labelHog(stop chan struct{}, gogc int) { for i := 0; ; i++ { select { case <-stop: return default: - fmt.Fprintf(io.Discard, "%d", i) + debug.SetGCPercent(gogc) } } } From d6c4583ad4923533ddc9f5792ed3b66f3b9f9feb Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 7 Dec 2021 19:15:51 -0500 Subject: [PATCH 444/752] doc: document the new types.Config.GoVersion field Also update some other go/types release notes to use the present tense. Updates #47694 Change-Id: I654371c065e76fd5d22679d0d3c1a81bc3d1e513 Reviewed-on: https://go-review.googlesource.com/c/go/+/370235 Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Gopher Robot Reviewed-by: Robert Griesemer --- doc/go1.18.html | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 2813ddc12c..8142a93b7b 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -528,6 +528,11 @@ Do not send CLs removing the interior tags from such phrases.

      go/types
      +

      + The new Config.GoVersion + field sets the accepted Go language version. +

      +

      Per the proposal @@ -540,7 +545,7 @@ Do not send CLs removing the interior tags from such phrases. The new type TypeParam, factory function NewTypeParam, - and associated methods were added to represent a type parameter. + and associated methods are added to represent a type parameter.

    • The new type @@ -569,7 +574,7 @@ Do not send CLs removing the interior tags from such phrases. type arguments or type parameters of an instantiated or parameterized type, and Named.SetTypeParams to set the type parameters (for instance, when importing a named type where allocation of the named - type and setting of type parameters cannot be done both at once due to possible cycles). + type and setting of type parameters cannot be done simultaneously due to possible cycles).
    • The Interface type has four new methods: @@ -586,7 +591,7 @@ Do not send CLs removing the interior tags from such phrases. Term, factory functions NewUnion and NewTerm, and associated - methods were added to represent type sets in interfaces. + methods are added to represent type sets in interfaces.
    • The new function @@ -600,12 +605,12 @@ Do not send CLs removing the interior tags from such phrases.
    • The new type ArgumentError - and associated methods were added to represent an error related to a type argument. + and associated methods are added to represent an error related to a type argument.
    • The new type Context and factory function NewContext - were added to facilitate sharing of identical type instances across type-checked packages. + are added to facilitate sharing of identical type instances across type-checked packages.
    From a76511f3a40ea69ee4f5cd86e735e1c8a84f0aa2 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Wed, 8 Dec 2021 18:05:11 -0500 Subject: [PATCH 445/752] syscall: fix ForkLock spurious close(0) on pipe failure Pipe (and therefore forkLockPipe) does not make any guarantees about the state of p after a failed Pipe(p). Avoid that assumption and the too-clever goto, so that we don't accidentally Close a real fd if the failed pipe leaves p[0] or p[1] set >= 0. Fixes #50057 Fixes CVE-2021-44717 Change-Id: Iff8e19a6efbba0c73cc8b13ecfae381c87600bb4 Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1291270 Reviewed-by: Ian Lance Taylor Reviewed-on: https://go-review.googlesource.com/c/go/+/370576 Run-TryBot: Filippo Valsorda Trust: Russ Cox Reviewed-by: Alex Rakoczy --- src/syscall/exec_unix.go | 20 ++++++-------------- 1 file changed, 6 insertions(+), 14 deletions(-) diff --git a/src/syscall/exec_unix.go b/src/syscall/exec_unix.go index 64eb5ed9f0..0e41959ffe 100644 --- a/src/syscall/exec_unix.go +++ b/src/syscall/exec_unix.go @@ -152,9 +152,6 @@ func forkExec(argv0 string, argv []string, attr *ProcAttr) (pid int, err error) sys = &zeroSysProcAttr } - p[0] = -1 - p[1] = -1 - // Convert args to C form. argv0p, err := BytePtrFromString(argv0) if err != nil { @@ -204,14 +201,17 @@ func forkExec(argv0 string, argv []string, attr *ProcAttr) (pid int, err error) // Allocate child status pipe close on exec. if err = forkExecPipe(p[:]); err != nil { - goto error + ForkLock.Unlock() + return 0, err } // Kick off child. pid, err1 = forkAndExecInChild(argv0p, argvp, envvp, chroot, dir, attr, sys, p[1]) if err1 != 0 { - err = Errno(err1) - goto error + Close(p[0]) + Close(p[1]) + ForkLock.Unlock() + return 0, Errno(err1) } ForkLock.Unlock() @@ -243,14 +243,6 @@ func forkExec(argv0 string, argv []string, attr *ProcAttr) (pid int, err error) // Read got EOF, so pipe closed on exec, so exec succeeded. return pid, nil - -error: - if p[0] >= 0 { - Close(p[0]) - Close(p[1]) - } - ForkLock.Unlock() - return 0, err } // Combination of fork and exec, careful to be thread safe. From 474ebb917cb802bf1d08434a265515d50c174082 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Wed, 8 Dec 2021 18:06:41 -0500 Subject: [PATCH 446/752] syscall: avoid writing to p when Pipe(p) fails Generally speaking Go functions make no guarantees about what has happened to result parameters on error, and Pipe is no exception: callers should avoid looking at p if Pipe returns an error. However, we had a bug in which ForkExec was using the content of p after a failed Pipe, and others may too. As a robustness fix, make Pipe avoid writing to p on failure. Updates #50057 Change-Id: Ie8955025dbd20702fabadc9bbe1d1a5ac0f36305 Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1291271 Reviewed-by: Ian Lance Taylor Reviewed-on: https://go-review.googlesource.com/c/go/+/370577 Run-TryBot: Filippo Valsorda Trust: Russ Cox TryBot-Result: Gopher Robot Reviewed-by: Alex Rakoczy --- src/syscall/syscall_aix.go | 6 ++++-- src/syscall/syscall_darwin.go | 6 ++++-- src/syscall/syscall_dragonfly.go | 12 +++++++++--- src/syscall/syscall_freebsd.go | 6 ++++-- src/syscall/syscall_linux.go | 6 ++++-- src/syscall/syscall_netbsd.go | 6 ++++-- src/syscall/syscall_openbsd.go | 6 ++++-- src/syscall/syscall_plan9.go | 6 ++++-- src/syscall/syscall_solaris.go | 4 +++- 9 files changed, 40 insertions(+), 18 deletions(-) diff --git a/src/syscall/syscall_aix.go b/src/syscall/syscall_aix.go index 0f5101999f..739c55f179 100644 --- a/src/syscall/syscall_aix.go +++ b/src/syscall/syscall_aix.go @@ -66,8 +66,10 @@ func Pipe(p []int) (err error) { } var pp [2]_C_int err = pipe(&pp) - p[0] = int(pp[0]) - p[1] = int(pp[1]) + if err == nil { + p[0] = int(pp[0]) + p[1] = int(pp[1]) + } return } diff --git a/src/syscall/syscall_darwin.go b/src/syscall/syscall_darwin.go index 5bb34e300c..902d6e77e1 100644 --- a/src/syscall/syscall_darwin.go +++ b/src/syscall/syscall_darwin.go @@ -80,8 +80,10 @@ func Pipe(p []int) (err error) { } var q [2]int32 err = pipe(&q) - p[0] = int(q[0]) - p[1] = int(q[1]) + if err == nil { + p[0] = int(q[0]) + p[1] = int(q[1]) + } return } diff --git a/src/syscall/syscall_dragonfly.go b/src/syscall/syscall_dragonfly.go index cc92c4a93e..f3c0f54521 100644 --- a/src/syscall/syscall_dragonfly.go +++ b/src/syscall/syscall_dragonfly.go @@ -98,8 +98,11 @@ func Pipe(p []int) (err error) { if len(p) != 2 { return EINVAL } - p[0], p[1], err = pipe() - return + r, w, err := pipe() + if err == nil { + p[0], p[1] = r, w + } + return err } //sysnb pipe2(p *[2]_C_int, flags int) (r int, w int, err error) @@ -111,7 +114,10 @@ func Pipe2(p []int, flags int) (err error) { var pp [2]_C_int // pipe2 on dragonfly takes an fds array as an argument, but still // returns the file descriptors. - p[0], p[1], err = pipe2(&pp, flags) + r, w, err := pipe2(&pp, flags) + if err == nil { + p[0], p[1] = r, w + } return err } diff --git a/src/syscall/syscall_freebsd.go b/src/syscall/syscall_freebsd.go index 6f44b25cb9..ecb9ec825a 100644 --- a/src/syscall/syscall_freebsd.go +++ b/src/syscall/syscall_freebsd.go @@ -105,8 +105,10 @@ func Pipe2(p []int, flags int) error { } var pp [2]_C_int err := pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) + if err == nil { + p[0] = int(pp[0]) + p[1] = int(pp[1]) + } return err } diff --git a/src/syscall/syscall_linux.go b/src/syscall/syscall_linux.go index c002299641..abcf1d5dfe 100644 --- a/src/syscall/syscall_linux.go +++ b/src/syscall/syscall_linux.go @@ -173,8 +173,10 @@ func Pipe2(p []int, flags int) error { } var pp [2]_C_int err := pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) + if err == nil { + p[0] = int(pp[0]) + p[1] = int(pp[1]) + } return err } diff --git a/src/syscall/syscall_netbsd.go b/src/syscall/syscall_netbsd.go index cebef10be8..0d562cc78e 100644 --- a/src/syscall/syscall_netbsd.go +++ b/src/syscall/syscall_netbsd.go @@ -114,8 +114,10 @@ func Pipe2(p []int, flags int) error { } var pp [2]_C_int err := pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) + if err == nil { + p[0] = int(pp[0]) + p[1] = int(pp[1]) + } return err } diff --git a/src/syscall/syscall_openbsd.go b/src/syscall/syscall_openbsd.go index 195cf8617c..fa939ec5c8 100644 --- a/src/syscall/syscall_openbsd.go +++ b/src/syscall/syscall_openbsd.go @@ -72,8 +72,10 @@ func Pipe2(p []int, flags int) error { } var pp [2]_C_int err := pipe2(&pp, flags) - p[0] = int(pp[0]) - p[1] = int(pp[1]) + if err == nil { + p[0] = int(pp[0]) + p[1] = int(pp[1]) + } return err } diff --git a/src/syscall/syscall_plan9.go b/src/syscall/syscall_plan9.go index d16cad45d8..6a8ab97dc6 100644 --- a/src/syscall/syscall_plan9.go +++ b/src/syscall/syscall_plan9.go @@ -198,8 +198,10 @@ func Pipe(p []int) (err error) { } var pp [2]int32 err = pipe(&pp) - p[0] = int(pp[0]) - p[1] = int(pp[1]) + if err == nil { + p[0] = int(pp[0]) + p[1] = int(pp[1]) + } return } diff --git a/src/syscall/syscall_solaris.go b/src/syscall/syscall_solaris.go index 5f12f229c4..f44a9e25ac 100644 --- a/src/syscall/syscall_solaris.go +++ b/src/syscall/syscall_solaris.go @@ -57,7 +57,9 @@ func Pipe(p []int) (err error) { if e1 != 0 { err = Errno(e1) } - p[0], p[1] = int(r0), int(w0) + if err == nil { + p[0], p[1] = int(r0), int(w0) + } return } From 61ba0bcf8eebd1515d1af7a0e918bf912db6eb46 Mon Sep 17 00:00:00 2001 From: Julie Qiu Date: Mon, 6 Dec 2021 12:31:27 -0500 Subject: [PATCH 447/752] cmd/go: use -count=1 in test_fuzz_chatty.txt Fuzz tests in test_fuzz_chatty.txt now use -count=1 where applicable. Fixes #48984 Change-Id: If1673924af990fe12d5dfba95082ccb573806fde Reviewed-on: https://go-review.googlesource.com/c/go/+/369674 Trust: Julie Qiu Trust: Katie Hockman Reviewed-by: Katie Hockman --- src/cmd/go/testdata/script/test_fuzz_chatty.txt | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/cmd/go/testdata/script/test_fuzz_chatty.txt b/src/cmd/go/testdata/script/test_fuzz_chatty.txt index 1abcbbd389..d07fe50f95 100644 --- a/src/cmd/go/testdata/script/test_fuzz_chatty.txt +++ b/src/cmd/go/testdata/script/test_fuzz_chatty.txt @@ -37,11 +37,9 @@ go test -v chatty_with_test_fuzz_test.go -fuzz=Fuzz -fuzztime=1x stdout ok stdout PASS ! stdout FAIL -# TODO: It's currently the case that it's logged twice. Fix that, and change -# this check to verify it. -stdout 'all good here' +stdout -count=1 'all good here' # Verify that the unit test is only run once. -! stdout '(?s)logged foo.*logged foo' +stdout -count=1 'logged foo' -- chatty_error_fuzz_test.go -- package chatty_error_fuzz From 307d7c67477ee7ccb8544ac802e965b5d18a069e Mon Sep 17 00:00:00 2001 From: Filippo Valsorda Date: Thu, 9 Dec 2021 09:09:52 -0500 Subject: [PATCH 448/752] net/http: update bundled golang.org/x/net/http2 Pull in security fix 2d13015 http2: cap the size of the server's canonical header cache and 0a0e4e1 http2: Fix handling of expect continue 04296fa http2: prioritize RST_STREAM frames in random write scheduler Fixes #50058 Fixes CVE-2021-44716 Change-Id: Ia40a2e52fa240e54a83b5ec7d8116cb6639ecbb9 Reviewed-on: https://go-review.googlesource.com/c/go/+/370579 Trust: Filippo Valsorda Run-TryBot: Filippo Valsorda TryBot-Result: Gopher Robot Reviewed-by: Damien Neil --- src/go.mod | 2 +- src/go.sum | 4 +-- src/net/http/h2_bundle.go | 32 ++++++++++++------- .../x/net/dns/dnsmessage/message.go | 22 ++++++------- src/vendor/modules.txt | 2 +- 5 files changed, 36 insertions(+), 26 deletions(-) diff --git a/src/go.mod b/src/go.mod index 24d034b810..07d0acf2bd 100644 --- a/src/go.mod +++ b/src/go.mod @@ -4,7 +4,7 @@ go 1.18 require ( golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa - golang.org/x/net v0.0.0-20211123203042-d83791d6bcd9 + golang.org/x/net v0.0.0-20211209124913-491a49abca63 ) require ( diff --git a/src/go.sum b/src/go.sum index d063e65530..cec5bc4d0e 100644 --- a/src/go.sum +++ b/src/go.sum @@ -1,7 +1,7 @@ golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa h1:idItI2DDfCokpg0N51B2VtiLdJ4vAuXC9fnCb2gACo4= golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/net v0.0.0-20211123203042-d83791d6bcd9 h1:0qxwC5n+ttVOINCBeRHO0nq9X7uy8SDsPoi5OaCdIEI= -golang.org/x/net v0.0.0-20211123203042-d83791d6bcd9/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= +golang.org/x/net v0.0.0-20211209124913-491a49abca63 h1:iocB37TsdFuN6IBRZ+ry36wrkoV51/tl5vOWqkcPGvY= +golang.org/x/net v0.0.0-20211209124913-491a49abca63/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/sys v0.0.0-20211205182925-97ca703d548d h1:FjkYO/PPp4Wi0EAUOVLxePm7qVW4r4ctbWpURyuOD0E= golang.org/x/sys v0.0.0-20211205182925-97ca703d548d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/text v0.3.8-0.20211105212822-18b340fc7af2 h1:GLw7MR8AfAG2GmGcmVgObFOHXYypgGjnGno25RDwn3Y= diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go index 8d19c42b5a..bb82f24585 100644 --- a/src/net/http/h2_bundle.go +++ b/src/net/http/h2_bundle.go @@ -4436,7 +4436,15 @@ func (sc *http2serverConn) canonicalHeader(v string) string { sc.canonHeader = make(map[string]string) } cv = CanonicalHeaderKey(v) - sc.canonHeader[v] = cv + // maxCachedCanonicalHeaders is an arbitrarily-chosen limit on the number of + // entries in the canonHeader cache. This should be larger than the number + // of unique, uncommon header keys likely to be sent by the peer, while not + // so high as to permit unreaasonable memory usage if the peer sends an unbounded + // number of unique header keys. + const maxCachedCanonicalHeaders = 32 + if len(sc.canonHeader) < maxCachedCanonicalHeaders { + sc.canonHeader[v] = cv + } return cv } @@ -7958,12 +7966,12 @@ func (cs *http2clientStream) writeRequest(req *Request) (err error) { } continueTimeout := cc.t.expectContinueTimeout() - if continueTimeout != 0 && - !httpguts.HeaderValuesContainsToken( - req.Header["Expect"], - "100-continue") { - continueTimeout = 0 - cs.on100 = make(chan struct{}, 1) + if continueTimeout != 0 { + if !httpguts.HeaderValuesContainsToken(req.Header["Expect"], "100-continue") { + continueTimeout = 0 + } else { + cs.on100 = make(chan struct{}, 1) + } } // Past this point (where we send request headers), it is possible for @@ -10117,7 +10125,8 @@ type http2WriteScheduler interface { // Pop dequeues the next frame to write. Returns false if no frames can // be written. Frames with a given wr.StreamID() are Pop'd in the same - // order they are Push'd. No frames should be discarded except by CloseStream. + // order they are Push'd, except RST_STREAM frames. No frames should be + // discarded except by CloseStream. Pop() (wr http2FrameWriteRequest, ok bool) } @@ -10137,6 +10146,7 @@ type http2FrameWriteRequest struct { // stream is the stream on which this frame will be written. // nil for non-stream frames like PING and SETTINGS. + // nil for RST_STREAM streams, which use the StreamError.StreamID field instead. stream *http2stream // done, if non-nil, must be a buffered channel with space for @@ -10816,11 +10826,11 @@ func (ws *http2randomWriteScheduler) AdjustStream(streamID uint32, priority http } func (ws *http2randomWriteScheduler) Push(wr http2FrameWriteRequest) { - id := wr.StreamID() - if id == 0 { + if wr.isControl() { ws.zero.push(wr) return } + id := wr.StreamID() q, ok := ws.sq[id] if !ok { q = ws.queuePool.get() @@ -10830,7 +10840,7 @@ func (ws *http2randomWriteScheduler) Push(wr http2FrameWriteRequest) { } func (ws *http2randomWriteScheduler) Pop() (http2FrameWriteRequest, bool) { - // Control frames first. + // Control and RST_STREAM frames first. if !ws.zero.empty() { return ws.zero.shift(), true } diff --git a/src/vendor/golang.org/x/net/dns/dnsmessage/message.go b/src/vendor/golang.org/x/net/dns/dnsmessage/message.go index 1736fc5d12..8c24430c5c 100644 --- a/src/vendor/golang.org/x/net/dns/dnsmessage/message.go +++ b/src/vendor/golang.org/x/net/dns/dnsmessage/message.go @@ -125,14 +125,14 @@ func (o OpCode) GoString() string { // An RCode is a DNS response status code. type RCode uint16 +// Header.RCode values. const ( - // Message.Rcode - RCodeSuccess RCode = 0 - RCodeFormatError RCode = 1 - RCodeServerFailure RCode = 2 - RCodeNameError RCode = 3 - RCodeNotImplemented RCode = 4 - RCodeRefused RCode = 5 + RCodeSuccess RCode = 0 // NoError + RCodeFormatError RCode = 1 // FormErr + RCodeServerFailure RCode = 2 // ServFail + RCodeNameError RCode = 3 // NXDomain + RCodeNotImplemented RCode = 4 // NotImp + RCodeRefused RCode = 5 // Refused ) var rCodeNames = map[RCode]string{ @@ -1207,8 +1207,8 @@ type Builder struct { // // The DNS message is appended to the provided initial buffer buf (which may be // nil) as it is built. The final message is returned by the (*Builder).Finish -// method, which may return the same underlying array if there was sufficient -// capacity in the slice. +// method, which includes buf[:len(buf)] and may return the same underlying +// array if there was sufficient capacity in the slice. func NewBuilder(buf []byte, h Header) Builder { if buf == nil { buf = make([]byte, 0, packStartingCap) @@ -1713,7 +1713,7 @@ const ( // SetEDNS0 configures h for EDNS(0). // -// The provided extRCode must be an extedned RCode. +// The provided extRCode must be an extended RCode. func (h *ResourceHeader) SetEDNS0(udpPayloadLen int, extRCode RCode, dnssecOK bool) error { h.Name = Name{Data: [nameLen]byte{'.'}, Length: 1} // RFC 6891 section 6.1.2 h.Type = TypeOPT @@ -1880,7 +1880,7 @@ const nameLen = 255 // A Name is a non-encoded domain name. It is used instead of strings to avoid // allocations. type Name struct { - Data [nameLen]byte + Data [nameLen]byte // 255 bytes Length uint8 } diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt index bef622891e..4130027c7f 100644 --- a/src/vendor/modules.txt +++ b/src/vendor/modules.txt @@ -9,7 +9,7 @@ golang.org/x/crypto/curve25519/internal/field golang.org/x/crypto/hkdf golang.org/x/crypto/internal/poly1305 golang.org/x/crypto/internal/subtle -# golang.org/x/net v0.0.0-20211123203042-d83791d6bcd9 +# golang.org/x/net v0.0.0-20211209124913-491a49abca63 ## explicit; go 1.17 golang.org/x/net/dns/dnsmessage golang.org/x/net/http/httpguts From 78b4518e31b39aac4fbad1679db95b3f526229a7 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 8 Dec 2021 16:47:56 -0500 Subject: [PATCH 449/752] crypto/x509: skip known TestSystemVerify flakes on windows-*-2008 builders The "-2008" builders are the only ones on which the failure has been observed, so I suspect that it is due to a platform bug fixed in a subsequent release. Since no one has added a workaround since #19564 was filed over four years ago, I'm assuming that no workaround is planned for this issue. Let's add a skip for the known failure mode and call it at that. Fixes #19564 Change-Id: Iefc22d1cc78bfdc79c845eb60cac22e26caf388c Reviewed-on: https://go-review.googlesource.com/c/go/+/370377 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Roland Shoemaker Reviewed-by: Filippo Valsorda --- src/crypto/x509/verify_test.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/crypto/x509/verify_test.go b/src/crypto/x509/verify_test.go index 05d521c09d..f4ea08bbf5 100644 --- a/src/crypto/x509/verify_test.go +++ b/src/crypto/x509/verify_test.go @@ -13,6 +13,7 @@ import ( "encoding/pem" "errors" "fmt" + "internal/testenv" "math/big" "runtime" "strings" @@ -469,6 +470,9 @@ func testVerify(t *testing.T, test verifyTest, useSystemRoots bool) { chains, err := leaf.Verify(opts) if test.errorCallback == nil && err != nil { + if runtime.GOOS == "windows" && strings.HasSuffix(testenv.Builder(), "-2008") && err.Error() == "x509: certificate signed by unknown authority" { + testenv.SkipFlaky(t, 19564) + } t.Fatalf("unexpected error: %v", err) } if test.errorCallback != nil { From ece493eb831a7797d03d60b44b817caf1c63a0ab Mon Sep 17 00:00:00 2001 From: Jason7602 Date: Tue, 9 Nov 2021 23:46:41 +0800 Subject: [PATCH 450/752] cmd/compile: fix type error reported on the wrong line The 'Does not match' type error shoud be reported where the function is called, not where the function is declared. And fix the todo by gri of issue45985 Fixes #45985 Fixes #49800 Change-Id: I15aac44dd44f2a57c485a1c273fcd79db912c389 Reviewed-on: https://go-review.googlesource.com/c/go/+/362634 Reviewed-by: Robert Griesemer Reviewed-by: Robert Findley Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/infer.go | 10 +++++----- .../internal/types2/testdata/fixedbugs/issue45985.go2 | 5 ++--- src/go/types/infer.go | 10 +++++----- src/go/types/testdata/fixedbugs/issue45985.go2 | 5 ++--- 4 files changed, 14 insertions(+), 16 deletions(-) diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go index 4f85a5894c..b203985b8d 100644 --- a/src/cmd/compile/internal/types2/infer.go +++ b/src/cmd/compile/internal/types2/infer.go @@ -60,7 +60,7 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, // If we have type arguments, see how far we get with constraint type inference. if len(targs) > 0 && useConstraintTypeInference { var index int - targs, index = check.inferB(tparams, targs) + targs, index = check.inferB(pos, tparams, targs) if targs == nil || index < 0 { return targs } @@ -171,7 +171,7 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, // Note that even if we don't have any type arguments, constraint type inference // may produce results for constraints that explicitly specify a type. if useConstraintTypeInference { - targs, index = check.inferB(tparams, targs) + targs, index = check.inferB(pos, tparams, targs) if targs == nil || index < 0 { return targs } @@ -209,7 +209,7 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, // Again, follow up with constraint type inference. if useConstraintTypeInference { - targs, index = check.inferB(tparams, targs) + targs, index = check.inferB(pos, tparams, targs) if targs == nil || index < 0 { return targs } @@ -360,7 +360,7 @@ func (w *tpWalker) isParameterizedTypeList(list []Type) bool { // first type argument in that list that couldn't be inferred (and thus is nil). If all // type arguments were inferred successfully, index is < 0. The number of type arguments // provided may be less than the number of type parameters, but there must be at least one. -func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type, index int) { +func (check *Checker) inferB(pos syntax.Pos, tparams []*TypeParam, targs []Type) (types []Type, index int) { assert(len(tparams) >= len(targs) && len(targs) > 0) // Setup bidirectional unification between constraints @@ -388,7 +388,7 @@ func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type, if !u.unify(tpar, sbound) { // TODO(gri) improve error message by providing the type arguments // which we know already - check.errorf(tpar.obj, "%s does not match %s", tpar, sbound) + check.errorf(pos, "%s does not match %s", tpar, sbound) return nil, 0 } } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45985.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45985.go2 index 9963d2ee00..cea8c14983 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45985.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue45985.go2 @@ -4,11 +4,10 @@ package issue45985 -// TODO(gri): this error should be on app[int] below. -func app[S /* ERROR "S does not match" */ interface{ ~[]T }, T any](s S, e T) S { +func app[S interface{ ~[]T }, T any](s S, e T) S { return append(s, e) } func _() { - _ = app[int] + _ = app[/* ERROR "S does not match" */int] } diff --git a/src/go/types/infer.go b/src/go/types/infer.go index 909042219c..a5088f2705 100644 --- a/src/go/types/infer.go +++ b/src/go/types/infer.go @@ -59,7 +59,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, // If we have type arguments, see how far we get with constraint type inference. if len(targs) > 0 { var index int - targs, index = check.inferB(tparams, targs) + targs, index = check.inferB(posn, tparams, targs) if targs == nil || index < 0 { return targs } @@ -174,7 +174,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, // See how far we get with constraint type inference. // Note that even if we don't have any type arguments, constraint type inference // may produce results for constraints that explicitly specify a type. - targs, index = check.inferB(tparams, targs) + targs, index = check.inferB(posn, tparams, targs) if targs == nil || index < 0 { return targs } @@ -210,7 +210,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, } // Again, follow up with constraint type inference. - targs, index = check.inferB(tparams, targs) + targs, index = check.inferB(posn, tparams, targs) if targs == nil || index < 0 { return targs } @@ -359,7 +359,7 @@ func (w *tpWalker) isParameterizedTypeList(list []Type) bool { // first type argument in that list that couldn't be inferred (and thus is nil). If all // type arguments were inferred successfully, index is < 0. The number of type arguments // provided may be less than the number of type parameters, but there must be at least one. -func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type, index int) { +func (check *Checker) inferB(posn positioner, tparams []*TypeParam, targs []Type) (types []Type, index int) { assert(len(tparams) >= len(targs) && len(targs) > 0) // Setup bidirectional unification between constraints @@ -387,7 +387,7 @@ func (check *Checker) inferB(tparams []*TypeParam, targs []Type) (types []Type, if !u.unify(tpar, sbound) { // TODO(gri) improve error message by providing the type arguments // which we know already - check.errorf(tpar.obj, _InvalidTypeArg, "%s does not match %s", tpar, sbound) + check.errorf(posn, _InvalidTypeArg, "%s does not match %s", tpar, sbound) return nil, 0 } } diff --git a/src/go/types/testdata/fixedbugs/issue45985.go2 b/src/go/types/testdata/fixedbugs/issue45985.go2 index 637e2cad5e..9a0f5e3697 100644 --- a/src/go/types/testdata/fixedbugs/issue45985.go2 +++ b/src/go/types/testdata/fixedbugs/issue45985.go2 @@ -4,11 +4,10 @@ package issue45985 -// TODO(rFindley): this error should be on app[int] below. -func app[S /* ERROR "S does not match" */ interface{ ~[]T }, T any](s S, e T) S { +func app[S interface{ ~[]T }, T any](s S, e T) S { return append(s, e) } func _() { - _ = app[int] + _ = app/* ERROR "S does not match" */[int] } From 8ff254e30ba9d9c13747fe42213c3f54b47c58e7 Mon Sep 17 00:00:00 2001 From: Matthew Dempsky Date: Wed, 8 Dec 2021 11:12:50 -0800 Subject: [PATCH 451/752] cmd/compile: preserve 'any' type alias in unified IR When exporting the "any" empty interface type for unified IR, write it out as a reference to the "any" alias, rather than to the underlying empty interface. This matches how "byte" and "rune" are handled. Verified to fix the issue demonstrated in CL 369975. Change-Id: Ic2844b0acc3b17c20b3a40aaf262f62ec653eb5a Reviewed-on: https://go-review.googlesource.com/c/go/+/370374 Trust: Matthew Dempsky Run-TryBot: Matthew Dempsky TryBot-Result: Gopher Robot Reviewed-by: Russ Cox --- src/cmd/compile/internal/noder/writer.go | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/cmd/compile/internal/noder/writer.go b/src/cmd/compile/internal/noder/writer.go index dde42c85d6..2bb0b4d5d7 100644 --- a/src/cmd/compile/internal/noder/writer.go +++ b/src/cmd/compile/internal/noder/writer.go @@ -229,6 +229,8 @@ func (pw *pkgWriter) pkgIdx(pkg *types2.Package) int { // @@@ Types +var anyTypeName = types2.Universe.Lookup("any").(*types2.TypeName) + func (w *writer) typ(typ types2.Type) { w.typInfo(w.p.typIdx(typ, w.dict)) } @@ -350,6 +352,12 @@ func (pw *pkgWriter) typIdx(typ types2.Type, dict *writerDict) typeInfo { w.structType(typ) case *types2.Interface: + if typ == anyTypeName.Type() { + w.code(typeNamed) + w.obj(anyTypeName, nil) + break + } + w.code(typeInterface) w.interfaceType(typ) From 13d15d147dd09b9209f5bc3778905684379129d8 Mon Sep 17 00:00:00 2001 From: Hossein Zolfi Date: Fri, 10 Dec 2021 12:39:57 +0330 Subject: [PATCH 452/752] go/types: remove TODO that is no longer relevant MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: Ie897b7b9c0a61c837245642c608129108e28423e Reviewed-on: https://go-review.googlesource.com/c/go/+/370582 Reviewed-by: Robert Findley Trust: Robert Findley Run-TryBot: Robert Findley Trust: Nooras Saba‎ TryBot-Result: Gopher Robot --- src/go/types/testdata/check/issues.go2 | 1 - 1 file changed, 1 deletion(-) diff --git a/src/go/types/testdata/check/issues.go2 b/src/go/types/testdata/check/issues.go2 index ac8ef789e5..371856eea3 100644 --- a/src/go/types/testdata/check/issues.go2 +++ b/src/go/types/testdata/check/issues.go2 @@ -47,7 +47,6 @@ func (T) m1() func (*T) m2() func _() { - // TODO(rFindley) this error should be positioned on the 'T'. f2[T /* ERROR wrong method signature */ ]() f2[*T]() } From c473ca087733236a6524900d037d92f32d5f6b70 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 3 Dec 2021 14:02:58 -0500 Subject: [PATCH 453/752] net: ignore EADDRINUSE errors when dialing to IPv4 from IPv6 on FreeBSD The failure mode in #34264 appears to match https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=210726. That bug was supposed to have been fixed in FreeBSD 12, but we're still observing failures specifically for the 6-to-4 case on FreeBSD 12.2. It is not clear to me whether FreeBSD 13.0 is also affected. For #34264 Change-Id: Iba7c7fc57676ae628b13c0b8fe43ddf2251c3637 Reviewed-on: https://go-review.googlesource.com/c/go/+/369157 Trust: Bryan Mills Run-TryBot: Bryan Mills Trust: Dmitri Shuralyov TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/net/dial_test.go | 17 +++++++++++++++-- src/net/dial_unix_test.go | 7 +++++++ 2 files changed, 22 insertions(+), 2 deletions(-) diff --git a/src/net/dial_test.go b/src/net/dial_test.go index 8967892197..36843870aa 100644 --- a/src/net/dial_test.go +++ b/src/net/dial_test.go @@ -537,6 +537,9 @@ func TestDialerPartialDeadline(t *testing.T) { } } +// isEADDRINUSE reports whether err is syscall.EADDRINUSE. +var isEADDRINUSE = func(err error) bool { return false } + func TestDialerLocalAddr(t *testing.T) { if !supportsIPv4() || !supportsIPv6() { t.Skip("both IPv4 and IPv6 are required") @@ -592,7 +595,9 @@ func TestDialerLocalAddr(t *testing.T) { {"tcp", "::1", &UnixAddr{}, &AddrError{Err: "some error"}}, } + issue34264Index := -1 if supportsIPv4map() { + issue34264Index = len(tests) tests = append(tests, test{ "tcp", "127.0.0.1", &TCPAddr{IP: ParseIP("::")}, nil, }) @@ -627,7 +632,7 @@ func TestDialerLocalAddr(t *testing.T) { } } - for _, tt := range tests { + for i, tt := range tests { d := &Dialer{LocalAddr: tt.laddr} var addr string ip := ParseIP(tt.raddr) @@ -639,7 +644,15 @@ func TestDialerLocalAddr(t *testing.T) { } c, err := d.Dial(tt.network, addr) if err == nil && tt.error != nil || err != nil && tt.error == nil { - t.Errorf("%s %v->%s: got %v; want %v", tt.network, tt.laddr, tt.raddr, err, tt.error) + if i == issue34264Index && runtime.GOOS == "freebsd" && isEADDRINUSE(err) { + // https://golang.org/issue/34264: FreeBSD through at least version 12.2 + // has been observed to fail with EADDRINUSE when dialing from an IPv6 + // local address to an IPv4 remote address. + t.Logf("%s %v->%s: got %v; want %v", tt.network, tt.laddr, tt.raddr, err, tt.error) + t.Logf("(spurious EADDRINUSE ignored on freebsd: see https://golang.org/issue/34264)") + } else { + t.Errorf("%s %v->%s: got %v; want %v", tt.network, tt.laddr, tt.raddr, err, tt.error) + } } if err != nil { if perr := parseDialError(err); perr != nil { diff --git a/src/net/dial_unix_test.go b/src/net/dial_unix_test.go index 1113aaca90..64dca70eb8 100644 --- a/src/net/dial_unix_test.go +++ b/src/net/dial_unix_test.go @@ -8,11 +8,18 @@ package net import ( "context" + "errors" "syscall" "testing" "time" ) +func init() { + isEADDRINUSE = func(err error) bool { + return errors.Is(err, syscall.EADDRINUSE) + } +} + // Issue 16523 func TestDialContextCancelRace(t *testing.T) { oldConnectFunc := connectFunc From 766f89b5c625f8c57492cf5645576d9e6f450cc2 Mon Sep 17 00:00:00 2001 From: Tim King Date: Thu, 9 Dec 2021 11:06:25 -0800 Subject: [PATCH 454/752] doc: document cmd/vet changes for 1.18 release cmd/vet has several precision improvements for the checkers copylock, printf, sortslice, testinggoroutine, and tests. Adds a high level mention in the release notes and an example of string constant concatenation. Updates #47694 Change-Id: I7a342a57ca3fd9e2f3e8ec99f7b647269798317f Reviewed-on: https://go-review.googlesource.com/c/go/+/370734 Reviewed-by: Russ Cox Reviewed-by: Robert Findley Trust: Tim King Run-TryBot: Tim King TryBot-Result: Gopher Robot --- doc/go1.18.html | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 8142a93b7b..67af3e6a90 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -288,6 +288,21 @@ Do not send CLs removing the interior tags from such phrases. }

    +

    Precision improvements for existing checkers

    + +

    + The cmd/vet checkers copylock, printf, + sortslice, testinggoroutine, and tests + have all had moderate precision improvements to handle additional code patterns. + This may lead to newly reported errors in existing packages. For example, the + printf checker now tracks formatting strings created by + concatenating string constants. So vet will report an error in: +

    +  // fmt.Printf formatting directive %d is being passed to Println.
+  fmt.Println("%d"+` ≡ x (mod 2)`+"\n", x%2)
+
    +

    +

    Runtime

    From 1c1998ea08d41ef09ef16c22eb8e53ea0eb569c5 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Sat, 11 Dec 2021 16:17:46 -0800 Subject: [PATCH 455/752] net/netip: fix formatting of IPv4-in-6 address with zone Weird, but don't drop the zone when stringifying. Fixes #50111 Change-Id: I5fbccdfedcdc77a77ee6bafc8d82b8ec8ec7220c Reviewed-on: https://go-review.googlesource.com/c/go/+/371094 Run-TryBot: Brad Fitzpatrick TryBot-Result: Gopher Robot Reviewed-by: Matt Layher Trust: Matt Layher Trust: Ian Lance Taylor --- src/net/netip/netip.go | 21 ++++++++++++++++++--- src/net/netip/netip_test.go | 6 ++++++ 2 files changed, 24 insertions(+), 3 deletions(-) diff --git a/src/net/netip/netip.go b/src/net/netip/netip.go index 01f6fe5efa..dc5faff40f 100644 --- a/src/net/netip/netip.go +++ b/src/net/netip/netip.go @@ -769,7 +769,11 @@ func (ip Addr) String() string { default: if ip.Is4In6() { // TODO(bradfitz): this could alloc less. - return "::ffff:" + ip.Unmap().String() + if z := ip.Zone(); z != "" { + return "::ffff:" + ip.Unmap().String() + "%" + z + } else { + return "::ffff:" + ip.Unmap().String() + } } return ip.string6() } @@ -787,7 +791,12 @@ func (ip Addr) AppendTo(b []byte) []byte { default: if ip.Is4In6() { b = append(b, "::ffff:"...) - return ip.Unmap().appendTo4(b) + b = ip.Unmap().appendTo4(b) + if z := ip.Zone(); z != "" { + b = append(b, '%') + b = append(b, z...) + } + return b } return ip.appendTo6(b) } @@ -947,10 +956,16 @@ func (ip Addr) MarshalText() ([]byte, error) { b := make([]byte, 0, max) if ip.Is4In6() { b = append(b, "::ffff:"...) - return ip.Unmap().appendTo4(b), nil + b = ip.Unmap().appendTo4(b) + if z := ip.Zone(); z != "" { + b = append(b, '%') + b = append(b, z...) + } + return b, nil } return ip.appendTo6(b), nil } + } // UnmarshalText implements the encoding.TextUnmarshaler interface. diff --git a/src/net/netip/netip_test.go b/src/net/netip/netip_test.go index a6327f0dea..2105545139 100644 --- a/src/net/netip/netip_test.go +++ b/src/net/netip/netip_test.go @@ -114,6 +114,12 @@ func TestParseAddr(t *testing.T) { ip: MkAddr(Mk128(0x0001000200000000, 0x0000ffffc0a88cff), intern.Get("eth1")), str: "1:2::ffff:c0a8:8cff%eth1", }, + // 4-in-6 with zone + { + in: "::ffff:192.168.140.255%eth1", + ip: MkAddr(Mk128(0, 0x0000ffffc0a88cff), intern.Get("eth1")), + str: "::ffff:192.168.140.255%eth1", + }, // IPv6 with capital letters. { in: "FD9E:1A04:F01D::1", From 9c6e8f63c0e4f24ccf4326164ddbc0f0607343a2 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Sat, 11 Dec 2021 19:35:08 -0800 Subject: [PATCH 456/752] net/netip: make AddrPort.MarshalText format 4-in-6 IPs consistently Thanks again to @capnspacehook. Fixes #50110 Change-Id: I1973bdea68eac9842b45f9524f62152e4f5342cf Reviewed-on: https://go-review.googlesource.com/c/go/+/371114 Run-TryBot: Brad Fitzpatrick Reviewed-by: Matt Layher Trust: Matt Layher Trust: Brad Fitzpatrick TryBot-Result: Gopher Robot --- src/net/netip/netip.go | 13 +++++++++++-- src/net/netip/netip_test.go | 26 ++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 2 deletions(-) diff --git a/src/net/netip/netip.go b/src/net/netip/netip.go index dc5faff40f..aaaf435ed8 100644 --- a/src/net/netip/netip.go +++ b/src/net/netip/netip.go @@ -1157,8 +1157,17 @@ func (p AddrPort) AppendTo(b []byte) []byte { case z4: b = p.ip.appendTo4(b) default: - b = append(b, '[') - b = p.ip.appendTo6(b) + if p.ip.Is4In6() { + b = append(b, "[::ffff:"...) + b = p.ip.Unmap().appendTo4(b) + if z := p.ip.Zone(); z != "" { + b = append(b, '%') + b = append(b, z...) + } + } else { + b = append(b, '[') + b = p.ip.appendTo6(b) + } b = append(b, ']') } b = append(b, ':') diff --git a/src/net/netip/netip_test.go b/src/net/netip/netip_test.go index 2105545139..869628050a 100644 --- a/src/net/netip/netip_test.go +++ b/src/net/netip/netip_test.go @@ -347,6 +347,32 @@ func TestAddrMarshalUnmarshalBinary(t *testing.T) { } } +func TestAddrPortMarshalTextString(t *testing.T) { + tests := []struct { + in AddrPort + want string + }{ + {mustIPPort("1.2.3.4:80"), "1.2.3.4:80"}, + {mustIPPort("[1::CAFE]:80"), "[1::cafe]:80"}, + {mustIPPort("[1::CAFE%en0]:80"), "[1::cafe%en0]:80"}, + {mustIPPort("[::FFFF:192.168.140.255]:80"), "[::ffff:192.168.140.255]:80"}, + {mustIPPort("[::FFFF:192.168.140.255%en0]:80"), "[::ffff:192.168.140.255%en0]:80"}, + } + for i, tt := range tests { + if got := tt.in.String(); got != tt.want { + t.Errorf("%d. for (%v, %v) String = %q; want %q", i, tt.in.Addr(), tt.in.Port(), got, tt.want) + } + mt, err := tt.in.MarshalText() + if err != nil { + t.Errorf("%d. for (%v, %v) MarshalText error: %v", i, tt.in.Addr(), tt.in.Port(), err) + continue + } + if string(mt) != tt.want { + t.Errorf("%d. for (%v, %v) MarshalText = %q; want %q", i, tt.in.Addr(), tt.in.Port(), mt, tt.want) + } + } +} + func TestAddrPortMarshalUnmarshalBinary(t *testing.T) { tests := []struct { ipport string From 6b8977372263504535cad6e880ffca156bdfdf68 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Thu, 9 Dec 2021 12:25:04 -0500 Subject: [PATCH 457/752] testenv: abstract run-with-timeout into testenv This lifts the logic to run a subcommand with a timeout in a test from the runtime's runTestProg into testenv. The implementation is unchanged in this CL. We'll improve it in a future CL. Currently, tests that run subcommands usually just timeout with no useful output if the subcommand runs for too long. This is a step toward improving this. For #37405. Change-Id: I2298770db516e216379c4c438e05d23cbbdda51d Reviewed-on: https://go-review.googlesource.com/c/go/+/370701 Trust: Austin Clements Run-TryBot: Austin Clements TryBot-Result: Gopher Robot Reviewed-by: Michael Knyszek Reviewed-by: Bryan Mills --- src/internal/testenv/testenv.go | 51 +++++++++++++++++++ .../testenv/testenv_notunix.go} | 8 +-- src/internal/testenv/testenv_unix.go | 13 +++++ src/runtime/crash_test.go | 41 +-------------- src/runtime/crash_unix_test.go | 6 +-- 5 files changed, 71 insertions(+), 48 deletions(-) rename src/{runtime/crash_nonunix_test.go => internal/testenv/testenv_notunix.go} (57%) create mode 100644 src/internal/testenv/testenv_unix.go diff --git a/src/internal/testenv/testenv.go b/src/internal/testenv/testenv.go index c902b1404f..eeb7d65a9b 100644 --- a/src/internal/testenv/testenv.go +++ b/src/internal/testenv/testenv.go @@ -11,6 +11,7 @@ package testenv import ( + "bytes" "errors" "flag" "internal/cfg" @@ -22,6 +23,7 @@ import ( "strings" "sync" "testing" + "time" ) // Builder reports the name of the builder running this test @@ -306,3 +308,52 @@ func SkipIfShortAndSlow(t testing.TB) { t.Skipf("skipping test in -short mode on %s", runtime.GOARCH) } } + +// RunWithTimeout runs cmd and returns its combined output. If the +// subprocess exits with a non-zero status, it will log that status +// and return a non-nil error, but this is not considered fatal. +func RunWithTimeout(t testing.TB, cmd *exec.Cmd) ([]byte, error) { + args := cmd.Args + if args == nil { + args = []string{cmd.Path} + } + + var b bytes.Buffer + cmd.Stdout = &b + cmd.Stderr = &b + if err := cmd.Start(); err != nil { + t.Fatalf("starting %s: %v", args, err) + } + + // If the process doesn't complete within 1 minute, + // assume it is hanging and kill it to get a stack trace. + p := cmd.Process + done := make(chan bool) + go func() { + scale := 1 + // This GOARCH/GOOS test is copied from cmd/dist/test.go. + // TODO(iant): Have cmd/dist update the environment variable. + if runtime.GOARCH == "arm" || runtime.GOOS == "windows" { + scale = 2 + } + if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" { + if sc, err := strconv.Atoi(s); err == nil { + scale = sc + } + } + + select { + case <-done: + case <-time.After(time.Duration(scale) * time.Minute): + p.Signal(Sigquit) + } + }() + + err := cmd.Wait() + if err != nil { + t.Logf("%s exit status: %v", args, err) + } + close(done) + + return b.Bytes(), err +} diff --git a/src/runtime/crash_nonunix_test.go b/src/internal/testenv/testenv_notunix.go similarity index 57% rename from src/runtime/crash_nonunix_test.go rename to src/internal/testenv/testenv_notunix.go index 73c1cd3101..180206bc9b 100644 --- a/src/runtime/crash_nonunix_test.go +++ b/src/internal/testenv/testenv_notunix.go @@ -1,13 +1,13 @@ -// Copyright 2016 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. //go:build windows || plan9 || (js && wasm) -package runtime_test +package testenv import "os" -// sigquit is the signal to send to kill a hanging testdata program. +// Sigquit is the signal to send to kill a hanging subprocess. // On Unix we send SIGQUIT, but on non-Unix we only have os.Kill. -var sigquit = os.Kill +var Sigquit = os.Kill diff --git a/src/internal/testenv/testenv_unix.go b/src/internal/testenv/testenv_unix.go new file mode 100644 index 0000000000..3dc5daf45e --- /dev/null +++ b/src/internal/testenv/testenv_unix.go @@ -0,0 +1,13 @@ +// 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. + +//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris + +package testenv + +import "syscall" + +// Sigquit is the signal to send to kill a hanging subprocess. +// Send SIGQUIT to get a stack trace. +var Sigquit = syscall.SIGQUIT diff --git a/src/runtime/crash_test.go b/src/runtime/crash_test.go index ec4db99d78..01b1ebcdd7 100644 --- a/src/runtime/crash_test.go +++ b/src/runtime/crash_test.go @@ -15,11 +15,9 @@ import ( "path/filepath" "regexp" "runtime" - "strconv" "strings" "sync" "testing" - "time" ) var toRemove []string @@ -71,43 +69,8 @@ func runBuiltTestProg(t *testing.T, exe, name string, env ...string) string { if testing.Short() { cmd.Env = append(cmd.Env, "RUNTIME_TEST_SHORT=1") } - var b bytes.Buffer - cmd.Stdout = &b - cmd.Stderr = &b - if err := cmd.Start(); err != nil { - t.Fatalf("starting %s %s: %v", exe, name, err) - } - - // If the process doesn't complete within 1 minute, - // assume it is hanging and kill it to get a stack trace. - p := cmd.Process - done := make(chan bool) - go func() { - scale := 1 - // This GOARCH/GOOS test is copied from cmd/dist/test.go. - // TODO(iant): Have cmd/dist update the environment variable. - if runtime.GOARCH == "arm" || runtime.GOOS == "windows" { - scale = 2 - } - if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" { - if sc, err := strconv.Atoi(s); err == nil { - scale = sc - } - } - - select { - case <-done: - case <-time.After(time.Duration(scale) * time.Minute): - p.Signal(sigquit) - } - }() - - if err := cmd.Wait(); err != nil { - t.Logf("%s %s exit status: %v", exe, name, err) - } - close(done) - - return b.String() + out, _ := testenv.RunWithTimeout(t, cmd) + return string(out) } var serializeBuild = make(chan bool, 2) diff --git a/src/runtime/crash_unix_test.go b/src/runtime/crash_unix_test.go index b93a760276..1eb10f9b60 100644 --- a/src/runtime/crash_unix_test.go +++ b/src/runtime/crash_unix_test.go @@ -21,16 +21,12 @@ import ( "unsafe" ) -// sigquit is the signal to send to kill a hanging testdata program. -// Send SIGQUIT to get a stack trace. -var sigquit = syscall.SIGQUIT - func init() { if runtime.Sigisblocked(int(syscall.SIGQUIT)) { // We can't use SIGQUIT to kill subprocesses because // it's blocked. Use SIGKILL instead. See issue // #19196 for an example of when this happens. - sigquit = syscall.SIGKILL + testenv.Sigquit = syscall.SIGKILL } } From cc795a01dcec7c97044b31571af88ac98310f2b3 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Thu, 9 Dec 2021 12:51:29 -0500 Subject: [PATCH 458/752] testenv: kill subprocess if SIGQUIT doesn't do it This makes testenv.RunWithTimeout first attempt to SIGQUIT the subprocess to get a useful Go traceback, but if that doesn't work, it sends a SIGKILL instead to make sure we tear down the subprocess. This is potentially important for non-Go subprocesses. For #37405. Change-Id: I9e7e118dc5769ec3f45288a71658733bff30c9cd Reviewed-on: https://go-review.googlesource.com/c/go/+/370702 Trust: Austin Clements Run-TryBot: Austin Clements TryBot-Result: Gopher Robot Reviewed-by: Bryan Mills Reviewed-by: Ian Lance Taylor --- src/internal/testenv/testenv.go | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/internal/testenv/testenv.go b/src/internal/testenv/testenv.go index eeb7d65a9b..d7614b0706 100644 --- a/src/internal/testenv/testenv.go +++ b/src/internal/testenv/testenv.go @@ -346,6 +346,13 @@ func RunWithTimeout(t testing.TB, cmd *exec.Cmd) ([]byte, error) { case <-done: case <-time.After(time.Duration(scale) * time.Minute): p.Signal(Sigquit) + // If SIGQUIT doesn't do it after a little + // while, kill the process. + select { + case <-done: + case <-time.After(time.Duration(scale) * 30 * time.Second): + p.Signal(os.Kill) + } } }() From 8692bacb6a43d1f65e09d0e581ca8b464fd77664 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Thu, 9 Dec 2021 13:52:18 -0500 Subject: [PATCH 459/752] runtime: run gdb with a timeout for TestGdbBacktrace This sometimes times out and we don't have any useful output for debugging it. Hopefully this will help. For #37405. Change-Id: I79074e6fbb9bd16a864c651109a0acbfc8aa6cef Reviewed-on: https://go-review.googlesource.com/c/go/+/370703 Trust: Austin Clements Run-TryBot: Austin Clements Reviewed-by: Michael Knyszek TryBot-Result: Gopher Robot --- src/runtime/runtime-gdb_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/runtime/runtime-gdb_test.go b/src/runtime/runtime-gdb_test.go index 4a0f489c2f..63d3160ee4 100644 --- a/src/runtime/runtime-gdb_test.go +++ b/src/runtime/runtime-gdb_test.go @@ -424,7 +424,7 @@ func TestGdbBacktrace(t *testing.T) { "-ex", "continue", filepath.Join(dir, "a.exe"), } - got, err := exec.Command("gdb", args...).CombinedOutput() + got, err := testenv.RunWithTimeout(t, exec.Command("gdb", args...)) t.Logf("gdb output:\n%s", got) if err != nil { t.Fatalf("gdb exited with error: %v", err) From 56817040d53187abcd568af0eea27cc21379c0ad Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Fri, 10 Dec 2021 21:09:16 -0500 Subject: [PATCH 460/752] os: document error returned by pending I/O operations on Close Currently, File.Close only documents that "an" error will be returned by pending I/O operations. Update the documentation to say that error is specifically ErrClosed. Change-Id: Ica817c9196ad6cb570c826789d37a4ff15a5d13d Reviewed-on: https://go-review.googlesource.com/c/go/+/371015 Trust: Austin Clements Reviewed-by: Ian Lance Taylor --- src/os/file_plan9.go | 2 +- src/os/file_posix.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/os/file_plan9.go b/src/os/file_plan9.go index 604aea607b..887e1c8892 100644 --- a/src/os/file_plan9.go +++ b/src/os/file_plan9.go @@ -139,7 +139,7 @@ func openFileNolog(name string, flag int, perm FileMode) (*File, error) { // Close closes the File, rendering it unusable for I/O. // On files that support SetDeadline, any pending I/O operations will -// be canceled and return immediately with an error. +// be canceled and return immediately with an ErrClosed error. // Close will return an error if it has already been called. func (f *File) Close() error { if err := f.checkValid("close"); err != nil { diff --git a/src/os/file_posix.go b/src/os/file_posix.go index 0dc6da0908..f34571d68d 100644 --- a/src/os/file_posix.go +++ b/src/os/file_posix.go @@ -16,7 +16,7 @@ func sigpipe() // implemented in package runtime // Close closes the File, rendering it unusable for I/O. // On files that support SetDeadline, any pending I/O operations will -// be canceled and return immediately with an error. +// be canceled and return immediately with an ErrClosed error. // Close will return an error if it has already been called. func (f *File) Close() error { if f == nil { From 49b7c9caec6b96d0b327624efee61bd8a72cf68c Mon Sep 17 00:00:00 2001 From: Matt Layher Date: Sun, 12 Dec 2021 10:53:17 -0500 Subject: [PATCH 461/752] net/netip: make Prefix.MarshalText format 4-in-6 IPs consistently Fixes #50115. Change-Id: Iac76e5b486d3a2a784583345eaeb22c31cc4a36d Reviewed-on: https://go-review.googlesource.com/c/go/+/371134 Trust: Matt Layher Run-TryBot: Matt Layher Reviewed-by: Brad Fitzpatrick Trust: Brad Fitzpatrick TryBot-Result: Gopher Robot --- src/net/netip/netip.go | 7 ++++++- src/net/netip/netip_test.go | 27 ++++++++++++++++++++++++++- 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/src/net/netip/netip.go b/src/net/netip/netip.go index aaaf435ed8..591d38abc8 100644 --- a/src/net/netip/netip.go +++ b/src/net/netip/netip.go @@ -1422,7 +1422,12 @@ func (p Prefix) AppendTo(b []byte) []byte { if p.ip.z == z4 { b = p.ip.appendTo4(b) } else { - b = p.ip.appendTo6(b) + if p.ip.Is4In6() { + b = append(b, "::ffff:"...) + b = p.ip.Unmap().appendTo4(b) + } else { + b = p.ip.appendTo6(b) + } } b = append(b, '/') diff --git a/src/net/netip/netip_test.go b/src/net/netip/netip_test.go index 869628050a..520695cdfb 100644 --- a/src/net/netip/netip_test.go +++ b/src/net/netip/netip_test.go @@ -413,6 +413,32 @@ func TestAddrPortMarshalUnmarshalBinary(t *testing.T) { } } +func TestPrefixMarshalTextString(t *testing.T) { + tests := []struct { + in Prefix + want string + }{ + {mustPrefix("1.2.3.4/24"), "1.2.3.4/24"}, + {mustPrefix("fd7a:115c:a1e0:ab12:4843:cd96:626b:430b/118"), "fd7a:115c:a1e0:ab12:4843:cd96:626b:430b/118"}, + {mustPrefix("::ffff:c000:0280/96"), "::ffff:192.0.2.128/96"}, + {mustPrefix("::ffff:c000:0280%eth0/37"), "::ffff:192.0.2.128/37"}, // Zone should be stripped + {mustPrefix("::ffff:192.168.140.255/8"), "::ffff:192.168.140.255/8"}, + } + for i, tt := range tests { + if got := tt.in.String(); got != tt.want { + t.Errorf("%d. for %v String = %q; want %q", i, tt.in, got, tt.want) + } + mt, err := tt.in.MarshalText() + if err != nil { + t.Errorf("%d. for %v MarshalText error: %v", i, tt.in, err) + continue + } + if string(mt) != tt.want { + t.Errorf("%d. for %v MarshalText = %q; want %q", i, tt.in, mt, tt.want) + } + } +} + func TestPrefixMarshalUnmarshalBinary(t *testing.T) { type testCase struct { prefix Prefix @@ -994,7 +1020,6 @@ func TestPrefixMarshalUnmarshal(t *testing.T) { "0.0.0.0/0", "::/0", "::1/128", - "::ffff:c000:1234/128", "2001:db8::/32", } From 9bfe09d78bd1b3ab97bc6e1c31395f0822875fba Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Sun, 12 Dec 2021 11:08:59 -0800 Subject: [PATCH 462/752] cmd/compile: fix identity case relating to 'any' and shape types In identical(), we don't want any to match a shape empty-interface type for the identStrict option, since IdenticalStrict() is specifically not supposed to match a shape type with a non-shape type. There is similar code in (*Type).cmp() (TINTER case), but I don't believe that we want to disqualify shape types from matching any in this case, since cmp() is used for back-end code, where we don't care about shape types vs non-shape types. The issue mainly comes about when 'any' is used as a type argument (rather than 'interface{}'), but only with some complicated circumstances, as shown by the test case. (Couldn't reproduce with simpler test cases.) Fixes #50109 Change-Id: I3f2f88be158f9ad09273237e1d346bc56aac099f Reviewed-on: https://go-review.googlesource.com/c/go/+/371154 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: Keith Randall --- src/cmd/compile/internal/types/identity.go | 6 +- test/typeparam/issue50109.go | 105 +++++++++++++++++++++ test/typeparam/issue50109.out | 1 + 3 files changed, 111 insertions(+), 1 deletion(-) create mode 100644 test/typeparam/issue50109.go create mode 100644 test/typeparam/issue50109.out diff --git a/src/cmd/compile/internal/types/identity.go b/src/cmd/compile/internal/types/identity.go index f99e50a1c3..a164b84da9 100644 --- a/src/cmd/compile/internal/types/identity.go +++ b/src/cmd/compile/internal/types/identity.go @@ -59,7 +59,11 @@ func identical(t1, t2 *Type, flags int, assumedEqual map[typePair]struct{}) bool case TINT32: return (t1 == Types[TINT32] || t1 == RuneType) && (t2 == Types[TINT32] || t2 == RuneType) case TINTER: - // Make sure named any type matches any empty interface. + // Make sure named any type matches any empty interface + // (but not a shape type, if identStrict). + if flags&identStrict != 0 { + return t1 == AnyType && t2.IsEmptyInterface() && !t2.HasShape() || t2 == AnyType && t1.IsEmptyInterface() && !t1.HasShape() + } return t1 == AnyType && t2.IsEmptyInterface() || t2 == AnyType && t1.IsEmptyInterface() default: return false diff --git a/test/typeparam/issue50109.go b/test/typeparam/issue50109.go new file mode 100644 index 0000000000..a6913df843 --- /dev/null +++ b/test/typeparam/issue50109.go @@ -0,0 +1,105 @@ +// run -gcflags=-G=3 + +// 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 AnyCacher[T any] interface { + // Get an item from the cache. Returns the item or nil, and a bool indicating + // whether the key was found. + Get(k string) (T, bool) + // Add an item to the cache, replacing any existing item. + Set(k string, x T) +} + +// Item ... +type Item[T any] struct { + Object T +} + +// AnyCache implements AnyCacher +type AnyCache[T any] struct { + *anyCache[T] +} + +type anyCache[T any] struct { + items map[string]Item[T] + janitor *janitor[T] // Needed for the failure in the issue +} + +// Set adds an item to the cache, replacing any existing item. +func (c *anyCache[T]) Set(k string, x T) { + c.items[k] = Item[T]{ + Object: x, + } +} + +// Get gets an item from the cache. Returns the item or nil, and a bool indicating +// whether the key was found. +func (c *anyCache[T]) Get(k string) (T, bool) { + // "Inlining" of get and Expired + item, found := c.items[k] + if !found { + var ret T + return ret, false + } + + return item.Object, true +} + +type janitor[T any] struct { + stop chan bool +} + +func newAnyCache[T any](m map[string]Item[T]) *anyCache[T] { + c := &anyCache[T]{ + items: m, + } + return c +} + +// NewAny[T any](...) returns a new AnyCache[T]. +func NewAny[T any]() *AnyCache[T] { + items := make(map[string]Item[T]) + return &AnyCache[T]{newAnyCache(items)} +} + +// NewAnyCacher[T any](...) returns an AnyCacher[T] interface. +func NewAnyCacher[T any]() AnyCacher[T] { + return NewAny[T]() +} + +type MyStruct struct { + Name string +} + +func main() { + // Create a generic cache. + // All items are cached as interface{} so they need to be cast back to their + // original type when retrieved. + // Failure in issue doesn't happen with 'any' replaced by 'interface{}' + c := NewAnyCacher[any]() + + myStruct := &MyStruct{"MySuperStruct"} + + c.Set("MySuperStruct", myStruct) + + myRawCachedStruct, found := c.Get("MySuperStruct") + + if found { + // Casting the retrieved object back to its original type + myCachedStruct := myRawCachedStruct.(*MyStruct) + fmt.Printf("%s", myCachedStruct.Name) + } else { + fmt.Printf("Error: MySuperStruct not found in cache") + } + + // Output: + // MySuperStruct +} diff --git a/test/typeparam/issue50109.out b/test/typeparam/issue50109.out new file mode 100644 index 0000000000..7d6ecc0c6d --- /dev/null +++ b/test/typeparam/issue50109.out @@ -0,0 +1 @@ +MySuperStruct \ No newline at end of file From 36db10f3cb916a1b97af3bfd4be7e3a2932185f8 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Thu, 9 Dec 2021 17:00:51 -0500 Subject: [PATCH 463/752] net: remove erroneous Dial check in TestListenerClose TestListenerClose had been asserting that a Dial to the newly-closed address always fails, on the assumption that the listener's address and port would not be reused by some other listener that could then accept the connection. As far as I can tell, that assumption is not valid: the Dial after Close may well connect to a Listener opened for some other test, or even one opened by a completely different process running concurrently on the same machine. Fixes #38700 Change-Id: I925ed1b2ccb556135a2c5be0240d1789ed27d5fc Reviewed-on: https://go-review.googlesource.com/c/go/+/370666 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/net/net_test.go | 29 ++++++----------------------- 1 file changed, 6 insertions(+), 23 deletions(-) diff --git a/src/net/net_test.go b/src/net/net_test.go index 35acac509b..5d9c3c67e6 100644 --- a/src/net/net_test.go +++ b/src/net/net_test.go @@ -243,7 +243,6 @@ func TestListenerClose(t *testing.T) { defer os.Remove(ln.Addr().String()) } - dst := ln.Addr().String() if err := ln.Close(); err != nil { if perr := parseCloseError(err, false); perr != nil { t.Error(perr) @@ -256,28 +255,12 @@ func TestListenerClose(t *testing.T) { t.Fatal("should fail") } - if network == "tcp" { - // We will have two TCP FSMs inside the - // kernel here. There's no guarantee that a - // signal comes from the far end FSM will be - // delivered immediately to the near end FSM, - // especially on the platforms that allow - // multiple consumer threads to pull pending - // established connections at the same time by - // enabling SO_REUSEPORT option such as Linux, - // DragonFly BSD. So we need to give some time - // quantum to the kernel. - // - // Note that net.inet.tcp.reuseport_ext=1 by - // default on DragonFly BSD. - time.Sleep(time.Millisecond) - - cc, err := Dial("tcp", dst) - if err == nil { - t.Error("Dial to closed TCP listener succeeded.") - cc.Close() - } - } + // Note: we cannot ensure that a subsequent Dial does not succeed, because + // we do not in general have any guarantee that ln.Addr is not immediately + // reused. (TCP sockets enter a TIME_WAIT state when closed, but that only + // applies to existing connections for the port — it does not prevent the + // port itself from being used for entirely new connections in the + // meantime.) }) } } From 6f42be78bbc107beef8b6eb61a794355e07120ca Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Thu, 9 Dec 2021 11:54:46 -0500 Subject: [PATCH 464/752] net: do not try to remove the LocalAddr of a unix socket MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit TestUnixAndUnixpacketServer deferred a call to os.Remove on the local address of a dialed unix domain socket, in an attempt to remove the socket from the server. However, that call appears to be neither necessary nor correct. In this test, the file that needs to be unlinked is the one attached to the listener — but the listener's Close method already does that (see the Unlink call in (*UnixListener).close), so there is no need for the test itself to do the same. Moreover, the local address is not something that is sensible to delete — on Linux, it is empirically always the literal string "@" — and the Addr returned by c.LocalAddr is not reliably non-nil on all platforms (see #34611). Since we don't need to do anything with the local address, we shouldn't. At best, this is a benign Remove of a file that doesn't exist anyway; at worst, it is a nil-panic. Fixes #34611 Change-Id: Ie072b3388d884d60e819d1df210fa7d3e2eed124 Reviewed-on: https://go-review.googlesource.com/c/go/+/370695 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/net/server_test.go | 29 ++--------------------------- 1 file changed, 2 insertions(+), 27 deletions(-) diff --git a/src/net/server_test.go b/src/net/server_test.go index 33d33b0337..ae1c1619ed 100644 --- a/src/net/server_test.go +++ b/src/net/server_test.go @@ -7,9 +7,7 @@ package net import ( - "fmt" "os" - "reflect" "testing" ) @@ -190,32 +188,9 @@ func TestUnixAndUnixpacketServer(t *testing.T) { t.Fatal(err) } - // We really just want to defer os.Remove(c.LocalAddr().String()) here, - // but sometimes that panics due to a nil dereference on the - // solaris-amd64-oraclerel builder (https://golang.org/issue/34611). - // The source of the nil panic is not obvious because there are many - // nillable types involved, so we will temporarily inspect all of them to - // try to get a better idea of what is happening on that platform. - checkNils := func() { - if c == nil { - panic("Dial returned a nil Conn") - } - if rc := reflect.ValueOf(c); rc.Kind() == reflect.Pointer && rc.IsNil() { - panic(fmt.Sprintf("Dial returned a nil %T", c)) - } - addr := c.LocalAddr() - if addr == nil { - panic(fmt.Sprintf("(%T).LocalAddr returned a nil Addr", c)) - } - if raddr := reflect.ValueOf(addr); raddr.Kind() == reflect.Pointer && raddr.IsNil() { - panic(fmt.Sprintf("(%T).LocalAddr returned a nil %T", c, addr)) - } + if addr := c.LocalAddr(); addr != nil { + t.Logf("connected %s->%s", addr, lss[i].Listener.Addr()) } - defer func() { - checkNils() - os.Remove(c.LocalAddr().String()) - }() - checkNils() defer c.Close() trchs = append(trchs, make(chan error, 1)) From f4ca598c9f08a4d00942a1c6a6b8cc7d8f162b66 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 3 Dec 2021 11:44:00 -0500 Subject: [PATCH 465/752] net: don't check "invalid.invalid" lookup errors in TestLookupHostCancel The exact error isn't actually relevant to the test, and may depend on whether the Go or cgo resolver is used. Also run the test in parallel, because it spends most of its time sleeping in between lookups. Fixes #38767 Fixes #43140 Change-Id: I2d64ffddf2eb114a69ed3242daa9a9e4a5679f67 Reviewed-on: https://go-review.googlesource.com/c/go/+/369037 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/net/lookup_test.go | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index 7bcc5c5be8..5b3a3e24b2 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -925,6 +925,8 @@ func TestNilResolverLookup(t *testing.T) { // canceled lookups (see golang.org/issue/24178 for details). func TestLookupHostCancel(t *testing.T) { mustHaveExternalNetwork(t) + t.Parallel() // Executes 600ms worth of sequential sleeps. + const ( google = "www.google.com" invalidDomain = "invalid.invalid" // RFC 2606 reserves .invalid @@ -943,9 +945,15 @@ func TestLookupHostCancel(t *testing.T) { if err == nil { t.Fatalf("LookupHost(%q): returns %v, but should fail", invalidDomain, addr) } - if !strings.Contains(err.Error(), "canceled") { - t.Fatalf("LookupHost(%q): failed with unexpected error: %v", invalidDomain, err) - } + + // Don't verify what the actual error is. + // We know that it must be non-nil because the domain is invalid, + // but we don't have any guarantee that LookupHost actually bothers + // to check for cancellation on the fast path. + // (For example, it could use a local cache to avoid blocking entirely.) + + // The lookup may deduplicate in-flight requests, so give it time to settle + // in between. time.Sleep(time.Millisecond * 1) } From d198a36d8c1d0a251449a1cc2355485a177310c4 Mon Sep 17 00:00:00 2001 From: "Paul E. Murphy" Date: Fri, 10 Dec 2021 16:58:43 -0600 Subject: [PATCH 466/752] cmd/asm,cmd/compile: fix tail call in leaf functions on PPC64 In some leaf functions using "RET foo(SB)", the jump may be incorrectly translated into "JMP LR" instead of "JMP foo(SB)". Such is the case when compiling the autogenerated function in k8s k8s.io/kubernetes/pkg/kubelet/server/stats.(*resourceAnalyzer).GetPodVolumeStats. Fixes #50048 Change-Id: Icdf65fcda6b3c5eb9d3ad5c7aad04add9419dffb Reviewed-on: https://go-review.googlesource.com/c/go/+/371034 Run-TryBot: Paul Murphy Reviewed-by: Cherry Mui Trust: Paul Murphy --- src/cmd/internal/obj/ppc64/obj9.go | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/cmd/internal/obj/ppc64/obj9.go b/src/cmd/internal/obj/ppc64/obj9.go index 7ac6465a72..c986c0d2b6 100644 --- a/src/cmd/internal/obj/ppc64/obj9.go +++ b/src/cmd/internal/obj/ppc64/obj9.go @@ -884,8 +884,13 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) { q = c.newprog() q.As = ABR q.Pos = p.Pos - q.To.Type = obj.TYPE_REG - q.To.Reg = REG_LR + if retTarget == nil { + q.To.Type = obj.TYPE_REG + q.To.Reg = REG_LR + } else { + q.To.Type = obj.TYPE_BRANCH + q.To.Sym = retTarget + } q.Mark |= BRANCH q.Spadj = +autosize From b55cbbb9e76969d67fbc6e264a584ad18c2f95fa Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Thu, 9 Dec 2021 11:42:42 -0500 Subject: [PATCH 467/752] net: pass a testing.TB to newLocal* helpers Passing in an explicit testing.TB gives two benefits: 1. It allows the helper to fail the test itself, instead of returning an error to the caller. A non-nil error invariably fails the calling test, and none of these callers bother to add detail to the error when logging it anyway so returning the error just added noise to the test bodies. 2. It allows the helper to use t.Cleanup to perform any needed cleanup tasks, which will be used in CL 370695 to clean up temp directories used as namespaces for unix socket paths. For #34611 Change-Id: I805e701687c12de2caca955649369294229c10b4 Reviewed-on: https://go-review.googlesource.com/c/go/+/370696 Trust: Bryan Mills Reviewed-by: Ian Lance Taylor Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot --- src/net/conn_test.go | 5 +- src/net/dial_test.go | 38 +++----------- src/net/dial_unix_test.go | 5 +- src/net/error_test.go | 15 ++---- src/net/file_test.go | 35 +++++-------- src/net/listen_test.go | 25 ++++------ src/net/mockserver_test.go | 84 ++++++++++++++++++++----------- src/net/net_test.go | 49 +++++------------- src/net/protoconn_test.go | 5 +- src/net/rawconn_test.go | 15 ++---- src/net/sendfile_test.go | 25 ++-------- src/net/server_test.go | 20 ++------ src/net/splice_test.go | 71 +++++++------------------- src/net/tcpsock_test.go | 25 ++-------- src/net/tcpsock_unix_test.go | 5 +- src/net/timeout_test.go | 86 +++++++------------------------- src/net/udpsock_test.go | 20 ++------ src/net/unixsock_test.go | 15 ++---- src/net/unixsock_windows_test.go | 5 +- src/net/writev_test.go | 5 +- 20 files changed, 164 insertions(+), 389 deletions(-) diff --git a/src/net/conn_test.go b/src/net/conn_test.go index e3cb0c5ec7..3403eddfd3 100644 --- a/src/net/conn_test.go +++ b/src/net/conn_test.go @@ -26,10 +26,7 @@ func TestConnAndListener(t *testing.T) { continue } - ls, err := newLocalServer(network) - if err != nil { - t.Fatal(err) - } + ls := newLocalServer(t, network) defer ls.teardown() ch := make(chan error, 1) handler := func(ls *localServer, ln Listener) { ls.transponder(ln, ch) } diff --git a/src/net/dial_test.go b/src/net/dial_test.go index 36843870aa..e0c9cdc2ae 100644 --- a/src/net/dial_test.go +++ b/src/net/dial_test.go @@ -59,10 +59,7 @@ func TestProhibitionaryDialArg(t *testing.T) { } func TestDialLocal(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() _, port, err := SplitHostPort(ln.Addr().String()) if err != nil { @@ -619,13 +616,9 @@ func TestDialerLocalAddr(t *testing.T) { c.Close() } } - var err error var lss [2]*localServer for i, network := range []string{"tcp4", "tcp6"} { - lss[i], err = newLocalServer(network) - if err != nil { - t.Fatal(err) - } + lss[i] = newLocalServer(t, network) defer lss[i].teardown() if err := lss[i].buildup(handler); err != nil { t.Fatal(err) @@ -725,10 +718,7 @@ func TestDialerKeepAlive(t *testing.T) { c.Close() } } - ls, err := newLocalServer("tcp") - if err != nil { - t.Fatal(err) - } + ls := newLocalServer(t, "tcp") defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) @@ -826,10 +816,7 @@ func TestCancelAfterDial(t *testing.T) { t.Skip("avoiding time.Sleep") } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") var wg sync.WaitGroup wg.Add(1) @@ -932,11 +919,7 @@ func TestDialerControl(t *testing.T) { if !testableNetwork(network) { continue } - ln, err := newLocalListener(network) - if err != nil { - t.Error(err) - continue - } + ln := newLocalListener(t, network) defer ln.Close() d := Dialer{Control: controlOnConnSetup} c, err := d.Dial(network, ln.Addr().String()) @@ -952,11 +935,7 @@ func TestDialerControl(t *testing.T) { if !testableNetwork(network) { continue } - c1, err := newLocalPacketListener(network) - if err != nil { - t.Error(err) - continue - } + c1 := newLocalPacketListener(t, network) if network == "unixgram" { defer os.Remove(c1.LocalAddr().String()) } @@ -992,10 +971,7 @@ func (contextWithNonZeroDeadline) Deadline() (time.Time, bool) { } func TestDialWithNonZeroDeadline(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() _, port, err := SplitHostPort(ln.Addr().String()) if err != nil { diff --git a/src/net/dial_unix_test.go b/src/net/dial_unix_test.go index 64dca70eb8..4170367c4b 100644 --- a/src/net/dial_unix_test.go +++ b/src/net/dial_unix_test.go @@ -31,10 +31,7 @@ func TestDialContextCancelRace(t *testing.T) { testHookCanceledDial = oldTestHookCanceledDial }() - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") listenerDone := make(chan struct{}) go func() { defer close(listenerDone) diff --git a/src/net/error_test.go b/src/net/error_test.go index 30f8af3aee..4a191673e2 100644 --- a/src/net/error_test.go +++ b/src/net/error_test.go @@ -553,10 +553,7 @@ third: } func TestCloseError(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() c, err := Dial(ln.Addr().Network(), ln.Addr().String()) if err != nil { @@ -664,10 +661,7 @@ func TestAcceptError(t *testing.T) { c.Close() } } - ls, err := newLocalServer("tcp") - if err != nil { - t.Fatal(err) - } + ls := newLocalServer(t, "tcp") if err := ls.buildup(handler); err != nil { ls.teardown() t.Fatal(err) @@ -773,10 +767,7 @@ func TestFileError(t *testing.T) { t.Error("should fail") } - ln, err = newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln = newLocalListener(t, "tcp") for i := 0; i < 3; i++ { f, err := ln.(*TCPListener).File() diff --git a/src/net/file_test.go b/src/net/file_test.go index e86c15fac7..ea2a218dfb 100644 --- a/src/net/file_test.go +++ b/src/net/file_test.go @@ -44,10 +44,7 @@ func TestFileConn(t *testing.T) { var network, address string switch tt.network { case "udp": - c, err := newLocalPacketListener(tt.network) - if err != nil { - t.Fatal(err) - } + c := newLocalPacketListener(t, tt.network) defer c.Close() network = c.LocalAddr().Network() address = c.LocalAddr().String() @@ -61,10 +58,7 @@ func TestFileConn(t *testing.T) { var b [1]byte c.Read(b[:]) } - ls, err := newLocalServer(tt.network) - if err != nil { - t.Fatal(err) - } + ls := newLocalServer(t, tt.network) defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) @@ -148,17 +142,17 @@ func TestFileListener(t *testing.T) { continue } - ln1, err := newLocalListener(tt.network) - if err != nil { - t.Fatal(err) - } + ln1 := newLocalListener(t, tt.network) switch tt.network { case "unix", "unixpacket": defer os.Remove(ln1.Addr().String()) } addr := ln1.Addr() - var f *os.File + var ( + f *os.File + err error + ) switch ln1 := ln1.(type) { case *TCPListener: f, err = ln1.File() @@ -240,17 +234,17 @@ func TestFilePacketConn(t *testing.T) { continue } - c1, err := newLocalPacketListener(tt.network) - if err != nil { - t.Fatal(err) - } + c1 := newLocalPacketListener(t, tt.network) switch tt.network { case "unixgram": defer os.Remove(c1.LocalAddr().String()) } addr := c1.LocalAddr() - var f *os.File + var ( + f *os.File + err error + ) switch c1 := c1.(type) { case *UDPConn: f, err = c1.File() @@ -314,10 +308,7 @@ func TestFileCloseRace(t *testing.T) { c.Read(b[:]) } - ls, err := newLocalServer("tcp") - if err != nil { - t.Fatal(err) - } + ls := newLocalServer(t, "tcp") defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) diff --git a/src/net/listen_test.go b/src/net/listen_test.go index 7aaebe8fa1..09ffbb31a1 100644 --- a/src/net/listen_test.go +++ b/src/net/listen_test.go @@ -697,10 +697,7 @@ func multicastRIBContains(ip IP) (bool, error) { // Issue 21856. func TestClosingListener(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") addr := ln.Addr() go func() { @@ -738,15 +735,13 @@ func TestListenConfigControl(t *testing.T) { if !testableNetwork(network) { continue } - ln, err := newLocalListener(network) - if err != nil { - t.Error(err) - continue - } + ln := newLocalListener(t, network) address := ln.Addr().String() + // TODO: This is racy. The selected address could be reused in between + // this Close and the subsequent Listen. ln.Close() lc := ListenConfig{Control: controlOnConnSetup} - ln, err = lc.Listen(context.Background(), network, address) + ln, err := lc.Listen(context.Background(), network, address) if err != nil { t.Error(err) continue @@ -759,18 +754,16 @@ func TestListenConfigControl(t *testing.T) { if !testableNetwork(network) { continue } - c, err := newLocalPacketListener(network) - if err != nil { - t.Error(err) - continue - } + c := newLocalPacketListener(t, network) address := c.LocalAddr().String() + // TODO: This is racy. The selected address could be reused in between + // this Close and the subsequent ListenPacket. c.Close() if network == "unixgram" { os.Remove(address) } lc := ListenConfig{Control: controlOnConnSetup} - c, err = lc.ListenPacket(context.Background(), network, address) + c, err := lc.ListenPacket(context.Background(), network, address) if err != nil { t.Error(err) continue diff --git a/src/net/mockserver_test.go b/src/net/mockserver_test.go index 70ecc69f66..0868871b7b 100644 --- a/src/net/mockserver_test.go +++ b/src/net/mockserver_test.go @@ -11,6 +11,7 @@ import ( "fmt" "os" "sync" + "testing" "time" ) @@ -26,29 +27,44 @@ func testUnixAddr() string { return addr } -func newLocalListener(network string) (Listener, error) { +func newLocalListener(t testing.TB, network string) Listener { + listen := func(net, addr string) Listener { + ln, err := Listen(net, addr) + if err != nil { + t.Helper() + t.Fatal(err) + } + return ln + } + switch network { case "tcp": if supportsIPv4() { + if !supportsIPv6() { + return listen("tcp4", "127.0.0.1:0") + } if ln, err := Listen("tcp4", "127.0.0.1:0"); err == nil { - return ln, nil + return ln } } if supportsIPv6() { - return Listen("tcp6", "[::1]:0") + return listen("tcp6", "[::1]:0") } case "tcp4": if supportsIPv4() { - return Listen("tcp4", "127.0.0.1:0") + return listen("tcp4", "127.0.0.1:0") } case "tcp6": if supportsIPv6() { - return Listen("tcp6", "[::1]:0") + return listen("tcp6", "[::1]:0") } case "unix", "unixpacket": - return Listen(network, testUnixAddr()) + return listen(network, testUnixAddr()) } - return nil, fmt.Errorf("%s is not supported", network) + + t.Helper() + t.Fatalf("%s is not supported", network) + return nil } func newDualStackListener() (lns []*TCPListener, err error) { @@ -119,12 +135,10 @@ func (ls *localServer) teardown() error { return nil } -func newLocalServer(network string) (*localServer, error) { - ln, err := newLocalListener(network) - if err != nil { - return nil, err - } - return &localServer{Listener: ln, done: make(chan bool)}, nil +func newLocalServer(t testing.TB, network string) *localServer { + t.Helper() + ln := newLocalListener(t, network) + return &localServer{Listener: ln, done: make(chan bool)} } type streamListener struct { @@ -133,8 +147,8 @@ type streamListener struct { done chan bool // signal that indicates server stopped } -func (sl *streamListener) newLocalServer() (*localServer, error) { - return &localServer{Listener: sl.Listener, done: make(chan bool)}, nil +func (sl *streamListener) newLocalServer() *localServer { + return &localServer{Listener: sl.Listener, done: make(chan bool)} } type dualStackServer struct { @@ -286,27 +300,39 @@ func transceiver(c Conn, wb []byte, ch chan<- error) { } } -func newLocalPacketListener(network string) (PacketConn, error) { +func newLocalPacketListener(t testing.TB, network string) PacketConn { + listenPacket := func(net, addr string) PacketConn { + c, err := ListenPacket(net, addr) + if err != nil { + t.Helper() + t.Fatal(err) + } + return c + } + switch network { case "udp": if supportsIPv4() { - return ListenPacket("udp4", "127.0.0.1:0") + return listenPacket("udp4", "127.0.0.1:0") } if supportsIPv6() { - return ListenPacket("udp6", "[::1]:0") + return listenPacket("udp6", "[::1]:0") } case "udp4": if supportsIPv4() { - return ListenPacket("udp4", "127.0.0.1:0") + return listenPacket("udp4", "127.0.0.1:0") } case "udp6": if supportsIPv6() { - return ListenPacket("udp6", "[::1]:0") + return listenPacket("udp6", "[::1]:0") } case "unixgram": - return ListenPacket(network, testUnixAddr()) + return listenPacket(network, testUnixAddr()) } - return nil, fmt.Errorf("%s is not supported", network) + + t.Helper() + t.Fatalf("%s is not supported", network) + return nil } func newDualStackPacketListener() (cs []*UDPConn, err error) { @@ -371,20 +397,18 @@ func (ls *localPacketServer) teardown() error { return nil } -func newLocalPacketServer(network string) (*localPacketServer, error) { - c, err := newLocalPacketListener(network) - if err != nil { - return nil, err - } - return &localPacketServer{PacketConn: c, done: make(chan bool)}, nil +func newLocalPacketServer(t testing.TB, network string) *localPacketServer { + t.Helper() + c := newLocalPacketListener(t, network) + return &localPacketServer{PacketConn: c, done: make(chan bool)} } type packetListener struct { PacketConn } -func (pl *packetListener) newLocalServer() (*localPacketServer, error) { - return &localPacketServer{PacketConn: pl.PacketConn, done: make(chan bool)}, nil +func (pl *packetListener) newLocalServer() *localPacketServer { + return &localPacketServer{PacketConn: pl.PacketConn, done: make(chan bool)} } func packetTransponder(c PacketConn, ch chan<- error) { diff --git a/src/net/net_test.go b/src/net/net_test.go index 5d9c3c67e6..7b169916f1 100644 --- a/src/net/net_test.go +++ b/src/net/net_test.go @@ -33,10 +33,7 @@ func TestCloseRead(t *testing.T) { } t.Parallel() - ln, err := newLocalListener(network) - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, network) switch network { case "unix", "unixpacket": defer os.Remove(ln.Addr().String()) @@ -132,10 +129,7 @@ func TestCloseWrite(t *testing.T) { } } - ls, err := newLocalServer(network) - if err != nil { - t.Fatal(err) - } + ls := newLocalServer(t, network) defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) @@ -189,10 +183,7 @@ func TestConnClose(t *testing.T) { } t.Parallel() - ln, err := newLocalListener(network) - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, network) switch network { case "unix", "unixpacket": defer os.Remove(ln.Addr().String()) @@ -234,10 +225,7 @@ func TestListenerClose(t *testing.T) { } t.Parallel() - ln, err := newLocalListener(network) - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, network) switch network { case "unix", "unixpacket": defer os.Remove(ln.Addr().String()) @@ -275,10 +263,7 @@ func TestPacketConnClose(t *testing.T) { } t.Parallel() - c, err := newLocalPacketListener(network) - if err != nil { - t.Fatal(err) - } + c := newLocalPacketListener(t, network) switch network { case "unixgram": defer os.Remove(c.LocalAddr().String()) @@ -303,18 +288,17 @@ func TestPacketConnClose(t *testing.T) { func TestListenCloseListen(t *testing.T) { const maxTries = 10 for tries := 0; tries < maxTries; tries++ { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") addr := ln.Addr().String() + // TODO: This is racy. The selected address could be reused in between this + // Close and the subsequent Listen. if err := ln.Close(); err != nil { if perr := parseCloseError(err, false); perr != nil { t.Error(perr) } t.Fatal(err) } - ln, err = Listen("tcp", addr) + ln, err := Listen("tcp", addr) if err == nil { // Success. (This test didn't always make it here earlier.) ln.Close() @@ -360,10 +344,7 @@ func TestAcceptIgnoreAbortedConnRequest(t *testing.T) { } c.Close() } - ls, err := newLocalServer("tcp") - if err != nil { - t.Fatal(err) - } + ls := newLocalServer(t, "tcp") defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) @@ -390,10 +371,7 @@ func TestZeroByteRead(t *testing.T) { } t.Parallel() - ln, err := newLocalListener(network) - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, network) connc := make(chan Conn, 1) go func() { defer ln.Close() @@ -442,10 +420,7 @@ func TestZeroByteRead(t *testing.T) { // runs peer1 and peer2 concurrently. withTCPConnPair returns when // both have completed. func withTCPConnPair(t *testing.T, peer1, peer2 func(c *TCPConn) error) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() errc := make(chan error, 2) go func() { diff --git a/src/net/protoconn_test.go b/src/net/protoconn_test.go index 9f7d8ee4ef..baf3ac6679 100644 --- a/src/net/protoconn_test.go +++ b/src/net/protoconn_test.go @@ -73,10 +73,7 @@ func TestTCPConnSpecificMethods(t *testing.T) { } ch := make(chan error, 1) handler := func(ls *localServer, ln Listener) { ls.transponder(ls.Listener, ch) } - ls, err := (&streamListener{Listener: ln}).newLocalServer() - if err != nil { - t.Fatal(err) - } + ls := (&streamListener{Listener: ln}).newLocalServer() defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) diff --git a/src/net/rawconn_test.go b/src/net/rawconn_test.go index 645d82a1a6..d1ef79d715 100644 --- a/src/net/rawconn_test.go +++ b/src/net/rawconn_test.go @@ -64,10 +64,7 @@ func TestRawConnReadWrite(t *testing.T) { return } } - ls, err := newLocalServer("tcp") - if err != nil { - t.Fatal(err) - } + ls := newLocalServer(t, "tcp") defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) @@ -102,10 +99,7 @@ func TestRawConnReadWrite(t *testing.T) { t.Skipf("not supported on %s", runtime.GOOS) } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() c, err := Dial(ln.Addr().Network(), ln.Addr().String()) @@ -180,10 +174,7 @@ func TestRawConnControl(t *testing.T) { } t.Run("TCP", func(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() cc1, err := ln.(*TCPListener).SyscallConn() diff --git a/src/net/sendfile_test.go b/src/net/sendfile_test.go index 492333d0c8..6edfb67dd7 100644 --- a/src/net/sendfile_test.go +++ b/src/net/sendfile_test.go @@ -27,10 +27,7 @@ const ( ) func TestSendfile(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() errc := make(chan error, 1) @@ -97,10 +94,7 @@ func TestSendfile(t *testing.T) { } func TestSendfileParts(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() errc := make(chan error, 1) @@ -155,10 +149,7 @@ func TestSendfileParts(t *testing.T) { } func TestSendfileSeeked(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() const seekTo = 65 << 10 @@ -225,10 +216,7 @@ func TestSendfilePipe(t *testing.T) { t.Parallel() - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() r, w, err := os.Pipe() @@ -317,10 +305,7 @@ func TestSendfilePipe(t *testing.T) { // 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) - } + ln := newLocalListener(t, "tcp") defer ln.Close() errc := make(chan error, 1) diff --git a/src/net/server_test.go b/src/net/server_test.go index ae1c1619ed..be12c1a12d 100644 --- a/src/net/server_test.go +++ b/src/net/server_test.go @@ -77,10 +77,7 @@ func TestTCPServer(t *testing.T) { } }() for i := 0; i < N; i++ { - ls, err := (&streamListener{Listener: ln}).newLocalServer() - if err != nil { - t.Fatal(err) - } + ls := (&streamListener{Listener: ln}).newLocalServer() lss = append(lss, ls) tpchs = append(tpchs, make(chan error, 1)) } @@ -162,10 +159,7 @@ func TestUnixAndUnixpacketServer(t *testing.T) { } }() for i := 0; i < N; i++ { - ls, err := (&streamListener{Listener: ln}).newLocalServer() - if err != nil { - t.Fatal(err) - } + ls := (&streamListener{Listener: ln}).newLocalServer() lss = append(lss, ls) tpchs = append(tpchs, make(chan error, 1)) } @@ -270,10 +264,7 @@ func TestUDPServer(t *testing.T) { t.Fatal(err) } - ls, err := (&packetListener{PacketConn: c1}).newLocalServer() - if err != nil { - t.Fatal(err) - } + ls := (&packetListener{PacketConn: c1}).newLocalServer() defer ls.teardown() tpch := make(chan error, 1) handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, tpch) } @@ -348,10 +339,7 @@ func TestUnixgramServer(t *testing.T) { t.Fatal(err) } - ls, err := (&packetListener{PacketConn: c1}).newLocalServer() - if err != nil { - t.Fatal(err) - } + ls := (&packetListener{PacketConn: c1}).newLocalServer() defer ls.teardown() tpch := make(chan error, 1) handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, tpch) } diff --git a/src/net/splice_test.go b/src/net/splice_test.go index 43e0b926f7..38d51451b6 100644 --- a/src/net/splice_test.go +++ b/src/net/splice_test.go @@ -46,20 +46,14 @@ type spliceTestCase struct { } func (tc spliceTestCase) test(t *testing.T) { - clientUp, serverUp, err := spliceTestSocketPair(tc.upNet) - if err != nil { - t.Fatal(err) - } + clientUp, serverUp := spliceTestSocketPair(t, tc.upNet) defer serverUp.Close() cleanup, err := startSpliceClient(clientUp, "w", tc.chunkSize, tc.totalSize) if err != nil { t.Fatal(err) } defer cleanup() - clientDown, serverDown, err := spliceTestSocketPair(tc.downNet) - if err != nil { - t.Fatal(err) - } + clientDown, serverDown := spliceTestSocketPair(t, tc.downNet) defer serverDown.Close() cleanup, err = startSpliceClient(clientDown, "r", tc.chunkSize, tc.totalSize) if err != nil { @@ -103,15 +97,9 @@ func (tc spliceTestCase) test(t *testing.T) { } func testSpliceReaderAtEOF(t *testing.T, upNet, downNet string) { - clientUp, serverUp, err := spliceTestSocketPair(upNet) - if err != nil { - t.Fatal(err) - } + clientUp, serverUp := spliceTestSocketPair(t, upNet) defer clientUp.Close() - clientDown, serverDown, err := spliceTestSocketPair(downNet) - if err != nil { - t.Fatal(err) - } + clientDown, serverDown := spliceTestSocketPair(t, downNet) defer clientDown.Close() serverUp.Close() @@ -140,7 +128,7 @@ func testSpliceReaderAtEOF(t *testing.T, upNet, downNet string) { }() buf := make([]byte, 3) - _, err = io.ReadFull(clientDown, buf) + _, err := io.ReadFull(clientDown, buf) if err != nil { t.Errorf("clientDown: %v", err) } @@ -150,15 +138,9 @@ func testSpliceReaderAtEOF(t *testing.T, upNet, downNet string) { } func testSpliceIssue25985(t *testing.T, upNet, downNet string) { - front, err := newLocalListener(upNet) - if err != nil { - t.Fatal(err) - } + front := newLocalListener(t, upNet) defer front.Close() - back, err := newLocalListener(downNet) - if err != nil { - t.Fatal(err) - } + back := newLocalListener(t, downNet) defer back.Close() var wg sync.WaitGroup @@ -210,16 +192,10 @@ func testSpliceIssue25985(t *testing.T, upNet, downNet string) { } func testSpliceNoUnixpacket(t *testing.T) { - clientUp, serverUp, err := spliceTestSocketPair("unixpacket") - if err != nil { - t.Fatal(err) - } + clientUp, serverUp := spliceTestSocketPair(t, "unixpacket") defer clientUp.Close() defer serverUp.Close() - clientDown, serverDown, err := spliceTestSocketPair("tcp") - if err != nil { - t.Fatal(err) - } + clientDown, serverDown := spliceTestSocketPair(t, "tcp") defer clientDown.Close() defer serverDown.Close() // If splice called poll.Splice here, we'd get err == syscall.EINVAL @@ -247,10 +223,7 @@ func testSpliceNoUnixgram(t *testing.T) { t.Fatal(err) } defer up.Close() - clientDown, serverDown, err := spliceTestSocketPair("tcp") - if err != nil { - t.Fatal(err) - } + clientDown, serverDown := spliceTestSocketPair(t, "tcp") defer clientDown.Close() defer serverDown.Close() // Analogous to testSpliceNoUnixpacket. @@ -284,10 +257,7 @@ func (tc spliceTestCase) bench(b *testing.B) { // To benchmark the genericReadFrom code path, set this to false. useSplice := true - clientUp, serverUp, err := spliceTestSocketPair(tc.upNet) - if err != nil { - b.Fatal(err) - } + clientUp, serverUp := spliceTestSocketPair(b, tc.upNet) defer serverUp.Close() cleanup, err := startSpliceClient(clientUp, "w", tc.chunkSize, tc.chunkSize*b.N) @@ -296,10 +266,7 @@ func (tc spliceTestCase) bench(b *testing.B) { } defer cleanup() - clientDown, serverDown, err := spliceTestSocketPair(tc.downNet) - if err != nil { - b.Fatal(err) - } + clientDown, serverDown := spliceTestSocketPair(b, tc.downNet) defer serverDown.Close() cleanup, err = startSpliceClient(clientDown, "r", tc.chunkSize, tc.chunkSize*b.N) @@ -327,11 +294,9 @@ func (tc spliceTestCase) bench(b *testing.B) { } } -func spliceTestSocketPair(net string) (client, server Conn, err error) { - ln, err := newLocalListener(net) - if err != nil { - return nil, nil, err - } +func spliceTestSocketPair(t testing.TB, net string) (client, server Conn) { + t.Helper() + ln := newLocalListener(t, net) defer ln.Close() var cerr, serr error acceptDone := make(chan struct{}) @@ -345,15 +310,15 @@ func spliceTestSocketPair(net string) (client, server Conn, err error) { if server != nil { server.Close() } - return nil, nil, cerr + t.Fatal(cerr) } if serr != nil { if client != nil { client.Close() } - return nil, nil, serr + t.Fatal(serr) } - return client, server, nil + return client, server } func startSpliceClient(conn Conn, op string, chunkSize, totalSize int) (func(), error) { diff --git a/src/net/tcpsock_test.go b/src/net/tcpsock_test.go index fdf5c330a9..ae65788a73 100644 --- a/src/net/tcpsock_test.go +++ b/src/net/tcpsock_test.go @@ -387,10 +387,7 @@ func TestIPv6LinkLocalUnicastTCP(t *testing.T) { t.Log(err) continue } - ls, err := (&streamListener{Listener: ln}).newLocalServer() - if err != nil { - t.Fatal(err) - } + ls := (&streamListener{Listener: ln}).newLocalServer() defer ls.teardown() ch := make(chan error, 1) handler := func(ls *localServer, ln Listener) { ls.transponder(ln, ch) } @@ -626,10 +623,7 @@ func TestTCPSelfConnect(t *testing.T) { t.Skip("known-broken test on windows") } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") var d Dialer c, err := d.Dial(ln.Addr().Network(), ln.Addr().String()) if err != nil { @@ -676,10 +670,7 @@ func TestTCPBig(t *testing.T) { for _, writev := range []bool{false, true} { t.Run(fmt.Sprintf("writev=%v", writev), func(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() x := int(1 << 30) @@ -723,10 +714,7 @@ func TestTCPBig(t *testing.T) { } func TestCopyPipeIntoTCP(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() errc := make(chan error, 1) @@ -794,10 +782,7 @@ func TestCopyPipeIntoTCP(t *testing.T) { } func BenchmarkSetReadDeadline(b *testing.B) { - ln, err := newLocalListener("tcp") - if err != nil { - b.Fatal(err) - } + ln := newLocalListener(b, "tcp") defer ln.Close() var serv Conn done := make(chan error) diff --git a/src/net/tcpsock_unix_test.go b/src/net/tcpsock_unix_test.go index b1f2876d4e..b14670bc67 100644 --- a/src/net/tcpsock_unix_test.go +++ b/src/net/tcpsock_unix_test.go @@ -22,10 +22,7 @@ func TestTCPSpuriousConnSetupCompletion(t *testing.T) { t.Skip("skipping in short mode") } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") var wg sync.WaitGroup wg.Add(1) go func(ln Listener) { diff --git a/src/net/timeout_test.go b/src/net/timeout_test.go index 515aa07ec3..cd6b953747 100644 --- a/src/net/timeout_test.go +++ b/src/net/timeout_test.go @@ -93,10 +93,7 @@ func TestDialTimeout(t *testing.T) { } func TestDialTimeoutMaxDuration(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer func() { if err := ln.Close(); err != nil { t.Error(err) @@ -147,10 +144,7 @@ func TestAcceptTimeout(t *testing.T) { t.Skipf("not supported on %s", runtime.GOOS) } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() var wg sync.WaitGroup @@ -203,10 +197,7 @@ func TestAcceptTimeoutMustReturn(t *testing.T) { t.Skipf("not supported on %s", runtime.GOOS) } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() max := time.NewTimer(time.Second) @@ -249,10 +240,7 @@ func TestAcceptTimeoutMustNotReturn(t *testing.T) { t.Skipf("not supported on %s", runtime.GOOS) } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() max := time.NewTimer(100 * time.Millisecond) @@ -302,10 +290,7 @@ func TestReadTimeout(t *testing.T) { c.Write([]byte("READ TIMEOUT TEST")) defer c.Close() } - ls, err := newLocalServer("tcp") - if err != nil { - t.Fatal(err) - } + ls := newLocalServer(t, "tcp") defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) @@ -354,10 +339,7 @@ func TestReadTimeoutMustNotReturn(t *testing.T) { t.Skipf("not supported on %s", runtime.GOOS) } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() c, err := Dial(ln.Addr().Network(), ln.Addr().String()) @@ -421,10 +403,7 @@ func TestReadFromTimeout(t *testing.T) { c.WriteTo([]byte("READFROM TIMEOUT TEST"), dst) } } - ls, err := newLocalPacketServer("udp") - if err != nil { - t.Fatal(err) - } + ls := newLocalPacketServer(t, "udp") defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) @@ -484,10 +463,7 @@ var writeTimeoutTests = []struct { func TestWriteTimeout(t *testing.T) { t.Parallel() - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() for i, tt := range writeTimeoutTests { @@ -532,10 +508,7 @@ func TestWriteTimeoutMustNotReturn(t *testing.T) { t.Skipf("not supported on %s", runtime.GOOS) } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() c, err := Dial(ln.Addr().Network(), ln.Addr().String()) @@ -598,10 +571,7 @@ var writeToTimeoutTests = []struct { func TestWriteToTimeout(t *testing.T) { t.Parallel() - c1, err := newLocalPacketListener("udp") - if err != nil { - t.Fatal(err) - } + c1 := newLocalPacketListener(t, "udp") defer c1.Close() host, _, err := SplitHostPort(c1.LocalAddr().String()) @@ -687,10 +657,7 @@ func nextTimeout(actual time.Duration) (next time.Duration, ok bool) { } func TestReadTimeoutFluctuation(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() c, err := Dial(ln.Addr().Network(), ln.Addr().String()) @@ -746,10 +713,7 @@ func TestReadTimeoutFluctuation(t *testing.T) { } func TestReadFromTimeoutFluctuation(t *testing.T) { - c1, err := newLocalPacketListener("udp") - if err != nil { - t.Fatal(err) - } + c1 := newLocalPacketListener(t, "udp") defer c1.Close() c2, err := Dial(c1.LocalAddr().Network(), c1.LocalAddr().String()) @@ -810,10 +774,7 @@ func TestWriteTimeoutFluctuation(t *testing.T) { t.Skipf("not supported on %s", runtime.GOOS) } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() c, err := Dial(ln.Addr().Network(), ln.Addr().String()) @@ -938,10 +899,7 @@ func testVariousDeadlines(t *testing.T) { c.Close() } } - ls, err := newLocalServer("tcp") - if err != nil { - t.Fatal(err) - } + ls := newLocalServer(t, "tcp") defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) @@ -1073,10 +1031,7 @@ func TestReadWriteProlongedTimeout(t *testing.T) { }() wg.Wait() } - ls, err := newLocalServer("tcp") - if err != nil { - t.Fatal(err) - } + ls := newLocalServer(t, "tcp") defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) @@ -1103,10 +1058,7 @@ func TestReadWriteDeadlineRace(t *testing.T) { N = 50 } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() c, err := Dial(ln.Addr().Network(), ln.Addr().String()) @@ -1156,10 +1108,7 @@ func TestReadWriteDeadlineRace(t *testing.T) { // Issue 35367. func TestConcurrentSetDeadline(t *testing.T) { - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() const goroutines = 8 @@ -1168,6 +1117,7 @@ func TestConcurrentSetDeadline(t *testing.T) { var c [conns]Conn for i := 0; i < conns; i++ { + var err error c[i], err = Dial(ln.Addr().Network(), ln.Addr().String()) if err != nil { t.Fatal(err) diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go index 8ccdb365ab..6f82554e56 100644 --- a/src/net/udpsock_test.go +++ b/src/net/udpsock_test.go @@ -285,10 +285,7 @@ func TestIPv6LinkLocalUnicastUDP(t *testing.T) { t.Log(err) continue } - ls, err := (&packetListener{PacketConn: c1}).newLocalServer() - if err != nil { - t.Fatal(err) - } + ls := (&packetListener{PacketConn: c1}).newLocalServer() defer ls.teardown() ch := make(chan error, 1) handler := func(ls *localPacketServer, c PacketConn) { packetTransponder(c, ch) } @@ -333,10 +330,7 @@ func TestUDPZeroBytePayload(t *testing.T) { testenv.SkipFlaky(t, 29225) } - c, err := newLocalPacketListener("udp") - if err != nil { - t.Fatal(err) - } + c := newLocalPacketListener(t, "udp") defer c.Close() for _, genericRead := range []bool{false, true} { @@ -369,10 +363,7 @@ func TestUDPZeroByteBuffer(t *testing.T) { t.Skipf("not supported on %s", runtime.GOOS) } - c, err := newLocalPacketListener("udp") - if err != nil { - t.Fatal(err) - } + c := newLocalPacketListener(t, "udp") defer c.Close() b := []byte("UDP ZERO BYTE BUFFER TEST") @@ -406,10 +397,7 @@ func TestUDPReadSizeError(t *testing.T) { t.Skipf("not supported on %s", runtime.GOOS) } - c1, err := newLocalPacketListener("udp") - if err != nil { - t.Fatal(err) - } + c1 := newLocalPacketListener(t, "udp") defer c1.Close() c2, err := Dial("udp", c1.LocalAddr().String()) diff --git a/src/net/unixsock_test.go b/src/net/unixsock_test.go index a75578235f..5ad20a0151 100644 --- a/src/net/unixsock_test.go +++ b/src/net/unixsock_test.go @@ -76,10 +76,7 @@ func TestUnixgramZeroBytePayload(t *testing.T) { t.Skip("unixgram test") } - c1, err := newLocalPacketListener("unixgram") - if err != nil { - t.Fatal(err) - } + c1 := newLocalPacketListener(t, "unixgram") defer os.Remove(c1.LocalAddr().String()) defer c1.Close() @@ -126,10 +123,7 @@ func TestUnixgramZeroByteBuffer(t *testing.T) { // issue 4352: Recvfrom failed with "address family not // supported by protocol family" if zero-length buffer provided - c1, err := newLocalPacketListener("unixgram") - if err != nil { - t.Fatal(err) - } + c1 := newLocalPacketListener(t, "unixgram") defer os.Remove(c1.LocalAddr().String()) defer c1.Close() @@ -259,10 +253,7 @@ func TestUnixConnLocalAndRemoteNames(t *testing.T) { if err != nil { t.Fatal(err) } - ls, err := (&streamListener{Listener: ln}).newLocalServer() - if err != nil { - t.Fatal(err) - } + ls := (&streamListener{Listener: ln}).newLocalServer() defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) diff --git a/src/net/unixsock_windows_test.go b/src/net/unixsock_windows_test.go index dedd761c56..e847a20de0 100644 --- a/src/net/unixsock_windows_test.go +++ b/src/net/unixsock_windows_test.go @@ -56,10 +56,7 @@ func TestUnixConnLocalWindows(t *testing.T) { if err != nil { t.Fatal(err) } - ls, err := (&streamListener{Listener: ln}).newLocalServer() - if err != nil { - t.Fatal(err) - } + ls := (&streamListener{Listener: ln}).newLocalServer() defer ls.teardown() if err := ls.buildup(handler); err != nil { t.Fatal(err) diff --git a/src/net/writev_test.go b/src/net/writev_test.go index b752295862..18795a457a 100644 --- a/src/net/writev_test.go +++ b/src/net/writev_test.go @@ -186,10 +186,7 @@ func TestWritevError(t *testing.T) { t.Skipf("skipping the test: windows does not have problem sending large chunks of data") } - ln, err := newLocalListener("tcp") - if err != nil { - t.Fatal(err) - } + ln := newLocalListener(t, "tcp") defer ln.Close() ch := make(chan Conn, 1) From 4b3d8d1a390a51ea6a1b3f66ef9d56ef7203bbe7 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Thu, 9 Dec 2021 11:55:20 -0500 Subject: [PATCH 468/752] net: create unix sockets in unique directories MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change applies the same transformation as in CL 366774, but to the net package. testUnixAddr was using os.CreateTemp to obtain a unique socket path, but then calling os.Remove on that path immediately. Since the existence of the file is what guarantees its uniqueness, that could occasionally result in testUnixAddr returning the same path for two calls, causing the tests using those paths to fail — especially if they are the same test or are run in parallel. Instead, we now create a unique, short temp directory for each call, and use a path within that directory for the socket address. For #34611 Change-Id: I8e13b606abce2479a0305f7aeecf5d54c449a032 Reviewed-on: https://go-review.googlesource.com/c/go/+/370694 Trust: Bryan Mills Reviewed-by: Ian Lance Taylor Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot --- src/net/mockserver_test.go | 26 ++++++++++++-------- src/net/packetconn_test.go | 27 +++++++++++++------- src/net/protoconn_test.go | 4 +-- src/net/server_test.go | 42 ++++++++++++++++---------------- src/net/splice_test.go | 2 +- src/net/unixsock_test.go | 16 ++++++------ src/net/unixsock_windows_test.go | 4 +-- 7 files changed, 68 insertions(+), 53 deletions(-) diff --git a/src/net/mockserver_test.go b/src/net/mockserver_test.go index 0868871b7b..186bd330b2 100644 --- a/src/net/mockserver_test.go +++ b/src/net/mockserver_test.go @@ -10,21 +10,27 @@ import ( "errors" "fmt" "os" + "path/filepath" "sync" "testing" "time" ) -// testUnixAddr uses os.CreateTemp to get a name that is unique. -func testUnixAddr() string { - f, err := os.CreateTemp("", "go-nettest") +// testUnixAddr uses os.MkdirTemp to get a name that is unique. +func testUnixAddr(t testing.TB) string { + // Pass an empty pattern to get a directory name that is as short as possible. + // If we end up with a name longer than the sun_path field in the sockaddr_un + // struct, we won't be able to make the syscall to open the socket. + d, err := os.MkdirTemp("", "") if err != nil { - panic(err) + t.Fatal(err) } - addr := f.Name() - f.Close() - os.Remove(addr) - return addr + t.Cleanup(func() { + if err := os.RemoveAll(d); err != nil { + t.Error(err) + } + }) + return filepath.Join(d, "sock") } func newLocalListener(t testing.TB, network string) Listener { @@ -59,7 +65,7 @@ func newLocalListener(t testing.TB, network string) Listener { return listen("tcp6", "[::1]:0") } case "unix", "unixpacket": - return listen(network, testUnixAddr()) + return listen(network, testUnixAddr(t)) } t.Helper() @@ -327,7 +333,7 @@ func newLocalPacketListener(t testing.TB, network string) PacketConn { return listenPacket("udp6", "[::1]:0") } case "unixgram": - return listenPacket(network, testUnixAddr()) + return listenPacket(network, testUnixAddr(t)) } t.Helper() diff --git a/src/net/packetconn_test.go b/src/net/packetconn_test.go index 487912efab..fa160df5f5 100644 --- a/src/net/packetconn_test.go +++ b/src/net/packetconn_test.go @@ -27,16 +27,16 @@ func packetConnTestData(t *testing.T, network string) ([]byte, func()) { return []byte("PACKETCONN TEST"), nil } -var packetConnTests = []struct { - net string - addr1 string - addr2 string -}{ - {"udp", "127.0.0.1:0", "127.0.0.1:0"}, - {"unixgram", testUnixAddr(), testUnixAddr()}, -} - func TestPacketConn(t *testing.T) { + var packetConnTests = []struct { + net string + addr1 string + addr2 string + }{ + {"udp", "127.0.0.1:0", "127.0.0.1:0"}, + {"unixgram", testUnixAddr(t), testUnixAddr(t)}, + } + closer := func(c PacketConn, net, addr1, addr2 string) { c.Close() switch net { @@ -85,6 +85,15 @@ func TestPacketConn(t *testing.T) { } func TestConnAndPacketConn(t *testing.T) { + var packetConnTests = []struct { + net string + addr1 string + addr2 string + }{ + {"udp", "127.0.0.1:0", "127.0.0.1:0"}, + {"unixgram", testUnixAddr(t), testUnixAddr(t)}, + } + closer := func(c PacketConn, net, addr1, addr2 string) { c.Close() switch net { diff --git a/src/net/protoconn_test.go b/src/net/protoconn_test.go index baf3ac6679..e4198a3a05 100644 --- a/src/net/protoconn_test.go +++ b/src/net/protoconn_test.go @@ -204,7 +204,7 @@ func TestUnixListenerSpecificMethods(t *testing.T) { t.Skip("unix test") } - addr := testUnixAddr() + addr := testUnixAddr(t) la, err := ResolveUnixAddr("unix", addr) if err != nil { t.Fatal(err) @@ -245,7 +245,7 @@ func TestUnixConnSpecificMethods(t *testing.T) { t.Skip("unixgram test") } - addr1, addr2, addr3 := testUnixAddr(), testUnixAddr(), testUnixAddr() + addr1, addr2, addr3 := testUnixAddr(t), testUnixAddr(t), testUnixAddr(t) a1, err := ResolveUnixAddr("unixgram", addr1) if err != nil { diff --git a/src/net/server_test.go b/src/net/server_test.go index be12c1a12d..6796d7993e 100644 --- a/src/net/server_test.go +++ b/src/net/server_test.go @@ -122,19 +122,19 @@ func TestTCPServer(t *testing.T) { } } -var unixAndUnixpacketServerTests = []struct { - network, address string -}{ - {"unix", testUnixAddr()}, - {"unix", "@nettest/go/unix"}, - - {"unixpacket", testUnixAddr()}, - {"unixpacket", "@nettest/go/unixpacket"}, -} - // TestUnixAndUnixpacketServer tests concurrent accept-read-write // servers func TestUnixAndUnixpacketServer(t *testing.T) { + var unixAndUnixpacketServerTests = []struct { + network, address string + }{ + {"unix", testUnixAddr(t)}, + {"unix", "@nettest/go/unix"}, + + {"unixpacket", testUnixAddr(t)}, + {"unixpacket", "@nettest/go/unixpacket"}, + } + const N = 3 for i, tt := range unixAndUnixpacketServerTests { @@ -313,18 +313,18 @@ func TestUDPServer(t *testing.T) { } } -var unixgramServerTests = []struct { - saddr string // server endpoint - caddr string // client endpoint - dial bool // test with Dial -}{ - {saddr: testUnixAddr(), caddr: testUnixAddr()}, - {saddr: testUnixAddr(), caddr: testUnixAddr(), dial: true}, - - {saddr: "@nettest/go/unixgram/server", caddr: "@nettest/go/unixgram/client"}, -} - func TestUnixgramServer(t *testing.T) { + var unixgramServerTests = []struct { + saddr string // server endpoint + caddr string // client endpoint + dial bool // test with Dial + }{ + {saddr: testUnixAddr(t), caddr: testUnixAddr(t)}, + {saddr: testUnixAddr(t), caddr: testUnixAddr(t), dial: true}, + + {saddr: "@nettest/go/unixgram/server", caddr: "@nettest/go/unixgram/client"}, + } + for i, tt := range unixgramServerTests { if !testableListenArgs("unixgram", tt.saddr, "") { t.Logf("skipping %s test", "unixgram "+tt.saddr+"<-"+tt.caddr) diff --git a/src/net/splice_test.go b/src/net/splice_test.go index 38d51451b6..fa14c95eb7 100644 --- a/src/net/splice_test.go +++ b/src/net/splice_test.go @@ -213,7 +213,7 @@ func testSpliceNoUnixpacket(t *testing.T) { } func testSpliceNoUnixgram(t *testing.T) { - addr, err := ResolveUnixAddr("unixgram", testUnixAddr()) + addr, err := ResolveUnixAddr("unixgram", testUnixAddr(t)) if err != nil { t.Fatal(err) } diff --git a/src/net/unixsock_test.go b/src/net/unixsock_test.go index 5ad20a0151..2fc9580caf 100644 --- a/src/net/unixsock_test.go +++ b/src/net/unixsock_test.go @@ -25,7 +25,7 @@ func TestReadUnixgramWithUnnamedSocket(t *testing.T) { testenv.SkipFlaky(t, 15157) } - addr := testUnixAddr() + addr := testUnixAddr(t) la, err := ResolveUnixAddr("unixgram", addr) if err != nil { t.Fatal(err) @@ -168,7 +168,7 @@ func TestUnixgramWrite(t *testing.T) { t.Skip("unixgram test") } - addr := testUnixAddr() + addr := testUnixAddr(t) laddr, err := ResolveUnixAddr("unixgram", addr) if err != nil { t.Fatal(err) @@ -213,7 +213,7 @@ func testUnixgramWriteConn(t *testing.T, raddr *UnixAddr) { } func testUnixgramWritePacketConn(t *testing.T, raddr *UnixAddr) { - addr := testUnixAddr() + addr := testUnixAddr(t) c, err := ListenPacket("unixgram", addr) if err != nil { t.Fatal(err) @@ -242,9 +242,9 @@ func TestUnixConnLocalAndRemoteNames(t *testing.T) { } handler := func(ls *localServer, ln Listener) {} - for _, laddr := range []string{"", testUnixAddr()} { + for _, laddr := range []string{"", testUnixAddr(t)} { laddr := laddr - taddr := testUnixAddr() + taddr := testUnixAddr(t) ta, err := ResolveUnixAddr("unix", taddr) if err != nil { t.Fatal(err) @@ -301,9 +301,9 @@ func TestUnixgramConnLocalAndRemoteNames(t *testing.T) { t.Skip("unixgram test") } - for _, laddr := range []string{"", testUnixAddr()} { + for _, laddr := range []string{"", testUnixAddr(t)} { laddr := laddr - taddr := testUnixAddr() + taddr := testUnixAddr(t) ta, err := ResolveUnixAddr("unixgram", taddr) if err != nil { t.Fatal(err) @@ -359,7 +359,7 @@ func TestUnixUnlink(t *testing.T) { if !testableNetwork("unix") { t.Skip("unix test") } - name := testUnixAddr() + name := testUnixAddr(t) listen := func(t *testing.T) *UnixListener { l, err := Listen("unix", name) diff --git a/src/net/unixsock_windows_test.go b/src/net/unixsock_windows_test.go index e847a20de0..d541d89f78 100644 --- a/src/net/unixsock_windows_test.go +++ b/src/net/unixsock_windows_test.go @@ -45,9 +45,9 @@ func TestUnixConnLocalWindows(t *testing.T) { } handler := func(ls *localServer, ln Listener) {} - for _, laddr := range []string{"", testUnixAddr()} { + for _, laddr := range []string{"", testUnixAddr(t)} { laddr := laddr - taddr := testUnixAddr() + taddr := testUnixAddr(t) ta, err := ResolveUnixAddr("unix", taddr) if err != nil { t.Fatal(err) From acc65b47e12e2ba061b8ab4f86b183d039072776 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 10 Dec 2021 14:13:52 -0500 Subject: [PATCH 469/752] net: refactor TestWriteToTimeout The test cases for this test had listed specific errors, but the specific error values were ignored in favor of just calling isDeadlineExceeded. Moreover, ENOBUFS errors (which can legitimately occur in the test if the network interface also happens to be saturated when the timeout occurs) were not handled at all. Now the test relies only on the timeout: we iterate until we have seen two of the expected timeout errors, and if we see ENOBUFS instead of "deadline exceeded" we back off to give the queues time to drain. Fixes #49930 Change-Id: I258a6d5c935d9635b02dffd79e197ba9caf83ac8 Reviewed-on: https://go-review.googlesource.com/c/go/+/370882 Trust: Bryan Mills Reviewed-by: Ian Lance Taylor Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot --- src/net/error_plan9_test.go | 4 ++ src/net/error_unix_test.go | 5 +++ src/net/error_windows_test.go | 12 ++++- src/net/timeout_test.go | 82 ++++++++++++++++++++--------------- 4 files changed, 66 insertions(+), 37 deletions(-) diff --git a/src/net/error_plan9_test.go b/src/net/error_plan9_test.go index d7c7f1487f..1270af19e5 100644 --- a/src/net/error_plan9_test.go +++ b/src/net/error_plan9_test.go @@ -17,3 +17,7 @@ func isPlatformError(err error) bool { _, ok := err.(syscall.ErrorString) return ok } + +func isENOBUFS(err error) bool { + return false // ENOBUFS is Unix-specific +} diff --git a/src/net/error_unix_test.go b/src/net/error_unix_test.go index 1334aa86b6..291a7234f2 100644 --- a/src/net/error_unix_test.go +++ b/src/net/error_unix_test.go @@ -7,6 +7,7 @@ package net import ( + "errors" "os" "syscall" ) @@ -32,3 +33,7 @@ func samePlatformError(err, want error) bool { } return err == want } + +func isENOBUFS(err error) bool { + return errors.Is(err, syscall.ENOBUFS) +} diff --git a/src/net/error_windows_test.go b/src/net/error_windows_test.go index 834a9de441..25825f96f8 100644 --- a/src/net/error_windows_test.go +++ b/src/net/error_windows_test.go @@ -4,7 +4,10 @@ package net -import "syscall" +import ( + "errors" + "syscall" +) var ( errTimedout = syscall.ETIMEDOUT @@ -17,3 +20,10 @@ func isPlatformError(err error) bool { _, ok := err.(syscall.Errno) return ok } + +func isENOBUFS(err error) bool { + // syscall.ENOBUFS is a completely made-up value on Windows: we don't expect + // a real system call to ever actually return it. However, since it is already + // defined in the syscall package we may as well check for it. + return errors.Is(err, syscall.ENOBUFS) +} diff --git a/src/net/timeout_test.go b/src/net/timeout_test.go index cd6b953747..032770dd83 100644 --- a/src/net/timeout_test.go +++ b/src/net/timeout_test.go @@ -557,17 +557,6 @@ func TestWriteTimeoutMustNotReturn(t *testing.T) { } } -var writeToTimeoutTests = []struct { - timeout time.Duration - xerrs [2]error // expected errors in transition -}{ - // Tests that write deadlines work, even if there's buffer - // space available to write. - {-5 * time.Second, [2]error{os.ErrDeadlineExceeded, os.ErrDeadlineExceeded}}, - - {10 * time.Millisecond, [2]error{nil, os.ErrDeadlineExceeded}}, -} - func TestWriteToTimeout(t *testing.T) { t.Parallel() @@ -579,37 +568,58 @@ func TestWriteToTimeout(t *testing.T) { t.Fatal(err) } - for i, tt := range writeToTimeoutTests { - c2, err := ListenPacket(c1.LocalAddr().Network(), JoinHostPort(host, "0")) - if err != nil { - t.Fatal(err) - } - defer c2.Close() + timeouts := []time.Duration{ + -5 * time.Second, + 10 * time.Millisecond, + } - if err := c2.SetWriteDeadline(time.Now().Add(tt.timeout)); err != nil { - t.Fatalf("#%d: %v", i, err) - } - for j, xerr := range tt.xerrs { - for { + for _, timeout := range timeouts { + t.Run(fmt.Sprint(timeout), func(t *testing.T) { + c2, err := ListenPacket(c1.LocalAddr().Network(), JoinHostPort(host, "0")) + if err != nil { + t.Fatal(err) + } + defer c2.Close() + + if err := c2.SetWriteDeadline(time.Now().Add(timeout)); err != nil { + t.Fatalf("SetWriteDeadline: %v", err) + } + backoff := 1 * time.Millisecond + nDeadlineExceeded := 0 + for j := 0; nDeadlineExceeded < 2; j++ { n, err := c2.WriteTo([]byte("WRITETO TIMEOUT TEST"), c1.LocalAddr()) - if xerr != nil { - if perr := parseWriteError(err); perr != nil { - t.Errorf("#%d/%d: %v", i, j, perr) - } - if !isDeadlineExceeded(err) { - t.Fatalf("#%d/%d: %v", i, j, err) - } - } - if err == nil { - time.Sleep(tt.timeout / 3) + t.Logf("#%d: WriteTo: %d, %v", j, n, err) + if err == nil && timeout >= 0 && nDeadlineExceeded == 0 { + // If the timeout is nonnegative, some number of WriteTo calls may + // succeed before the timeout takes effect. + t.Logf("WriteTo succeeded; sleeping %v", timeout/3) + time.Sleep(timeout / 3) continue } - if n != 0 { - t.Fatalf("#%d/%d: wrote %d; want 0", i, j, n) + if isENOBUFS(err) { + t.Logf("WriteTo: %v", err) + // We're looking for a deadline exceeded error, but if the kernel's + // network buffers are saturated we may see ENOBUFS instead (see + // https://go.dev/issue/49930). Give it some time to unsaturate. + time.Sleep(backoff) + backoff *= 2 + continue } - break + if perr := parseWriteError(err); perr != nil { + t.Errorf("failed to parse error: %v", perr) + } + if !isDeadlineExceeded(err) { + t.Errorf("error is not 'deadline exceeded'") + } + if n != 0 { + t.Errorf("unexpectedly wrote %d bytes", n) + } + if !t.Failed() { + t.Logf("WriteTo timed out as expected") + } + nDeadlineExceeded++ } - } + }) } } From 083ef5462494e81ee23316245c5d65085a3f62d9 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 10 Dec 2021 15:35:46 -0800 Subject: [PATCH 470/752] spec: fix conversion rules (match implementation) As written, the conversion P(x), where P and the type of x are type parameters with identical underlying types (i.e., identical constraints), is valid. However, unless the type of x and P are identical (which is covered with the assignability rule), such a conversion is not valid in general (consider the case where both type parameters are different type parameters with constraint "any"). This change adjusts the rules to prohibit type parameters in this case. The same reasoning applies and the analogue change is made for pointer types. The type checker already implements these updated rules. Change-Id: Id90187900cb2820f6a0a0cf582cf26cdf8addbce Reviewed-on: https://go-review.googlesource.com/c/go/+/371074 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index 2832b0739d..cb57aa301c 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1,6 +1,6 @@ @@ -4782,14 +4782,16 @@ in any of these cases:

  • x's type and T are both integer or floating From 2580d0e08d5e9f979b943758d3c49877fb2324cb Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Wed, 1 Dec 2021 12:15:45 -0500 Subject: [PATCH 471/752] all: gofmt -w -r 'interface{} -> any' src And then revert the bootstrap cmd directories and certain testdata. And adjust tests as needed. Not reverting the changes in std that are bootstrapped, because some of those changes would appear in API docs, and we want to use any consistently. Instead, rewrite 'any' to 'interface{}' in cmd/dist for those directories when preparing the bootstrap copy. A few files changed as a result of running gofmt -w not because of interface{} -> any but because they hadn't been updated for the new //go:build lines. Fixes #49884. Change-Id: Ie8045cba995f65bd79c694ec77a1b3d1fe01bb09 Reviewed-on: https://go-review.googlesource.com/c/go/+/368254 Trust: Russ Cox Run-TryBot: Russ Cox Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/archive/tar/common.go | 2 +- src/archive/tar/reader_test.go | 4 +- src/archive/tar/tar_test.go | 2 +- src/archive/tar/writer_test.go | 6 +- src/archive/zip/reader.go | 2 +- src/archive/zip/struct.go | 2 +- src/builtin/builtin.go | 4 +- src/bytes/reader_test.go | 2 +- src/cmd/api/goapi.go | 2 +- .../testdata/src/issue21181/p/p_generic.go | 1 + src/cmd/api/testdata/src/pkg/p1/p1.go | 2 +- src/cmd/api/testdata/src/pkg/p4/p4.go | 4 +- .../internal/importer/gcimporter_test.go | 2 +- src/cmd/cover/testdata/test.go | 4 +- src/cmd/dist/buildtool.go | 7 +- src/cmd/doc/pkg.go | 6 +- src/cmd/doc/testdata/nested/ignore.go | 1 + src/cmd/fix/cftype.go | 8 +- src/cmd/fix/fix.go | 8 +- src/cmd/fix/gotypes.go | 2 +- src/cmd/fix/main.go | 2 +- src/cmd/fix/netipv6zone.go | 2 +- src/cmd/fix/printerconfig.go | 2 +- src/cmd/fix/typecheck.go | 12 +- src/cmd/go/internal/base/base.go | 6 +- src/cmd/go/internal/cmdflag/flag.go | 2 +- src/cmd/go/internal/fsys/fsys.go | 6 +- src/cmd/go/internal/generate/generate.go | 2 +- src/cmd/go/internal/help/help.go | 2 +- .../go/internal/imports/testdata/android/e.go | 1 + .../go/internal/imports/testdata/android/f.go | 1 + .../go/internal/imports/testdata/android/g.go | 1 + .../go/internal/imports/testdata/illumos/e.go | 1 + .../go/internal/imports/testdata/illumos/f.go | 1 + .../go/internal/imports/testdata/illumos/g.go | 1 + .../go/internal/imports/testdata/star/x1.go | 7 +- src/cmd/go/internal/list/list.go | 6 +- src/cmd/go/internal/load/pkg.go | 20 +-- src/cmd/go/internal/modcmd/tidy.go | 4 +- src/cmd/go/internal/modfetch/cache.go | 12 +- .../go/internal/modfetch/codehost/codehost.go | 4 +- src/cmd/go/internal/modfetch/codehost/git.go | 4 +- src/cmd/go/internal/modfetch/codehost/vcs.go | 4 +- src/cmd/go/internal/modfetch/coderepo.go | 4 +- src/cmd/go/internal/modfetch/fetch.go | 4 +- src/cmd/go/internal/modfetch/repo.go | 6 +- src/cmd/go/internal/modget/get.go | 4 +- src/cmd/go/internal/modload/buildlist.go | 2 +- src/cmd/go/internal/modload/import.go | 4 +- src/cmd/go/internal/modload/load.go | 4 +- src/cmd/go/internal/modload/modfile.go | 4 +- src/cmd/go/internal/modload/vendor.go | 2 +- src/cmd/go/internal/mvs/mvs.go | 2 +- src/cmd/go/internal/par/work.go | 32 ++-- src/cmd/go/internal/par/work_test.go | 12 +- src/cmd/go/internal/run/run.go | 2 +- src/cmd/go/internal/str/str.go | 2 +- src/cmd/go/internal/vcs/vcs.go | 4 +- src/cmd/go/internal/work/action.go | 8 +- src/cmd/go/internal/work/build_test.go | 2 +- src/cmd/go/internal/work/exec.go | 10 +- src/cmd/go/internal/work/gc.go | 10 +- src/cmd/go/proxy_test.go | 4 +- src/cmd/go/script_test.go | 4 +- src/cmd/go/testdata/addmod.go | 3 +- src/cmd/go/testdata/savedir.go | 1 + .../testterminal18153/terminal_test.go | 1 + src/cmd/gofmt/gofmt.go | 2 +- src/cmd/internal/buildid/buildid_test.go | 2 +- src/cmd/internal/buildid/rewrite.go | 2 +- src/cmd/internal/test2json/test2json_test.go | 2 +- src/cmd/internal/traceviewer/format.go | 28 ++-- src/cmd/nm/nm.go | 2 +- src/cmd/pack/pack_test.go | 4 +- src/cmd/pprof/readlineui.go | 6 +- src/cmd/trace/main.go | 2 +- src/cmd/trace/mmu.go | 2 +- src/cmd/trace/trace.go | 2 +- src/container/heap/example_intheap_test.go | 4 +- src/container/heap/example_pq_test.go | 4 +- src/container/heap/heap.go | 10 +- src/container/heap/heap_test.go | 4 +- src/container/list/list.go | 14 +- src/container/list/list_test.go | 46 +++--- src/container/ring/example_test.go | 8 +- src/container/ring/ring.go | 4 +- src/container/ring/ring_test.go | 2 +- src/context/context.go | 16 +- src/context/context_test.go | 20 +-- src/crypto/crypto.go | 6 +- .../edwards25519/scalar_alias_test.go | 2 +- src/crypto/tls/cipher_suites.go | 8 +- src/crypto/tls/common.go | 2 +- src/crypto/tls/conn.go | 16 +- src/crypto/tls/generate_cert.go | 4 +- src/crypto/tls/handshake_client.go | 2 +- src/crypto/tls/handshake_client_test.go | 4 +- src/crypto/tls/handshake_messages_test.go | 2 +- src/crypto/tls/handshake_server.go | 2 +- src/crypto/tls/handshake_server_test.go | 6 +- src/crypto/x509/name_constraints_test.go | 2 +- src/crypto/x509/parser.go | 2 +- src/crypto/x509/pkcs8.go | 4 +- src/crypto/x509/pkix/pkix.go | 2 +- src/crypto/x509/verify.go | 14 +- src/crypto/x509/x509.go | 20 +-- src/crypto/x509/x509_test.go | 8 +- src/database/sql/convert.go | 14 +- src/database/sql/convert_test.go | 42 +++--- src/database/sql/driver/driver.go | 2 +- src/database/sql/driver/types.go | 18 +-- src/database/sql/driver/types_test.go | 4 +- src/database/sql/fakedb_test.go | 32 ++-- src/database/sql/sql.go | 96 ++++++------ src/database/sql/sql_test.go | 40 ++--- src/debug/dwarf/entry.go | 6 +- src/debug/dwarf/entry_test.go | 2 +- src/debug/elf/elf_test.go | 2 +- src/debug/elf/file.go | 2 +- src/debug/gosym/symtab.go | 2 +- src/debug/macho/file.go | 2 +- src/debug/macho/file_test.go | 12 +- src/debug/pe/file.go | 6 +- src/debug/pe/file_test.go | 4 +- src/debug/plan9obj/file.go | 2 +- src/embed/embed.go | 2 +- src/embed/internal/embedtest/embed_test.go | 2 +- src/encoding/ascii85/ascii85_test.go | 2 +- src/encoding/asn1/asn1.go | 6 +- src/encoding/asn1/asn1_test.go | 10 +- src/encoding/asn1/marshal.go | 4 +- src/encoding/asn1/marshal_test.go | 12 +- src/encoding/base32/base32_test.go | 2 +- src/encoding/base64/base64_test.go | 2 +- src/encoding/binary/binary.go | 8 +- src/encoding/binary/binary_test.go | 16 +- src/encoding/binary/example_test.go | 2 +- src/encoding/gob/codec_test.go | 34 ++--- src/encoding/gob/debug.go | 2 +- src/encoding/gob/decoder.go | 2 +- src/encoding/gob/encode.go | 2 +- src/encoding/gob/encoder.go | 2 +- src/encoding/gob/encoder_test.go | 48 +++--- src/encoding/gob/error.go | 2 +- src/encoding/gob/gobencdec_test.go | 2 +- src/encoding/gob/timing_test.go | 18 +-- src/encoding/gob/type.go | 8 +- src/encoding/gob/type_test.go | 4 +- src/encoding/json/bench_test.go | 2 +- src/encoding/json/decode.go | 20 +-- src/encoding/json/decode_test.go | 106 +++++++------- src/encoding/json/encode.go | 10 +- src/encoding/json/encode_test.go | 112 +++++++------- src/encoding/json/example_test.go | 2 +- src/encoding/json/fuzz.go | 8 +- src/encoding/json/scanner.go | 2 +- src/encoding/json/scanner_test.go | 10 +- src/encoding/json/stream.go | 8 +- src/encoding/json/stream_test.go | 70 ++++----- src/encoding/json/tagkey_test.go | 6 +- src/encoding/xml/marshal.go | 8 +- src/encoding/xml/marshal_test.go | 38 ++--- src/encoding/xml/read.go | 8 +- src/encoding/xml/read_test.go | 6 +- src/encoding/xml/xml.go | 2 +- src/errors/wrap.go | 4 +- src/errors/wrap_test.go | 8 +- src/expvar/expvar.go | 10 +- src/expvar/expvar_test.go | 8 +- src/flag/flag.go | 22 +-- src/fmt/errors.go | 2 +- src/fmt/fmt_test.go | 50 +++---- src/fmt/print.go | 34 ++--- src/fmt/scan.go | 26 ++-- src/fmt/scan_test.go | 20 +-- src/go/ast/print.go | 18 +-- src/go/ast/print_test.go | 2 +- src/go/ast/resolve.go | 2 +- src/go/ast/scope.go | 8 +- src/go/constant/value.go | 4 +- src/go/constant/value_test.go | 4 +- src/go/doc/doc.go | 2 +- src/go/doc/doc_test.go | 2 +- src/go/doc/testdata/benchmark.go | 4 +- src/go/doc/testdata/testing.0.golden | 24 +-- src/go/doc/testdata/testing.1.golden | 40 ++--- src/go/doc/testdata/testing.2.golden | 24 +-- src/go/doc/testdata/testing.go | 20 +-- src/go/format/format.go | 2 +- src/go/internal/gccgoimporter/parser.go | 32 ++-- src/go/internal/gcimporter/gcimporter_test.go | 2 +- src/go/internal/gcimporter/support.go | 2 +- .../internal/gcimporter/testdata/exports.go | 6 +- src/go/parser/error_test.go | 2 +- src/go/parser/interface.go | 6 +- src/go/parser/parser.go | 2 +- src/go/parser/resolver.go | 6 +- src/go/printer/printer.go | 14 +- src/go/printer/testdata/parser.go | 4 +- src/go/scanner/scanner.go | 2 +- src/go/token/serialize.go | 4 +- src/go/token/serialize_test.go | 4 +- src/go/types/check.go | 4 +- src/go/types/conversions.go | 2 +- src/go/types/errors.go | 20 +-- src/go/types/eval_test.go | 4 +- src/go/types/expr.go | 4 +- src/go/types/gotype.go | 2 +- src/go/types/hilbert_test.go | 2 +- src/go/types/initorder.go | 4 +- src/go/types/instantiate.go | 2 +- src/go/types/operand.go | 2 +- src/go/types/sizeof_test.go | 6 +- src/go/types/stdlib_test.go | 4 +- src/go/types/stmt.go | 4 +- src/go/types/subst.go | 4 +- src/html/template/content.go | 6 +- src/html/template/content_test.go | 4 +- src/html/template/css.go | 4 +- src/html/template/error.go | 2 +- src/html/template/escape.go | 8 +- src/html/template/escape_test.go | 12 +- src/html/template/example_test.go | 2 +- src/html/template/exec_test.go | 36 ++--- src/html/template/html.go | 12 +- src/html/template/js.go | 10 +- src/html/template/js_test.go | 14 +- src/html/template/template.go | 8 +- src/html/template/template_test.go | 2 +- src/html/template/url.go | 10 +- src/html/template/url_test.go | 2 +- src/image/draw/draw_test.go | 4 +- src/internal/abi/abi.go | 4 +- src/internal/fmtsort/sort_test.go | 14 +- src/internal/fuzz/encoding.go | 12 +- src/internal/fuzz/fuzz.go | 14 +- src/internal/fuzz/minimize_test.go | 34 ++--- src/internal/fuzz/mutator.go | 2 +- src/internal/fuzz/mutator_test.go | 10 +- src/internal/fuzz/queue.go | 10 +- src/internal/fuzz/worker.go | 10 +- src/internal/fuzz/worker_test.go | 6 +- src/internal/intern/intern.go | 10 +- src/internal/lazytemplate/lazytemplate.go | 2 +- src/internal/nettrace/nettrace.go | 2 +- src/internal/poll/splice_linux.go | 2 +- src/internal/poll/splice_linux_test.go | 2 +- src/internal/reflectlite/all_test.go | 32 ++-- src/internal/reflectlite/export_test.go | 2 +- src/internal/reflectlite/set_test.go | 12 +- src/internal/reflectlite/swapper.go | 2 +- src/internal/reflectlite/type.go | 2 +- src/internal/reflectlite/value.go | 26 ++-- src/internal/singleflight/singleflight.go | 10 +- .../singleflight/singleflight_test.go | 6 +- .../syscall/windows/registry/registry_test.go | 2 +- src/internal/trace/gc.go | 8 +- .../unsafeheader/unsafeheader_test.go | 2 +- src/io/fs/fs.go | 2 +- src/io/io.go | 2 +- src/log/log.go | 36 ++--- src/math/all_test.go | 2 +- src/math/big/floatconv_test.go | 2 +- src/math/bits/make_examples.go | 20 +-- src/math/rand/example_test.go | 2 +- src/math/rand/regress_test.go | 6 +- src/mime/quotedprintable/reader_test.go | 4 +- src/mime/type.go | 2 +- src/net/http/cgi/host.go | 2 +- src/net/http/client_test.go | 2 +- src/net/http/clientserver_test.go | 10 +- src/net/http/cookie_test.go | 2 +- src/net/http/fs_test.go | 2 +- src/net/http/h2_bundle.go | 52 +++---- src/net/http/header.go | 2 +- src/net/http/httptrace/trace.go | 2 +- src/net/http/httputil/dump_test.go | 2 +- src/net/http/httputil/reverseproxy.go | 2 +- src/net/http/omithttp2.go | 6 +- src/net/http/requestwrite_test.go | 2 +- src/net/http/response_test.go | 16 +- src/net/http/roundtrip_js.go | 12 +- src/net/http/serve_test.go | 16 +- src/net/http/server.go | 8 +- src/net/http/transfer.go | 6 +- src/net/http/transport.go | 4 +- src/net/http/transport_test.go | 10 +- src/net/ip_test.go | 2 +- src/net/listen_test.go | 2 +- src/net/lookup.go | 10 +- src/net/lookup_test.go | 2 +- src/net/lookup_windows_test.go | 2 +- src/net/mail/message.go | 2 +- src/net/netip/netip_test.go | 2 +- src/net/platform_test.go | 2 +- src/net/rpc/client.go | 22 +-- src/net/rpc/client_test.go | 4 +- src/net/rpc/debug.go | 2 +- src/net/rpc/jsonrpc/all_test.go | 6 +- src/net/rpc/jsonrpc/client.go | 12 +- src/net/rpc/jsonrpc/server.go | 10 +- src/net/rpc/server.go | 20 +-- src/net/rpc/server_test.go | 8 +- src/net/smtp/smtp.go | 2 +- src/net/textproto/textproto.go | 2 +- src/net/textproto/writer.go | 2 +- src/net/url/example_test.go | 2 +- src/net/url/url_test.go | 2 +- src/os/dir_unix.go | 2 +- src/os/env_test.go | 2 +- src/os/exec.go | 4 +- src/os/exec/exec.go | 2 +- src/os/exec/exec_test.go | 2 +- src/os/exec_plan9.go | 4 +- src/os/exec_posix.go | 4 +- src/os/stat_plan9.go | 2 +- src/os/types_plan9.go | 4 +- src/os/types_unix.go | 2 +- src/os/types_windows.go | 2 +- src/os/user/lookup_unix.go | 8 +- src/plugin/plugin.go | 4 +- src/plugin/plugin_dlopen.go | 4 +- src/reflect/abi_test.go | 6 +- src/reflect/all_test.go | 138 +++++++++--------- src/reflect/deepequal.go | 2 +- src/reflect/example_test.go | 4 +- src/reflect/export_test.go | 2 +- src/reflect/set_test.go | 18 +-- src/reflect/swapper.go | 2 +- src/reflect/type.go | 18 +-- src/reflect/value.go | 30 ++-- src/reflect/visiblefields_test.go | 4 +- src/runtime/abi_test.go | 2 +- src/runtime/alg.go | 2 +- src/runtime/cgo.go | 2 +- src/runtime/cgo/handle.go | 4 +- src/runtime/cgo/handle_test.go | 6 +- src/runtime/cgocall.go | 4 +- src/runtime/chan_test.go | 2 +- src/runtime/crash_test.go | 2 +- src/runtime/debug/garbage_test.go | 4 +- src/runtime/debugcall.go | 2 +- src/runtime/debuglog.go | 2 +- src/runtime/defer_test.go | 2 +- src/runtime/error.go | 4 +- src/runtime/export_debug_test.go | 4 +- src/runtime/export_debuglog_test.go | 18 +-- src/runtime/export_test.go | 10 +- src/runtime/gc_test.go | 12 +- src/runtime/gcinfo_test.go | 28 ++-- src/runtime/hash_test.go | 2 +- src/runtime/iface.go | 10 +- src/runtime/iface_test.go | 16 +- src/runtime/internal/atomic/bench_test.go | 2 +- src/runtime/lfstack_test.go | 2 +- src/runtime/malloc_test.go | 12 +- src/runtime/map_benchmark_test.go | 6 +- src/runtime/map_test.go | 6 +- src/runtime/mbitmap.go | 4 +- src/runtime/mfinal.go | 6 +- src/runtime/mfinal_test.go | 16 +- src/runtime/mgcscavenge.go | 2 +- src/runtime/mkpreempt.go | 2 +- src/runtime/netpoll.go | 12 +- src/runtime/os_windows.go | 4 +- src/runtime/panic.go | 4 +- src/runtime/plugin.go | 6 +- src/runtime/pprof/mprof_test.go | 2 +- src/runtime/pprof/pprof.go | 8 +- src/runtime/pprof/pprof_test.go | 4 +- src/runtime/pprof/proto_test.go | 2 +- src/runtime/race/race_test.go | 2 +- src/runtime/race/testdata/issue12664_test.go | 2 +- src/runtime/race/testdata/mop_test.go | 18 +-- src/runtime/race/testdata/pool_test.go | 4 +- src/runtime/runtime2.go | 4 +- src/runtime/runtime_test.go | 4 +- src/runtime/sizeof_test.go | 6 +- src/runtime/softfloat64_test.go | 2 +- src/runtime/stack.go | 2 +- src/runtime/stack_test.go | 2 +- src/runtime/syscall_windows_test.go | 2 +- src/runtime/testdata/testprog/gc.go | 6 +- src/runtime/testdata/testprog/signal.go | 1 + .../testdata/testprog/syscalls_none.go | 1 + src/runtime/testdata/testprogcgo/callback.go | 1 + .../testdata/testprogcgo/catchpanic.go | 1 + src/runtime/testdata/testprogcgo/dropm.go | 1 + src/runtime/testdata/testprogcgo/eintr.go | 1 + src/runtime/testdata/testprogcgo/exec.go | 1 + .../testdata/testprogcgo/lockosthread.go | 1 + .../testdata/testprogcgo/needmdeadlock.go | 1 + .../testdata/testprogcgo/numgoroutine.go | 1 + src/runtime/testdata/testprogcgo/raceprof.go | 1 + src/runtime/testdata/testprogcgo/racesig.go | 1 + src/runtime/testdata/testprogcgo/segv.go | 1 + src/runtime/testdata/testprogcgo/sigstack.go | 1 + .../testdata/testprogcgo/threadpanic.go | 1 + .../testdata/testprogcgo/threadpprof.go | 3 +- .../testdata/testprogcgo/threadprof.go | 4 +- src/runtime/testdata/testprognet/signal.go | 1 + .../testdata/testprognet/signalexec.go | 1 + src/runtime/testdata/testwinlib/main.go | 1 + src/runtime/time.go | 10 +- src/runtime/trace/annotation.go | 2 +- src/sort/slice.go | 6 +- src/sort/slice_go14.go | 2 +- src/strings/export_test.go | 2 +- src/strings/reader_test.go | 2 +- src/sync/atomic/atomic_test.go | 2 +- src/sync/atomic/value.go | 12 +- src/sync/atomic/value_test.go | 18 +-- src/sync/example_pool_test.go | 2 +- src/sync/export_test.go | 18 +-- src/sync/map.go | 40 ++--- src/sync/map_bench_test.go | 4 +- src/sync/map_reference_test.go | 58 ++++---- src/sync/map_test.go | 28 ++-- src/sync/pool.go | 14 +- src/sync/pool_test.go | 12 +- src/sync/poolqueue.go | 18 +-- src/syscall/fs_js.go | 4 +- src/syscall/js/func.go | 4 +- src/syscall/js/js.go | 18 +-- src/syscall/js/js_test.go | 18 +-- src/syscall/net_js.go | 3 +- src/syscall/syscall_windows.go | 6 +- src/testing/allocs_test.go | 2 +- src/testing/example.go | 2 +- src/testing/fstest/mapfs.go | 4 +- src/testing/fstest/testfs.go | 2 +- src/testing/fuzz.go | 10 +- src/testing/internal/testdeps/deps.go | 2 +- src/testing/quick/quick.go | 18 +-- src/testing/testing.go | 50 +++---- src/text/scanner/scanner.go | 2 +- src/text/template/exec.go | 12 +- src/text/template/exec_test.go | 34 ++--- src/text/template/funcs.go | 10 +- src/text/template/parse/lex.go | 2 +- src/text/template/parse/parse.go | 12 +- src/text/template/parse/parse_test.go | 2 +- src/time/internal_test.go | 2 +- src/time/sleep.go | 10 +- src/time/tzdata/generate_zipdata.go | 2 +- 445 files changed, 1906 insertions(+), 1875 deletions(-) diff --git a/src/archive/tar/common.go b/src/archive/tar/common.go index 595de64725..c99b5c1920 100644 --- a/src/archive/tar/common.go +++ b/src/archive/tar/common.go @@ -538,7 +538,7 @@ type headerFileInfo struct { func (fi headerFileInfo) Size() int64 { return fi.h.Size } func (fi headerFileInfo) IsDir() bool { return fi.Mode().IsDir() } func (fi headerFileInfo) ModTime() time.Time { return fi.h.ModTime } -func (fi headerFileInfo) Sys() interface{} { return fi.h } +func (fi headerFileInfo) Sys() any { return fi.h } // Name returns the base name of the file. func (fi headerFileInfo) Name() string { diff --git a/src/archive/tar/reader_test.go b/src/archive/tar/reader_test.go index c31a847ec3..f21a6065b4 100644 --- a/src/archive/tar/reader_test.go +++ b/src/archive/tar/reader_test.go @@ -1363,7 +1363,7 @@ func TestFileReader(t *testing.T) { wantLCnt int64 wantPCnt int64 } - testFnc interface{} // testRead | testWriteTo | testRemaining + testFnc any // testRead | testWriteTo | testRemaining ) type ( @@ -1376,7 +1376,7 @@ func TestFileReader(t *testing.T) { spd sparseDatas size int64 } - fileMaker interface{} // makeReg | makeSparse + fileMaker any // makeReg | makeSparse ) vectors := []struct { diff --git a/src/archive/tar/tar_test.go b/src/archive/tar/tar_test.go index e9fafc7cc7..a476f5eb01 100644 --- a/src/archive/tar/tar_test.go +++ b/src/archive/tar/tar_test.go @@ -23,7 +23,7 @@ import ( type testError struct{ error } -type fileOps []interface{} // []T where T is (string | int64) +type fileOps []any // []T where T is (string | int64) // testFile is an io.ReadWriteSeeker where the IO operations performed // on it must match the list of operations in ops. diff --git a/src/archive/tar/writer_test.go b/src/archive/tar/writer_test.go index 95ce99a3ed..da3fb89e65 100644 --- a/src/archive/tar/writer_test.go +++ b/src/archive/tar/writer_test.go @@ -67,7 +67,7 @@ func TestWriter(t *testing.T) { testClose struct { // Close() == wantErr wantErr error } - testFnc interface{} // testHeader | testWrite | testReadFrom | testClose + testFnc any // testHeader | testWrite | testReadFrom | testClose ) vectors := []struct { @@ -1031,7 +1031,7 @@ func TestFileWriter(t *testing.T) { wantLCnt int64 wantPCnt int64 } - testFnc interface{} // testWrite | testReadFrom | testRemaining + testFnc any // testWrite | testReadFrom | testRemaining ) type ( @@ -1044,7 +1044,7 @@ func TestFileWriter(t *testing.T) { sph sparseHoles size int64 } - fileMaker interface{} // makeReg | makeSparse + fileMaker any // makeReg | makeSparse ) vectors := []struct { diff --git a/src/archive/zip/reader.go b/src/archive/zip/reader.go index 2843a5d658..92fd6f6a92 100644 --- a/src/archive/zip/reader.go +++ b/src/archive/zip/reader.go @@ -670,7 +670,7 @@ func (f *fileListEntry) Size() int64 { return 0 } func (f *fileListEntry) Mode() fs.FileMode { return fs.ModeDir | 0555 } func (f *fileListEntry) Type() fs.FileMode { return fs.ModeDir } func (f *fileListEntry) IsDir() bool { return true } -func (f *fileListEntry) Sys() interface{} { return nil } +func (f *fileListEntry) Sys() any { return nil } func (f *fileListEntry) ModTime() time.Time { if f.file == nil { diff --git a/src/archive/zip/struct.go b/src/archive/zip/struct.go index 88effedc0f..6f73fb8376 100644 --- a/src/archive/zip/struct.go +++ b/src/archive/zip/struct.go @@ -163,7 +163,7 @@ func (fi headerFileInfo) ModTime() time.Time { } func (fi headerFileInfo) Mode() fs.FileMode { return fi.fh.Mode() } func (fi headerFileInfo) Type() fs.FileMode { return fi.fh.Mode().Type() } -func (fi headerFileInfo) Sys() interface{} { return fi.fh } +func (fi headerFileInfo) Sys() any { return fi.fh } func (fi headerFileInfo) Info() (fs.FileInfo, error) { return fi, nil } diff --git a/src/builtin/builtin.go b/src/builtin/builtin.go index 9a94c7357d..08ae7ed313 100644 --- a/src/builtin/builtin.go +++ b/src/builtin/builtin.go @@ -239,7 +239,7 @@ func close(c chan<- Type) // that point, the program is terminated with a non-zero exit code. This // termination sequence is called panicking and can be controlled by the // built-in function recover. -func panic(v interface{}) +func panic(v any) // The recover built-in function allows a program to manage behavior of a // panicking goroutine. Executing a call to recover inside a deferred @@ -250,7 +250,7 @@ func panic(v interface{}) // panicking, or if the argument supplied to panic was nil, recover returns // nil. Thus the return value from recover reports whether the goroutine is // panicking. -func recover() interface{} +func recover() any // The print built-in function formats its arguments in an // implementation-specific way and writes the result to standard error. diff --git a/src/bytes/reader_test.go b/src/bytes/reader_test.go index 8baac5046c..9119c944ac 100644 --- a/src/bytes/reader_test.go +++ b/src/bytes/reader_test.go @@ -76,7 +76,7 @@ func TestReaderAt(t *testing.T) { off int64 n int want string - wanterr interface{} + wanterr any }{ {0, 10, "0123456789", nil}, {1, 10, "123456789", io.EOF}, diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go index a55e51cc9b..036aefe4d8 100644 --- a/src/cmd/api/goapi.go +++ b/src/cmd/api/goapi.go @@ -1071,7 +1071,7 @@ func (w *Walker) emitMethod(m *types.Selection) { w.emitf("method (%s%s) %s%s", w.typeString(recv), tps, m.Obj().Name(), w.signatureString(sig)) } -func (w *Walker) emitf(format string, args ...interface{}) { +func (w *Walker) emitf(format string, args ...any) { f := strings.Join(w.scope, ", ") + ", " + fmt.Sprintf(format, args...) if strings.Contains(f, "\n") { panic("feature contains newlines: " + f) diff --git a/src/cmd/api/testdata/src/issue21181/p/p_generic.go b/src/cmd/api/testdata/src/issue21181/p/p_generic.go index 4d75809676..ad6df20187 100644 --- a/src/cmd/api/testdata/src/issue21181/p/p_generic.go +++ b/src/cmd/api/testdata/src/issue21181/p/p_generic.go @@ -1,3 +1,4 @@ +//go:build !amd64 // +build !amd64 package p diff --git a/src/cmd/api/testdata/src/pkg/p1/p1.go b/src/cmd/api/testdata/src/pkg/p1/p1.go index 65181b248a..81826d768b 100644 --- a/src/cmd/api/testdata/src/pkg/p1/p1.go +++ b/src/cmd/api/testdata/src/pkg/p1/p1.go @@ -197,7 +197,7 @@ var m map[string]int var chanVar chan int -var ifaceVar interface{} = 5 +var ifaceVar any = 5 var assertVar = ifaceVar.(int) diff --git a/src/cmd/api/testdata/src/pkg/p4/p4.go b/src/cmd/api/testdata/src/pkg/p4/p4.go index 462a75be1a..1f90e779dd 100644 --- a/src/cmd/api/testdata/src/pkg/p4/p4.go +++ b/src/cmd/api/testdata/src/pkg/p4/p4.go @@ -4,12 +4,12 @@ package p4 -type Pair[T1 interface { M() }, T2 ~int] struct { +type Pair[T1 interface{ M() }, T2 ~int] struct { f1 T1 f2 T2 } -func NewPair[T1 interface { M() }, T2 ~int](v1 T1, v2 T2) Pair[T1, T2] { +func NewPair[T1 interface{ M() }, T2 ~int](v1 T1, v2 T2) Pair[T1, T2] { return Pair[T1, T2]{f1: v1, f2: v2} } diff --git a/src/cmd/compile/internal/importer/gcimporter_test.go b/src/cmd/compile/internal/importer/gcimporter_test.go index e097507f69..5d80db244b 100644 --- a/src/cmd/compile/internal/importer/gcimporter_test.go +++ b/src/cmd/compile/internal/importer/gcimporter_test.go @@ -258,7 +258,7 @@ var importedObjectTests = []struct { {"go/internal/gcimporter.FindPkg", "func FindPkg(path string, srcDir string) (filename string, id string)"}, // interfaces - {"context.Context", "type Context interface{Deadline() (deadline time.Time, ok bool); Done() <-chan struct{}; Err() error; Value(key interface{}) interface{}}"}, + {"context.Context", "type Context interface{Deadline() (deadline time.Time, ok bool); Done() <-chan struct{}; Err() error; Value(key any) any}"}, {"crypto.Decrypter", "type Decrypter interface{Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error); Public() PublicKey}"}, {"encoding.BinaryMarshaler", "type BinaryMarshaler interface{MarshalBinary() (data []byte, err error)}"}, {"io.Reader", "type Reader interface{Read(p []byte) (n int, err error)}"}, diff --git a/src/cmd/cover/testdata/test.go b/src/cmd/cover/testdata/test.go index 703fba57a4..0e1dbc6194 100644 --- a/src/cmd/cover/testdata/test.go +++ b/src/cmd/cover/testdata/test.go @@ -151,7 +151,7 @@ func testSwitch() { } func testTypeSwitch() { - var x = []interface{}{1, 2.0, "hi"} + var x = []any{1, 2.0, "hi"} for _, v := range x { switch func() { check(LINE, 3) }(); v.(type) { case int: @@ -215,7 +215,7 @@ func testEmptySwitches() { switch 3 { } check(LINE, 1) - switch i := (interface{})(3).(int); i { + switch i := (any)(3).(int); i { } check(LINE, 1) c := make(chan int) diff --git a/src/cmd/dist/buildtool.go b/src/cmd/dist/buildtool.go index 17538ad5a4..036f8c52fa 100644 --- a/src/cmd/dist/buildtool.go +++ b/src/cmd/dist/buildtool.go @@ -15,6 +15,7 @@ import ( "fmt" "os" "path/filepath" + "regexp" "runtime" "strings" ) @@ -288,7 +289,11 @@ func rewriteBlock%s(b *Block) bool { panic("unused during bootstrap") } } func bootstrapFixImports(srcFile string) string { - lines := strings.SplitAfter(readfile(srcFile), "\n") + text := readfile(srcFile) + if !strings.Contains(srcFile, "/cmd/") && !strings.Contains(srcFile, `\cmd\`) { + text = regexp.MustCompile(`\bany\b`).ReplaceAllString(text, "interface{}") + } + lines := strings.SplitAfter(text, "\n") inBlock := false for i, line := range lines { if strings.HasPrefix(line, "import (") { diff --git a/src/cmd/doc/pkg.go b/src/cmd/doc/pkg.go index 2257c5c0eb..f51efe08af 100644 --- a/src/cmd/doc/pkg.go +++ b/src/cmd/doc/pkg.go @@ -122,7 +122,7 @@ func trim(path, prefix string) (string, bool) { // main do function, so it doesn't cause an exit. Allows testing to work // without running a subprocess. The log prefix will be added when // logged in main; it is not added here. -func (pkg *Package) Fatalf(format string, args ...interface{}) { +func (pkg *Package) Fatalf(format string, args ...any) { panic(PackageError(fmt.Sprintf(format, args...))) } @@ -209,7 +209,7 @@ func parsePackage(writer io.Writer, pkg *build.Package, userPath string) *Packag return p } -func (pkg *Package) Printf(format string, args ...interface{}) { +func (pkg *Package) Printf(format string, args ...any) { fmt.Fprintf(&pkg.buf, format, args...) } @@ -235,7 +235,7 @@ func (pkg *Package) newlines(n int) { // clears the stuff we don't want to print anyway. It's a bit of a magic trick. func (pkg *Package) emit(comment string, node ast.Node) { if node != nil { - var arg interface{} = node + var arg any = node if showSrc { // Need an extra little dance to get internal comments to appear. arg = &printer.CommentedNode{ diff --git a/src/cmd/doc/testdata/nested/ignore.go b/src/cmd/doc/testdata/nested/ignore.go index c497f1b5bc..5fa811d0a8 100644 --- a/src/cmd/doc/testdata/nested/ignore.go +++ b/src/cmd/doc/testdata/nested/ignore.go @@ -1,3 +1,4 @@ +//go:build ignore // +build ignore // Ignored package diff --git a/src/cmd/fix/cftype.go b/src/cmd/fix/cftype.go index 3d292bdeba..27e4088aa9 100644 --- a/src/cmd/fix/cftype.go +++ b/src/cmd/fix/cftype.go @@ -45,8 +45,8 @@ func typefix(f *ast.File, badType func(string) bool) bool { // step 1: Find all the nils with the offending types. // Compute their replacement. - badNils := map[interface{}]ast.Expr{} - walk(f, func(n interface{}) { + badNils := map[any]ast.Expr{} + walk(f, func(n any) { if i, ok := n.(*ast.Ident); ok && i.Name == "nil" && badType(typeof[n]) { badNils[n] = &ast.BasicLit{ValuePos: i.NamePos, Kind: token.INT, Value: "0"} } @@ -58,7 +58,7 @@ func typefix(f *ast.File, badType func(string) bool) bool { if len(badNils) > 0 { exprType := reflect.TypeOf((*ast.Expr)(nil)).Elem() exprSliceType := reflect.TypeOf(([]ast.Expr)(nil)) - walk(f, func(n interface{}) { + walk(f, func(n any) { if n == nil { return } @@ -99,7 +99,7 @@ func typefix(f *ast.File, badType func(string) bool) bool { // Now we need unsafe.Pointer as an intermediate cast. // (*unsafe.Pointer)(x) where x is type *bad -> (*unsafe.Pointer)(unsafe.Pointer(x)) // (*bad.type)(x) where x is type *unsafe.Pointer -> (*bad.type)(unsafe.Pointer(x)) - walk(f, func(n interface{}) { + walk(f, func(n any) { if n == nil { return } diff --git a/src/cmd/fix/fix.go b/src/cmd/fix/fix.go index b9980c17b9..7abdab28a8 100644 --- a/src/cmd/fix/fix.go +++ b/src/cmd/fix/fix.go @@ -43,15 +43,15 @@ func register(f fix) { // walk traverses the AST x, calling visit(y) for each node y in the tree but // also with a pointer to each ast.Expr, ast.Stmt, and *ast.BlockStmt, // in a bottom-up traversal. -func walk(x interface{}, visit func(interface{})) { +func walk(x any, visit func(any)) { walkBeforeAfter(x, nop, visit) } -func nop(interface{}) {} +func nop(any) {} // walkBeforeAfter is like walk but calls before(x) before traversing // x's children and after(x) afterward. -func walkBeforeAfter(x interface{}, before, after func(interface{})) { +func walkBeforeAfter(x any, before, after func(any)) { before(x) switch n := x.(type) { @@ -390,7 +390,7 @@ func renameTop(f *ast.File, old, new string) bool { // Rename top-level old to new, both unresolved names // (probably defined in another file) and names that resolve // to a declaration we renamed. - walk(f, func(n interface{}) { + walk(f, func(n any) { id, ok := n.(*ast.Ident) if ok && isTopName(id, old) { id.Name = new diff --git a/src/cmd/fix/gotypes.go b/src/cmd/fix/gotypes.go index 031f85c9cc..6085816ada 100644 --- a/src/cmd/fix/gotypes.go +++ b/src/cmd/fix/gotypes.go @@ -36,7 +36,7 @@ func fixGoExact(f *ast.File) bool { // This one is harder because the import name changes. // First find the import spec. var importSpec *ast.ImportSpec - walk(f, func(n interface{}) { + walk(f, func(n any) { if importSpec != nil { return } diff --git a/src/cmd/fix/main.go b/src/cmd/fix/main.go index b5f7b901d6..3229b71ec4 100644 --- a/src/cmd/fix/main.go +++ b/src/cmd/fix/main.go @@ -245,7 +245,7 @@ func processFile(filename string, useStdin bool) error { return os.WriteFile(f.Name(), newSrc, 0) } -func gofmt(n interface{}) string { +func gofmt(n any) string { var gofmtBuf bytes.Buffer if err := format.Node(&gofmtBuf, fset, n); err != nil { return "<" + err.Error() + ">" diff --git a/src/cmd/fix/netipv6zone.go b/src/cmd/fix/netipv6zone.go index 3e502bda07..199fcf5bf5 100644 --- a/src/cmd/fix/netipv6zone.go +++ b/src/cmd/fix/netipv6zone.go @@ -26,7 +26,7 @@ func netipv6zone(f *ast.File) bool { } fixed := false - walk(f, func(n interface{}) { + walk(f, func(n any) { cl, ok := n.(*ast.CompositeLit) if !ok { return diff --git a/src/cmd/fix/printerconfig.go b/src/cmd/fix/printerconfig.go index 6d93996872..bad6953196 100644 --- a/src/cmd/fix/printerconfig.go +++ b/src/cmd/fix/printerconfig.go @@ -23,7 +23,7 @@ func printerconfig(f *ast.File) bool { } fixed := false - walk(f, func(n interface{}) { + walk(f, func(n any) { cl, ok := n.(*ast.CompositeLit) if !ok { return diff --git a/src/cmd/fix/typecheck.go b/src/cmd/fix/typecheck.go index b7ec72e116..8a18d61bf2 100644 --- a/src/cmd/fix/typecheck.go +++ b/src/cmd/fix/typecheck.go @@ -142,9 +142,9 @@ func (typ *Type) dot(cfg *TypeConfig, name string) string { // typeof maps AST nodes to type information in gofmt string form. // assign maps type strings to lists of expressions that were assigned // to values of another type that were assigned to that type. -func typecheck(cfg *TypeConfig, f *ast.File) (typeof map[interface{}]string, assign map[string][]interface{}) { - typeof = make(map[interface{}]string) - assign = make(map[string][]interface{}) +func typecheck(cfg *TypeConfig, f *ast.File) (typeof map[any]string, assign map[string][]any) { + typeof = make(map[any]string) + assign = make(map[string][]any) cfg1 := &TypeConfig{} *cfg1 = *cfg // make copy so we can add locally copied := false @@ -296,7 +296,7 @@ func makeExprList(a []*ast.Ident) []ast.Expr { // Typecheck1 is the recursive form of typecheck. // It is like typecheck but adds to the information in typeof // instead of allocating a new map. -func typecheck1(cfg *TypeConfig, f interface{}, typeof map[interface{}]string, assign map[string][]interface{}) { +func typecheck1(cfg *TypeConfig, f any, typeof map[any]string, assign map[string][]any) { // set sets the type of n to typ. // If isDecl is true, n is being declared. set := func(n ast.Expr, typ string, isDecl bool) { @@ -368,7 +368,7 @@ func typecheck1(cfg *TypeConfig, f interface{}, typeof map[interface{}]string, a // the curfn stack. var curfn []*ast.FuncType - before := func(n interface{}) { + before := func(n any) { // push function type on stack switch n := n.(type) { case *ast.FuncDecl: @@ -379,7 +379,7 @@ func typecheck1(cfg *TypeConfig, f interface{}, typeof map[interface{}]string, a } // After is the real type checker. - after := func(n interface{}) { + after := func(n any) { if n == nil { return } diff --git a/src/cmd/go/internal/base/base.go b/src/cmd/go/internal/base/base.go index 954ce47a98..c2d4e6b258 100644 --- a/src/cmd/go/internal/base/base.go +++ b/src/cmd/go/internal/base/base.go @@ -117,12 +117,12 @@ func Exit() { os.Exit(exitStatus) } -func Fatalf(format string, args ...interface{}) { +func Fatalf(format string, args ...any) { Errorf(format, args...) Exit() } -func Errorf(format string, args ...interface{}) { +func Errorf(format string, args ...any) { log.Printf(format, args...) SetExitStatus(1) } @@ -151,7 +151,7 @@ func GetExitStatus() int { // Run runs the command, with stdout and stderr // connected to the go command's own stdout and stderr. // If the command fails, Run reports the error using Errorf. -func Run(cmdargs ...interface{}) { +func Run(cmdargs ...any) { cmdline := str.StringList(cmdargs...) if cfg.BuildN || cfg.BuildX { fmt.Printf("%s\n", strings.Join(cmdline, " ")) diff --git a/src/cmd/go/internal/cmdflag/flag.go b/src/cmd/go/internal/cmdflag/flag.go index 8abb7e559f..a634bc1ab8 100644 --- a/src/cmd/go/internal/cmdflag/flag.go +++ b/src/cmd/go/internal/cmdflag/flag.go @@ -92,7 +92,7 @@ func ParseOne(fs *flag.FlagSet, args []string) (f *flag.Flag, remainingArgs []st // Use fs.Set instead of f.Value.Set below so that any subsequent call to // fs.Visit will correctly visit the flags that have been set. - failf := func(format string, a ...interface{}) (*flag.Flag, []string, error) { + failf := func(format string, a ...any) (*flag.Flag, []string, error) { return f, args, fmt.Errorf(format, a...) } diff --git a/src/cmd/go/internal/fsys/fsys.go b/src/cmd/go/internal/fsys/fsys.go index 0b806027e6..9a1bbf890e 100644 --- a/src/cmd/go/internal/fsys/fsys.go +++ b/src/cmd/go/internal/fsys/fsys.go @@ -499,7 +499,7 @@ func (f fakeFile) Size() int64 { return f.real.Size() } func (f fakeFile) Mode() fs.FileMode { return f.real.Mode() } func (f fakeFile) ModTime() time.Time { return f.real.ModTime() } func (f fakeFile) IsDir() bool { return f.real.IsDir() } -func (f fakeFile) Sys() interface{} { return f.real.Sys() } +func (f fakeFile) Sys() any { return f.real.Sys() } // missingFile provides an fs.FileInfo for an overlaid file where the // destination file in the overlay doesn't exist. It returns zero values @@ -512,7 +512,7 @@ func (f missingFile) Size() int64 { return 0 } func (f missingFile) Mode() fs.FileMode { return fs.ModeIrregular } func (f missingFile) ModTime() time.Time { return time.Unix(0, 0) } func (f missingFile) IsDir() bool { return false } -func (f missingFile) Sys() interface{} { return nil } +func (f missingFile) Sys() any { return nil } // fakeDir provides an fs.FileInfo implementation for directories that are // implicitly created by overlaid files. Each directory in the @@ -524,7 +524,7 @@ func (f fakeDir) Size() int64 { return 0 } func (f fakeDir) Mode() fs.FileMode { return fs.ModeDir | 0500 } func (f fakeDir) ModTime() time.Time { return time.Unix(0, 0) } func (f fakeDir) IsDir() bool { return true } -func (f fakeDir) Sys() interface{} { return nil } +func (f fakeDir) Sys() any { return nil } // Glob is like filepath.Glob but uses the overlay file system. func Glob(pattern string) (matches []string, err error) { diff --git a/src/cmd/go/internal/generate/generate.go b/src/cmd/go/internal/generate/generate.go index 4c17f42930..54ccfe78f2 100644 --- a/src/cmd/go/internal/generate/generate.go +++ b/src/cmd/go/internal/generate/generate.go @@ -408,7 +408,7 @@ var stop = fmt.Errorf("error in generation") // errorf logs an error message prefixed with the file and line number. // It then exits the program (with exit status 1) because generation stops // at the first error. -func (g *Generator) errorf(format string, args ...interface{}) { +func (g *Generator) errorf(format string, args ...any) { fmt.Fprintf(os.Stderr, "%s:%d: %s\n", base.ShortPath(g.path), g.lineNum, fmt.Sprintf(format, args...)) panic(stop) diff --git a/src/cmd/go/internal/help/help.go b/src/cmd/go/internal/help/help.go index 7a730fc8eb..2a07d2423b 100644 --- a/src/cmd/go/internal/help/help.go +++ b/src/cmd/go/internal/help/help.go @@ -162,7 +162,7 @@ func (w *errWriter) Write(b []byte) (int, error) { } // tmpl executes the given template text on data, writing the result to w. -func tmpl(w io.Writer, text string, data interface{}) { +func tmpl(w io.Writer, text string, data any) { t := template.New("top") t.Funcs(template.FuncMap{"trim": strings.TrimSpace, "capitalize": capitalize}) template.Must(t.Parse(text)) diff --git a/src/cmd/go/internal/imports/testdata/android/e.go b/src/cmd/go/internal/imports/testdata/android/e.go index d9b2db769b..f1b9c888c2 100644 --- a/src/cmd/go/internal/imports/testdata/android/e.go +++ b/src/cmd/go/internal/imports/testdata/android/e.go @@ -1,3 +1,4 @@ +//go:build android // +build android package android diff --git a/src/cmd/go/internal/imports/testdata/android/f.go b/src/cmd/go/internal/imports/testdata/android/f.go index 281e4dd6b9..bb0ff7b73f 100644 --- a/src/cmd/go/internal/imports/testdata/android/f.go +++ b/src/cmd/go/internal/imports/testdata/android/f.go @@ -1,3 +1,4 @@ +//go:build linux // +build linux package android diff --git a/src/cmd/go/internal/imports/testdata/android/g.go b/src/cmd/go/internal/imports/testdata/android/g.go index 66a789c0ad..ee19424890 100644 --- a/src/cmd/go/internal/imports/testdata/android/g.go +++ b/src/cmd/go/internal/imports/testdata/android/g.go @@ -1,3 +1,4 @@ +//go:build !android // +build !android package android diff --git a/src/cmd/go/internal/imports/testdata/illumos/e.go b/src/cmd/go/internal/imports/testdata/illumos/e.go index 5e1ed3cb9d..fddf2c4299 100644 --- a/src/cmd/go/internal/imports/testdata/illumos/e.go +++ b/src/cmd/go/internal/imports/testdata/illumos/e.go @@ -1,3 +1,4 @@ +//go:build illumos // +build illumos package illumos diff --git a/src/cmd/go/internal/imports/testdata/illumos/f.go b/src/cmd/go/internal/imports/testdata/illumos/f.go index f3e3f728bc..4b6d528e4c 100644 --- a/src/cmd/go/internal/imports/testdata/illumos/f.go +++ b/src/cmd/go/internal/imports/testdata/illumos/f.go @@ -1,3 +1,4 @@ +//go:build solaris // +build solaris package illumos diff --git a/src/cmd/go/internal/imports/testdata/illumos/g.go b/src/cmd/go/internal/imports/testdata/illumos/g.go index b30f1eb403..1bf826b815 100644 --- a/src/cmd/go/internal/imports/testdata/illumos/g.go +++ b/src/cmd/go/internal/imports/testdata/illumos/g.go @@ -1,3 +1,4 @@ +//go:build !illumos // +build !illumos package illumos diff --git a/src/cmd/go/internal/imports/testdata/star/x1.go b/src/cmd/go/internal/imports/testdata/star/x1.go index 6a9594aed0..eaaea979e9 100644 --- a/src/cmd/go/internal/imports/testdata/star/x1.go +++ b/src/cmd/go/internal/imports/testdata/star/x1.go @@ -1,8 +1,5 @@ -// +build blahblh -// +build linux -// +build !linux -// +build windows -// +build darwin +//go:build blahblh && linux && !linux && windows && darwin +// +build blahblh,linux,!linux,windows,darwin package x diff --git a/src/cmd/go/internal/list/list.go b/src/cmd/go/internal/list/list.go index 5ecd384787..d9a7078ccf 100644 --- a/src/cmd/go/internal/list/list.go +++ b/src/cmd/go/internal/list/list.go @@ -358,9 +358,9 @@ func runList(ctx context.Context, cmd *base.Command, args []string) { } } - var do func(interface{}) + var do func(any) if *listJson { - do = func(x interface{}) { + do = func(x any) { b, err := json.MarshalIndent(x, "", "\t") if err != nil { out.Flush() @@ -386,7 +386,7 @@ func runList(ctx context.Context, cmd *base.Command, args []string) { if err != nil { base.Fatalf("%s", err) } - do = func(x interface{}) { + do = func(x any) { if err := tmpl.Execute(out, x); err != nil { out.Flush() base.Fatalf("%s", err) diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go index 589bf9e729..a891d601b1 100644 --- a/src/cmd/go/internal/load/pkg.go +++ b/src/cmd/go/internal/load/pkg.go @@ -498,7 +498,7 @@ type importError struct { err error // created with fmt.Errorf } -func ImportErrorf(path, format string, args ...interface{}) ImportPathError { +func ImportErrorf(path, format string, args ...any) ImportPathError { err := &importError{importPath: path, err: fmt.Errorf(format, args...)} if errStr := err.Error(); !strings.Contains(errStr, path) { panic(fmt.Sprintf("path %q not in error %q", path, errStr)) @@ -589,10 +589,10 @@ func ClearPackageCachePartial(args []string) { delete(packageCache, arg) } } - resolvedImportCache.DeleteIf(func(key interface{}) bool { + resolvedImportCache.DeleteIf(func(key any) bool { return shouldDelete[key.(importSpec).path] }) - packageDataCache.DeleteIf(func(key interface{}) bool { + packageDataCache.DeleteIf(func(key any) bool { return shouldDelete[key.(string)] }) } @@ -605,7 +605,7 @@ func ReloadPackageNoFlags(arg string, stk *ImportStack) *Package { p := packageCache[arg] if p != nil { delete(packageCache, arg) - resolvedImportCache.DeleteIf(func(key interface{}) bool { + resolvedImportCache.DeleteIf(func(key any) bool { return key.(importSpec).path == p.ImportPath }) packageDataCache.Delete(p.ImportPath) @@ -817,7 +817,7 @@ func loadPackageData(ctx context.Context, path, parentPath, parentDir, parentRoo parentIsStd: parentIsStd, mode: mode, } - r := resolvedImportCache.Do(importKey, func() interface{} { + r := resolvedImportCache.Do(importKey, func() any { var r resolvedImport if build.IsLocalImport(path) { r.dir = filepath.Join(parentDir, path) @@ -844,7 +844,7 @@ func loadPackageData(ctx context.Context, path, parentPath, parentDir, parentRoo // Load the package from its directory. If we already found the package's // directory when resolving its import path, use that. - data := packageDataCache.Do(r.path, func() interface{} { + data := packageDataCache.Do(r.path, func() any { loaded = true var data packageData if r.dir != "" { @@ -1063,7 +1063,7 @@ func cleanImport(path string) string { var isDirCache par.Cache func isDir(path string) bool { - return isDirCache.Do(path, func() interface{} { + return isDirCache.Do(path, func() any { fi, err := fsys.Stat(path) return err == nil && fi.IsDir() }).(bool) @@ -1191,7 +1191,7 @@ var ( // goModPath returns the module path in the go.mod in dir, if any. func goModPath(dir string) (path string) { - return goModPathCache.Do(dir, func() interface{} { + return goModPathCache.Do(dir, func() any { data, err := os.ReadFile(filepath.Join(dir, "go.mod")) if err != nil { return "" @@ -2221,7 +2221,7 @@ func (p *Package) setBuildInfo() { // executables always appear stale unless the user sets the same flags. // Perhaps it's safe to omit those flags when GO_GCFLAGS and GO_LDFLAGS // are not set? - setPkgErrorf := func(format string, args ...interface{}) { + setPkgErrorf := func(format string, args ...any) { if p.Error == nil { p.Error = &PackageError{Err: fmt.Errorf(format, args...)} } @@ -2397,7 +2397,7 @@ func (p *Package) setBuildInfo() { Status vcs.Status Err error } - cached := vcsStatusCache.Do(repoDir, func() interface{} { + cached := vcsStatusCache.Do(repoDir, func() any { st, err := vcsCmd.Status(vcsCmd, repoDir) return vcsStatusError{st, err} }).(vcsStatusError) diff --git a/src/cmd/go/internal/modcmd/tidy.go b/src/cmd/go/internal/modcmd/tidy.go index 57d303a13c..d35476eb53 100644 --- a/src/cmd/go/internal/modcmd/tidy.go +++ b/src/cmd/go/internal/modcmd/tidy.go @@ -75,8 +75,8 @@ type goVersionFlag struct { v string } -func (f *goVersionFlag) String() string { return f.v } -func (f *goVersionFlag) Get() interface{} { return f.v } +func (f *goVersionFlag) String() string { return f.v } +func (f *goVersionFlag) Get() any { return f.v } func (f *goVersionFlag) Set(s string) error { if s != "" { diff --git a/src/cmd/go/internal/modfetch/cache.go b/src/cmd/go/internal/modfetch/cache.go index 8d299e931a..c682447900 100644 --- a/src/cmd/go/internal/modfetch/cache.go +++ b/src/cmd/go/internal/modfetch/cache.go @@ -204,7 +204,7 @@ func (r *cachingRepo) Versions(prefix string) ([]string, error) { list []string err error } - c := r.cache.Do("versions:"+prefix, func() interface{} { + c := r.cache.Do("versions:"+prefix, func() any { list, err := r.repo().Versions(prefix) return cached{list, err} }).(cached) @@ -221,7 +221,7 @@ type cachedInfo struct { } func (r *cachingRepo) Stat(rev string) (*RevInfo, error) { - c := r.cache.Do("stat:"+rev, func() interface{} { + c := r.cache.Do("stat:"+rev, func() any { file, info, err := readDiskStat(r.path, rev) if err == nil { return cachedInfo{info, nil} @@ -233,7 +233,7 @@ func (r *cachingRepo) Stat(rev string) (*RevInfo, error) { // then save the information under the proper version, for future use. if info.Version != rev { file, _ = CachePath(module.Version{Path: r.path, Version: info.Version}, "info") - r.cache.Do("stat:"+info.Version, func() interface{} { + r.cache.Do("stat:"+info.Version, func() any { return cachedInfo{info, err} }) } @@ -253,12 +253,12 @@ func (r *cachingRepo) Stat(rev string) (*RevInfo, error) { } func (r *cachingRepo) Latest() (*RevInfo, error) { - c := r.cache.Do("latest:", func() interface{} { + c := r.cache.Do("latest:", func() any { info, err := r.repo().Latest() // Save info for likely future Stat call. if err == nil { - r.cache.Do("stat:"+info.Version, func() interface{} { + r.cache.Do("stat:"+info.Version, func() any { return cachedInfo{info, err} }) if file, _, err := readDiskStat(r.path, info.Version); err != nil { @@ -281,7 +281,7 @@ func (r *cachingRepo) GoMod(version string) ([]byte, error) { text []byte err error } - c := r.cache.Do("gomod:"+version, func() interface{} { + c := r.cache.Do("gomod:"+version, func() any { file, text, err := readDiskGoMod(r.path, version) if err == nil { // Note: readDiskGoMod already called checkGoMod. diff --git a/src/cmd/go/internal/modfetch/codehost/codehost.go b/src/cmd/go/internal/modfetch/codehost/codehost.go index 5063f8616a..4a0e2241e5 100644 --- a/src/cmd/go/internal/modfetch/codehost/codehost.go +++ b/src/cmd/go/internal/modfetch/codehost/codehost.go @@ -228,7 +228,7 @@ var dirLock sync.Map // It returns the standard output and, for a non-zero exit, // a *RunError indicating the command, exit status, and standard error. // Standard error is unavailable for commands that exit successfully. -func Run(dir string, cmdline ...interface{}) ([]byte, error) { +func Run(dir string, cmdline ...any) ([]byte, error) { return RunWithStdin(dir, nil, cmdline...) } @@ -236,7 +236,7 @@ func Run(dir string, cmdline ...interface{}) ([]byte, error) { // See https://www.gnu.org/software/bash/manual/html_node/Double-Quotes.html. var bashQuoter = strings.NewReplacer(`"`, `\"`, `$`, `\$`, "`", "\\`", `\`, `\\`) -func RunWithStdin(dir string, stdin io.Reader, cmdline ...interface{}) ([]byte, error) { +func RunWithStdin(dir string, stdin io.Reader, cmdline ...any) ([]byte, error) { if dir != "" { muIface, ok := dirLock.Load(dir) if !ok { diff --git a/src/cmd/go/internal/modfetch/codehost/git.go b/src/cmd/go/internal/modfetch/codehost/git.go index 2a5255f115..34f453c855 100644 --- a/src/cmd/go/internal/modfetch/codehost/git.go +++ b/src/cmd/go/internal/modfetch/codehost/git.go @@ -56,7 +56,7 @@ func newGitRepoCached(remote string, localOK bool) (Repo, error) { err error } - c := gitRepoCache.Do(key{remote, localOK}, func() interface{} { + c := gitRepoCache.Do(key{remote, localOK}, func() any { repo, err := newGitRepo(remote, localOK) return cached{repo, err} }).(cached) @@ -503,7 +503,7 @@ func (r *gitRepo) Stat(rev string) (*RevInfo, error) { info *RevInfo err error } - c := r.statCache.Do(rev, func() interface{} { + c := r.statCache.Do(rev, func() any { info, err := r.stat(rev) return cached{info, err} }).(cached) diff --git a/src/cmd/go/internal/modfetch/codehost/vcs.go b/src/cmd/go/internal/modfetch/codehost/vcs.go index c8449ccdcc..de62265efc 100644 --- a/src/cmd/go/internal/modfetch/codehost/vcs.go +++ b/src/cmd/go/internal/modfetch/codehost/vcs.go @@ -38,7 +38,7 @@ type VCSError struct { func (e *VCSError) Error() string { return e.Err.Error() } -func vcsErrorf(format string, a ...interface{}) error { +func vcsErrorf(format string, a ...any) error { return &VCSError{Err: fmt.Errorf(format, a...)} } @@ -51,7 +51,7 @@ func NewRepo(vcs, remote string) (Repo, error) { repo Repo err error } - c := vcsRepoCache.Do(key{vcs, remote}, func() interface{} { + c := vcsRepoCache.Do(key{vcs, remote}, func() any { repo, err := newVCSRepo(vcs, remote) if err != nil { err = &VCSError{err} diff --git a/src/cmd/go/internal/modfetch/coderepo.go b/src/cmd/go/internal/modfetch/coderepo.go index df835c3d7e..79da010809 100644 --- a/src/cmd/go/internal/modfetch/coderepo.go +++ b/src/cmd/go/internal/modfetch/coderepo.go @@ -321,7 +321,7 @@ func (r *codeRepo) convert(info *codehost.RevInfo, statVers string) (*RevInfo, e return ok } - invalidf := func(format string, args ...interface{}) error { + invalidf := func(format string, args ...any) error { return &module.ModuleError{ Path: r.modPath, Err: &module.InvalidVersionError{ @@ -1066,7 +1066,7 @@ func (fi dataFileInfo) Size() int64 { return int64(len(fi.f.data)) } func (fi dataFileInfo) Mode() fs.FileMode { return 0644 } func (fi dataFileInfo) ModTime() time.Time { return time.Time{} } func (fi dataFileInfo) IsDir() bool { return false } -func (fi dataFileInfo) Sys() interface{} { return nil } +func (fi dataFileInfo) Sys() any { return nil } // hasPathPrefix reports whether the path s begins with the // elements in prefix. diff --git a/src/cmd/go/internal/modfetch/fetch.go b/src/cmd/go/internal/modfetch/fetch.go index e246c1a04d..12b7431570 100644 --- a/src/cmd/go/internal/modfetch/fetch.go +++ b/src/cmd/go/internal/modfetch/fetch.go @@ -48,7 +48,7 @@ func Download(ctx context.Context, mod module.Version) (dir string, err error) { dir string err error } - c := downloadCache.Do(mod, func() interface{} { + c := downloadCache.Do(mod, func() any { dir, err := download(ctx, mod) if err != nil { return cached{"", err} @@ -165,7 +165,7 @@ func DownloadZip(ctx context.Context, mod module.Version) (zipfile string, err e zipfile string err error } - c := downloadZipCache.Do(mod, func() interface{} { + c := downloadZipCache.Do(mod, func() any { zipfile, err := CachePath(mod, "zip") if err != nil { return cached{"", err} diff --git a/src/cmd/go/internal/modfetch/repo.go b/src/cmd/go/internal/modfetch/repo.go index 0bffa55af6..1b42ecb6ed 100644 --- a/src/cmd/go/internal/modfetch/repo.go +++ b/src/cmd/go/internal/modfetch/repo.go @@ -196,7 +196,7 @@ func Lookup(proxy, path string) Repo { type cached struct { r Repo } - c := lookupCache.Do(lookupCacheKey{proxy, path}, func() interface{} { + c := lookupCache.Do(lookupCacheKey{proxy, path}, func() any { r := newCachingRepo(path, func() (Repo, error) { r, err := lookup(proxy, path) if err == nil && traceRepo { @@ -308,7 +308,7 @@ func newLoggingRepo(r Repo) *loggingRepo { // defer logCall("hello %s", arg)() // // Note the final (). -func logCall(format string, args ...interface{}) func() { +func logCall(format string, args ...any) func() { start := time.Now() fmt.Fprintf(os.Stderr, "+++ %s\n", fmt.Sprintf(format, args...)) return func() { @@ -371,7 +371,7 @@ type notExistError struct { err error } -func notExistErrorf(format string, args ...interface{}) error { +func notExistErrorf(format string, args ...any) error { return notExistError{fmt.Errorf(format, args...)} } diff --git a/src/cmd/go/internal/modget/get.go b/src/cmd/go/internal/modget/get.go index 893cc92e39..3d8463e892 100644 --- a/src/cmd/go/internal/modget/get.go +++ b/src/cmd/go/internal/modget/get.go @@ -601,7 +601,7 @@ func (r *resolver) matchInModule(ctx context.Context, pattern string, m module.V err error } - e := r.matchInModuleCache.Do(key{pattern, m}, func() interface{} { + e := r.matchInModuleCache.Do(key{pattern, m}, func() any { match := modload.MatchInModule(ctx, pattern, m, imports.AnyTags()) if len(match.Errs) > 0 { return entry{match.Pkgs, match.Errs[0]} @@ -893,7 +893,7 @@ func (r *resolver) checkWildcardVersions(ctx context.Context) { // curM at its original version contains a path matching q.pattern, // but at rev.Version it does not, so (somewhat paradoxically) if // we changed the version of curM it would no longer match the query. - var version interface{} = m + var version any = m if rev.Version != q.version { version = fmt.Sprintf("%s@%s (%s)", m.Path, q.version, m.Version) } diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go index 4ce71fef5b..45be51f1c6 100644 --- a/src/cmd/go/internal/modload/buildlist.go +++ b/src/cmd/go/internal/modload/buildlist.go @@ -326,7 +326,7 @@ func readModGraph(ctx context.Context, pruning modPruning, roots []module.Versio // It does not load the transitive requirements of m even if the go version in // m's go.mod file indicates that it supports graph pruning. loadOne := func(m module.Version) (*modFileSummary, error) { - cached := mg.loadCache.Do(m, func() interface{} { + cached := mg.loadCache.Do(m, func() any { summary, err := goModSummary(m) mu.Lock() diff --git a/src/cmd/go/internal/modload/import.go b/src/cmd/go/internal/modload/import.go index bc2b0a0230..812e48a156 100644 --- a/src/cmd/go/internal/modload/import.go +++ b/src/cmd/go/internal/modload/import.go @@ -612,7 +612,7 @@ func dirInModule(path, mpath, mdir string, isLocal bool) (dir string, haveGoFile // (the main module, and any directory trees pointed at by replace directives). if isLocal { for d := dir; d != mdir && len(d) > len(mdir); { - haveGoMod := haveGoModCache.Do(d, func() interface{} { + haveGoMod := haveGoModCache.Do(d, func() any { fi, err := fsys.Stat(filepath.Join(d, "go.mod")) return err == nil && !fi.IsDir() }).(bool) @@ -635,7 +635,7 @@ func dirInModule(path, mpath, mdir string, isLocal bool) (dir string, haveGoFile // Are there Go source files in the directory? // We don't care about build tags, not even "+build ignore". // We're just looking for a plausible directory. - res := haveGoFilesCache.Do(dir, func() interface{} { + res := haveGoFilesCache.Do(dir, func() any { ok, err := fsys.IsDirWithGoFiles(dir) return goFilesEntry{haveGoFiles: ok, err: err} }).(goFilesEntry) diff --git a/src/cmd/go/internal/modload/load.go b/src/cmd/go/internal/modload/load.go index 5e7075da4e..617b634d26 100644 --- a/src/cmd/go/internal/modload/load.go +++ b/src/cmd/go/internal/modload/load.go @@ -859,7 +859,7 @@ func (ld *loader) reset() { // errorf reports an error via either os.Stderr or base.Errorf, // according to whether ld.AllowErrors is set. -func (ld *loader) errorf(format string, args ...interface{}) { +func (ld *loader) errorf(format string, args ...any) { if ld.AllowErrors { fmt.Fprintf(os.Stderr, format, args...) } else { @@ -1492,7 +1492,7 @@ func (ld *loader) pkg(ctx context.Context, path string, flags loadPkgFlags) *loa panic("internal error: (*loader).pkg called with pkgImportsLoaded flag set") } - pkg := ld.pkgCache.Do(path, func() interface{} { + pkg := ld.pkgCache.Do(path, func() any { pkg := &loadPkg{ path: path, } diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go index 40e6ed787d..ec3f57ae3e 100644 --- a/src/cmd/go/internal/modload/modfile.go +++ b/src/cmd/go/internal/modload/modfile.go @@ -664,7 +664,7 @@ func rawGoModSummary(m module.Version) (*modFileSummary, error) { summary *modFileSummary err error } - c := rawGoModSummaryCache.Do(key{m}, func() interface{} { + c := rawGoModSummaryCache.Do(key{m}, func() any { summary := new(modFileSummary) name, data, err := rawGoModData(m) if err != nil { @@ -766,7 +766,7 @@ func queryLatestVersionIgnoringRetractions(ctx context.Context, path string) (la latest module.Version err error } - e := latestVersionIgnoringRetractionsCache.Do(path, func() interface{} { + e := latestVersionIgnoringRetractionsCache.Do(path, func() any { ctx, span := trace.StartSpan(ctx, "queryLatestVersionIgnoringRetractions "+path) defer span.Done() diff --git a/src/cmd/go/internal/modload/vendor.go b/src/cmd/go/internal/modload/vendor.go index a735cad905..5ea82a8620 100644 --- a/src/cmd/go/internal/modload/vendor.go +++ b/src/cmd/go/internal/modload/vendor.go @@ -147,7 +147,7 @@ func checkVendorConsistency(index *modFileIndex, modFile *modfile.File) { } vendErrors := new(strings.Builder) - vendErrorf := func(mod module.Version, format string, args ...interface{}) { + vendErrorf := func(mod module.Version, format string, args ...any) { detail := fmt.Sprintf(format, args...) if mod.Version == "" { fmt.Fprintf(vendErrors, "\n\t%s: %s", mod.Path, detail) diff --git a/src/cmd/go/internal/mvs/mvs.go b/src/cmd/go/internal/mvs/mvs.go index 566fa4b6b3..d25d447b0e 100644 --- a/src/cmd/go/internal/mvs/mvs.go +++ b/src/cmd/go/internal/mvs/mvs.go @@ -114,7 +114,7 @@ func buildList(targets []module.Version, reqs Reqs, upgrade func(module.Version) for _, target := range targets { work.Add(target) } - work.Do(10, func(item interface{}) { + work.Do(10, func(item any) { m := item.(module.Version) var required []module.Version diff --git a/src/cmd/go/internal/par/work.go b/src/cmd/go/internal/par/work.go index 960cec6fb1..496c41b150 100644 --- a/src/cmd/go/internal/par/work.go +++ b/src/cmd/go/internal/par/work.go @@ -14,24 +14,24 @@ import ( // Work manages a set of work items to be executed in parallel, at most once each. // The items in the set must all be valid map keys. type Work struct { - f func(interface{}) // function to run for each item - running int // total number of runners + f func(any) // function to run for each item + running int // total number of runners mu sync.Mutex - added map[interface{}]bool // items added to set - todo []interface{} // items yet to be run - wait sync.Cond // wait when todo is empty - waiting int // number of runners waiting for todo + added map[any]bool // items added to set + todo []any // items yet to be run + wait sync.Cond // wait when todo is empty + waiting int // number of runners waiting for todo } func (w *Work) init() { if w.added == nil { - w.added = make(map[interface{}]bool) + w.added = make(map[any]bool) } } // Add adds item to the work set, if it hasn't already been added. -func (w *Work) Add(item interface{}) { +func (w *Work) Add(item any) { w.mu.Lock() w.init() if !w.added[item] { @@ -51,7 +51,7 @@ func (w *Work) Add(item interface{}) { // before calling Do (or else Do returns immediately), // but it is allowed for f(item) to add new items to the set. // Do should only be used once on a given Work. -func (w *Work) Do(n int, f func(item interface{})) { +func (w *Work) Do(n int, f func(item any)) { if n < 1 { panic("par.Work.Do: n < 1") } @@ -110,13 +110,13 @@ type Cache struct { type cacheEntry struct { done uint32 mu sync.Mutex - result interface{} + result any } // Do calls the function f if and only if Do is being called for the first time with this key. // No call to Do with a given key returns until the one call to f returns. // Do returns the value returned by the one call to f. -func (c *Cache) Do(key interface{}, f func() interface{}) interface{} { +func (c *Cache) Do(key any, f func() any) any { entryIface, ok := c.m.Load(key) if !ok { entryIface, _ = c.m.LoadOrStore(key, new(cacheEntry)) @@ -136,7 +136,7 @@ func (c *Cache) Do(key interface{}, f func() interface{}) interface{} { // Get returns the cached result associated with key. // It returns nil if there is no such result. // If the result for key is being computed, Get does not wait for the computation to finish. -func (c *Cache) Get(key interface{}) interface{} { +func (c *Cache) Get(key any) any { entryIface, ok := c.m.Load(key) if !ok { return nil @@ -156,7 +156,7 @@ func (c *Cache) Get(key interface{}) interface{} { // TODO(jayconrod): Delete this after the package cache clearing functions // in internal/load have been removed. func (c *Cache) Clear() { - c.m.Range(func(key, value interface{}) bool { + c.m.Range(func(key, value any) bool { c.m.Delete(key) return true }) @@ -169,7 +169,7 @@ func (c *Cache) Clear() { // // TODO(jayconrod): Delete this after the package cache clearing functions // in internal/load have been removed. -func (c *Cache) Delete(key interface{}) { +func (c *Cache) Delete(key any) { c.m.Delete(key) } @@ -180,8 +180,8 @@ func (c *Cache) Delete(key interface{}) { // // TODO(jayconrod): Delete this after the package cache clearing functions // in internal/load have been removed. -func (c *Cache) DeleteIf(pred func(key interface{}) bool) { - c.m.Range(func(key, _ interface{}) bool { +func (c *Cache) DeleteIf(pred func(key any) bool) { + c.m.Range(func(key, _ any) bool { if pred(key) { c.Delete(key) } diff --git a/src/cmd/go/internal/par/work_test.go b/src/cmd/go/internal/par/work_test.go index f104bc4106..add0e640d8 100644 --- a/src/cmd/go/internal/par/work_test.go +++ b/src/cmd/go/internal/par/work_test.go @@ -16,7 +16,7 @@ func TestWork(t *testing.T) { const N = 10000 n := int32(0) w.Add(N) - w.Do(100, func(x interface{}) { + w.Do(100, func(x any) { atomic.AddInt32(&n, 1) i := x.(int) if i >= 2 { @@ -40,7 +40,7 @@ func TestWorkParallel(t *testing.T) { } start := time.Now() var n int32 - w.Do(N, func(x interface{}) { + w.Do(N, func(x any) { time.Sleep(1 * time.Millisecond) atomic.AddInt32(&n, +1) }) @@ -58,19 +58,19 @@ func TestCache(t *testing.T) { var cache Cache n := 1 - v := cache.Do(1, func() interface{} { n++; return n }) + v := cache.Do(1, func() any { n++; return n }) if v != 2 { t.Fatalf("cache.Do(1) did not run f") } - v = cache.Do(1, func() interface{} { n++; return n }) + v = cache.Do(1, func() any { n++; return n }) if v != 2 { t.Fatalf("cache.Do(1) ran f again!") } - v = cache.Do(2, func() interface{} { n++; return n }) + v = cache.Do(2, func() any { n++; return n }) if v != 3 { t.Fatalf("cache.Do(2) did not run f") } - v = cache.Do(1, func() interface{} { n++; return n }) + v = cache.Do(1, func() any { n++; return n }) if v != 2 { t.Fatalf("cache.Do(1) did not returned saved value from original cache.Do(1)") } diff --git a/src/cmd/go/internal/run/run.go b/src/cmd/go/internal/run/run.go index 878cee367e..c4b70b64fe 100644 --- a/src/cmd/go/internal/run/run.go +++ b/src/cmd/go/internal/run/run.go @@ -69,7 +69,7 @@ func init() { CmdRun.Flag.Var((*base.StringsFlag)(&work.ExecCmd), "exec", "") } -func printStderr(args ...interface{}) (int, error) { +func printStderr(args ...any) (int, error) { return fmt.Fprint(os.Stderr, args...) } diff --git a/src/cmd/go/internal/str/str.go b/src/cmd/go/internal/str/str.go index 5bc521b9df..021bfbff77 100644 --- a/src/cmd/go/internal/str/str.go +++ b/src/cmd/go/internal/str/str.go @@ -14,7 +14,7 @@ import ( // StringList flattens its arguments into a single []string. // Each argument in args must have type string or []string. -func StringList(args ...interface{}) []string { +func StringList(args ...any) []string { var x []string for _, arg := range args { switch arg := arg.(type) { diff --git a/src/cmd/go/internal/vcs/vcs.go b/src/cmd/go/internal/vcs/vcs.go index 77a75fd51c..313dc62b78 100644 --- a/src/cmd/go/internal/vcs/vcs.go +++ b/src/cmd/go/internal/vcs/vcs.go @@ -1311,7 +1311,7 @@ func metaImportsForPrefix(importPrefix string, mod ModuleMode, security web.Secu return res, nil } - resi, _, _ := fetchGroup.Do(importPrefix, func() (resi interface{}, err error) { + resi, _, _ := fetchGroup.Do(importPrefix, func() (resi any, err error) { fetchCacheMu.Lock() if res, ok := fetchCache[importPrefix]; ok { fetchCacheMu.Unlock() @@ -1588,7 +1588,7 @@ type importError struct { err error } -func importErrorf(path, format string, args ...interface{}) error { +func importErrorf(path, format string, args ...any) error { err := &importError{importPath: path, err: fmt.Errorf(format, args...)} if errStr := err.Error(); !strings.Contains(errStr, path) { panic(fmt.Sprintf("path %q not in error %q", path, errStr)) diff --git a/src/cmd/go/internal/work/action.go b/src/cmd/go/internal/work/action.go index 6f5ac1364c..c0862c5efe 100644 --- a/src/cmd/go/internal/work/action.go +++ b/src/cmd/go/internal/work/action.go @@ -37,7 +37,7 @@ type Builder struct { actionCache map[cacheKey]*Action // a cache of already-constructed actions mkdirCache map[string]bool // a cache of created directories flagCache map[[2]string]bool // a cache of supported compiler flags - Print func(args ...interface{}) (int, error) + Print func(args ...any) (int, error) IsCmdList bool // running as part of go list; set p.Stale and additional fields below NeedError bool // list needs p.Error @@ -120,8 +120,8 @@ type actionQueue []*Action func (q *actionQueue) Len() int { return len(*q) } func (q *actionQueue) Swap(i, j int) { (*q)[i], (*q)[j] = (*q)[j], (*q)[i] } func (q *actionQueue) Less(i, j int) bool { return (*q)[i].priority < (*q)[j].priority } -func (q *actionQueue) Push(x interface{}) { *q = append(*q, x.(*Action)) } -func (q *actionQueue) Pop() interface{} { +func (q *actionQueue) Push(x any) { *q = append(*q, x.(*Action)) } +func (q *actionQueue) Pop() any { n := len(*q) - 1 x := (*q)[n] *q = (*q)[:n] @@ -241,7 +241,7 @@ const ( ) func (b *Builder) Init() { - b.Print = func(a ...interface{}) (int, error) { + b.Print = func(a ...any) (int, error) { return fmt.Fprint(os.Stderr, a...) } b.actionCache = make(map[cacheKey]*Action) diff --git a/src/cmd/go/internal/work/build_test.go b/src/cmd/go/internal/work/build_test.go index 600fc3083f..0b6b83a706 100644 --- a/src/cmd/go/internal/work/build_test.go +++ b/src/cmd/go/internal/work/build_test.go @@ -234,7 +234,7 @@ func TestRespectSetgidDir(t *testing.T) { // of `(*Builder).ShowCmd` afterwards as a sanity check. cfg.BuildX = true var cmdBuf bytes.Buffer - b.Print = func(a ...interface{}) (int, error) { + b.Print = func(a ...any) (int, error) { return cmdBuf.WriteString(fmt.Sprint(a...)) } diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go index 2c040b8ff4..ccd5aee221 100644 --- a/src/cmd/go/internal/work/exec.go +++ b/src/cmd/go/internal/work/exec.go @@ -1948,7 +1948,7 @@ func mayberemovefile(s string) { // fmtcmd replaces the name of the current directory with dot (.) // but only when it is at the beginning of a space-separated token. // -func (b *Builder) fmtcmd(dir string, format string, args ...interface{}) string { +func (b *Builder) fmtcmd(dir string, format string, args ...any) string { cmd := fmt.Sprintf(format, args...) if dir != "" && dir != "/" { dot := " ." @@ -1974,7 +1974,7 @@ func (b *Builder) fmtcmd(dir string, format string, args ...interface{}) string // showcmd prints the given command to standard output // for the implementation of -n or -x. -func (b *Builder) Showcmd(dir string, format string, args ...interface{}) { +func (b *Builder) Showcmd(dir string, format string, args ...any) { b.output.Lock() defer b.output.Unlock() b.Print(b.fmtcmd(dir, format, args...) + "\n") @@ -2038,7 +2038,7 @@ var cgoTypeSigRe = lazyregexp.New(`\b_C2?(type|func|var|macro)_\B`) // run runs the command given by cmdline in the directory dir. // If the command fails, run prints information about the failure // and returns a non-nil error. -func (b *Builder) run(a *Action, dir string, desc string, env []string, cmdargs ...interface{}) error { +func (b *Builder) run(a *Action, dir string, desc string, env []string, cmdargs ...any) error { out, err := b.runOut(a, dir, env, cmdargs...) if len(out) > 0 { if desc == "" { @@ -2072,7 +2072,7 @@ func (b *Builder) processOutput(out []byte) string { // runOut runs the command given by cmdline in the directory dir. // It returns the command output and any errors that occurred. // It accumulates execution time in a. -func (b *Builder) runOut(a *Action, dir string, env []string, cmdargs ...interface{}) ([]byte, error) { +func (b *Builder) runOut(a *Action, dir string, env []string, cmdargs ...any) ([]byte, error) { cmdline := str.StringList(cmdargs...) for _, arg := range cmdline { @@ -2409,7 +2409,7 @@ func (b *Builder) gccld(a *Action, p *load.Package, objdir, outfile string, flag cmd = b.GccCmd(p.Dir, objdir) } - cmdargs := []interface{}{cmd, "-o", outfile, objs, flags} + cmdargs := []any{cmd, "-o", outfile, objs, flags} dir := p.Dir out, err := b.runOut(a, base.Cwd(), b.cCompilerEnv(), cmdargs...) diff --git a/src/cmd/go/internal/work/gc.go b/src/cmd/go/internal/work/gc.go index e3b4a817e7..40175324d2 100644 --- a/src/cmd/go/internal/work/gc.go +++ b/src/cmd/go/internal/work/gc.go @@ -165,7 +165,7 @@ func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg gcflags = append(gcflags, fmt.Sprintf("-c=%d", c)) } - args := []interface{}{cfg.BuildToolexec, base.Tool("compile"), "-o", ofile, "-trimpath", a.trimpath(), defaultGcFlags, gcflags} + args := []any{cfg.BuildToolexec, base.Tool("compile"), "-o", ofile, "-trimpath", a.trimpath(), defaultGcFlags, gcflags} if p.Internal.LocalPrefix == "" { args = append(args, "-nolocalimports") } else { @@ -362,11 +362,11 @@ func (a *Action) trimpath() string { return rewrite } -func asmArgs(a *Action, p *load.Package) []interface{} { +func asmArgs(a *Action, p *load.Package) []any { // Add -I pkg/GOOS_GOARCH so #include "textflag.h" works in .s files. inc := filepath.Join(cfg.GOROOT, "pkg", "include") pkgpath := pkgPath(a) - args := []interface{}{cfg.BuildToolexec, base.Tool("asm"), "-p", pkgpath, "-trimpath", a.trimpath(), "-I", a.Objdir, "-I", inc, "-D", "GOOS_" + cfg.Goos, "-D", "GOARCH_" + cfg.Goarch, forcedAsmflags, p.Internal.Asmflags} + args := []any{cfg.BuildToolexec, base.Tool("asm"), "-p", pkgpath, "-trimpath", a.trimpath(), "-I", a.Objdir, "-I", inc, "-D", "GOOS_" + cfg.Goos, "-D", "GOARCH_" + cfg.Goarch, forcedAsmflags, p.Internal.Asmflags} if p.ImportPath == "runtime" && cfg.Goarch == "386" { for _, arg := range forcedAsmflags { if arg == "-dynlink" { @@ -455,8 +455,8 @@ func (gcToolchain) symabis(b *Builder, a *Action, sfiles []string) (string, erro // toolVerify checks that the command line args writes the same output file // if run using newTool instead. // Unused now but kept around for future use. -func toolVerify(a *Action, b *Builder, p *load.Package, newTool string, ofile string, args []interface{}) error { - newArgs := make([]interface{}, len(args)) +func toolVerify(a *Action, b *Builder, p *load.Package, newTool string, ofile string, args []any) error { + newArgs := make([]any, len(args)) copy(newArgs, args) newArgs[1] = base.Tool(newTool) newArgs[3] = ofile + ".new" // x.6 becomes x.6.new diff --git a/src/cmd/go/proxy_test.go b/src/cmd/go/proxy_test.go index a387fe67db..517a885542 100644 --- a/src/cmd/go/proxy_test.go +++ b/src/cmd/go/proxy_test.go @@ -357,7 +357,7 @@ func proxyHandler(w http.ResponseWriter, r *http.Request) { zip []byte err error } - c := zipCache.Do(a, func() interface{} { + c := zipCache.Do(a, func() any { var buf bytes.Buffer z := zip.NewWriter(&buf) for _, f := range a.Files { @@ -431,7 +431,7 @@ func readArchive(path, vers string) (*txtar.Archive, error) { prefix := strings.ReplaceAll(enc, "/", "_") name := filepath.Join(cmdGoDir, "testdata/mod", prefix+"_"+encVers+".txt") - a := archiveCache.Do(name, func() interface{} { + a := archiveCache.Do(name, func() any { a, err := txtar.ParseFile(name) if err != nil { if testing.Verbose() || !os.IsNotExist(err) { diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go index 101195fc9d..dbfba2291c 100644 --- a/src/cmd/go/script_test.go +++ b/src/cmd/go/script_test.go @@ -375,7 +375,7 @@ Script: default: if strings.HasPrefix(cond.tag, "exec:") { prog := cond.tag[len("exec:"):] - ok = execCache.Do(prog, func() interface{} { + ok = execCache.Do(prog, func() any { if runtime.GOOS == "plan9" && prog == "git" { // The Git command is usually not the real Git on Plan 9. // See https://golang.org/issues/29640. @@ -1310,7 +1310,7 @@ func (ts *testScript) expand(s string, inRegexp bool) string { } // fatalf aborts the test with the given failure message. -func (ts *testScript) fatalf(format string, args ...interface{}) { +func (ts *testScript) fatalf(format string, args ...any) { fmt.Fprintf(&ts.log, "FAIL: %s:%d: %s\n", ts.file, ts.lineno, fmt.Sprintf(format, args...)) ts.t.FailNow() } diff --git a/src/cmd/go/testdata/addmod.go b/src/cmd/go/testdata/addmod.go index a1ace4ce59..eac2a7ad44 100644 --- a/src/cmd/go/testdata/addmod.go +++ b/src/cmd/go/testdata/addmod.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build ignore // +build ignore // Addmod adds a module as a txtar archive to the testdata/mod directory. @@ -39,7 +40,7 @@ func usage() { var tmpdir string -func fatalf(format string, args ...interface{}) { +func fatalf(format string, args ...any) { os.RemoveAll(tmpdir) log.Fatalf(format, args...) } diff --git a/src/cmd/go/testdata/savedir.go b/src/cmd/go/testdata/savedir.go index 6a8a232702..53c78cfb00 100644 --- a/src/cmd/go/testdata/savedir.go +++ b/src/cmd/go/testdata/savedir.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build ignore // +build ignore // Savedir archives a directory tree as a txtar archive printed to standard output. diff --git a/src/cmd/go/testdata/testterminal18153/terminal_test.go b/src/cmd/go/testdata/testterminal18153/terminal_test.go index 71493efe98..34ee580c0e 100644 --- a/src/cmd/go/testdata/testterminal18153/terminal_test.go +++ b/src/cmd/go/testdata/testterminal18153/terminal_test.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build linux // +build linux // This test is run by src/cmd/dist/test.go (cmd_go_test_terminal), diff --git a/src/cmd/gofmt/gofmt.go b/src/cmd/gofmt/gofmt.go index 860d77aaf0..51f6e652d9 100644 --- a/src/cmd/gofmt/gofmt.go +++ b/src/cmd/gofmt/gofmt.go @@ -183,7 +183,7 @@ func (r *reporter) getState() *reporterState { // Warnf emits a warning message to the reporter's error stream, // without changing its exit code. -func (r *reporter) Warnf(format string, args ...interface{}) { +func (r *reporter) Warnf(format string, args ...any) { fmt.Fprintf(r.getState().err, format, args...) } diff --git a/src/cmd/internal/buildid/buildid_test.go b/src/cmd/internal/buildid/buildid_test.go index 4895a49e11..f04e328046 100644 --- a/src/cmd/internal/buildid/buildid_test.go +++ b/src/cmd/internal/buildid/buildid_test.go @@ -103,7 +103,7 @@ func TestFindAndHash(t *testing.T) { id[i] = byte(i) } numError := 0 - errorf := func(msg string, args ...interface{}) { + errorf := func(msg string, args ...any) { t.Errorf(msg, args...) if numError++; numError > 20 { t.Logf("stopping after too many errors") diff --git a/src/cmd/internal/buildid/rewrite.go b/src/cmd/internal/buildid/rewrite.go index 8814950db0..becc078242 100644 --- a/src/cmd/internal/buildid/rewrite.go +++ b/src/cmd/internal/buildid/rewrite.go @@ -151,7 +151,7 @@ func (r *excludedReader) Read(p []byte) (int, error) { return n, err } -func findMachoCodeSignature(r interface{}) (*macho.File, codesign.CodeSigCmd, bool) { +func findMachoCodeSignature(r any) (*macho.File, codesign.CodeSigCmd, bool) { ra, ok := r.(io.ReaderAt) if !ok { return nil, codesign.CodeSigCmd{}, false diff --git a/src/cmd/internal/test2json/test2json_test.go b/src/cmd/internal/test2json/test2json_test.go index 4683907888..e69739d3fe 100644 --- a/src/cmd/internal/test2json/test2json_test.go +++ b/src/cmd/internal/test2json/test2json_test.go @@ -145,7 +145,7 @@ func writeAndKill(w io.Writer, b []byte) { // and fails the test with a useful message if they don't match. func diffJSON(t *testing.T, have, want []byte) { t.Helper() - type event map[string]interface{} + type event map[string]any // Parse into events, one per line. parseEvents := func(b []byte) ([]event, []string) { diff --git a/src/cmd/internal/traceviewer/format.go b/src/cmd/internal/traceviewer/format.go index 871477447f..3636c1053d 100644 --- a/src/cmd/internal/traceviewer/format.go +++ b/src/cmd/internal/traceviewer/format.go @@ -16,20 +16,20 @@ type Data struct { } type Event struct { - Name string `json:"name,omitempty"` - Phase string `json:"ph"` - Scope string `json:"s,omitempty"` - Time float64 `json:"ts"` - Dur float64 `json:"dur,omitempty"` - PID uint64 `json:"pid"` - TID uint64 `json:"tid"` - ID uint64 `json:"id,omitempty"` - BindPoint string `json:"bp,omitempty"` - Stack int `json:"sf,omitempty"` - EndStack int `json:"esf,omitempty"` - Arg interface{} `json:"args,omitempty"` - Cname string `json:"cname,omitempty"` - Category string `json:"cat,omitempty"` + Name string `json:"name,omitempty"` + Phase string `json:"ph"` + Scope string `json:"s,omitempty"` + Time float64 `json:"ts"` + Dur float64 `json:"dur,omitempty"` + PID uint64 `json:"pid"` + TID uint64 `json:"tid"` + ID uint64 `json:"id,omitempty"` + BindPoint string `json:"bp,omitempty"` + Stack int `json:"sf,omitempty"` + EndStack int `json:"esf,omitempty"` + Arg any `json:"args,omitempty"` + Cname string `json:"cname,omitempty"` + Category string `json:"cat,omitempty"` } type Frame struct { diff --git a/src/cmd/nm/nm.go b/src/cmd/nm/nm.go index 457239921b..178eeb27be 100644 --- a/src/cmd/nm/nm.go +++ b/src/cmd/nm/nm.go @@ -93,7 +93,7 @@ func main() { var exitCode = 0 -func errorf(format string, args ...interface{}) { +func errorf(format string, args ...any) { log.Printf(format, args...) exitCode = 1 } diff --git a/src/cmd/pack/pack_test.go b/src/cmd/pack/pack_test.go index 7842b562dc..81e78f53e2 100644 --- a/src/cmd/pack/pack_test.go +++ b/src/cmd/pack/pack_test.go @@ -203,7 +203,7 @@ func TestLargeDefs(t *testing.T) { } b := bufio.NewWriter(f) - printf := func(format string, args ...interface{}) { + printf := func(format string, args ...any) { _, err := fmt.Fprintf(b, format, args...) if err != nil { t.Fatalf("Writing to %s: %v", large, err) @@ -454,7 +454,7 @@ func (f *FakeFile) IsDir() bool { return false } -func (f *FakeFile) Sys() interface{} { +func (f *FakeFile) Sys() any { return nil } diff --git a/src/cmd/pprof/readlineui.go b/src/cmd/pprof/readlineui.go index 7ad712cd60..b269177650 100644 --- a/src/cmd/pprof/readlineui.go +++ b/src/cmd/pprof/readlineui.go @@ -69,18 +69,18 @@ func (r *readlineUI) ReadLine(prompt string) (string, error) { // It formats the text as fmt.Print would and adds a final \n if not already present. // For line-based UI, Print writes to standard error. // (Standard output is reserved for report data.) -func (r *readlineUI) Print(args ...interface{}) { +func (r *readlineUI) Print(args ...any) { r.print(false, args...) } // PrintErr shows an error message to the user. // It formats the text as fmt.Print would and adds a final \n if not already present. // For line-based UI, PrintErr writes to standard error. -func (r *readlineUI) PrintErr(args ...interface{}) { +func (r *readlineUI) PrintErr(args ...any) { r.print(true, args...) } -func (r *readlineUI) print(withColor bool, args ...interface{}) { +func (r *readlineUI) print(withColor bool, args ...any) { text := fmt.Sprint(args...) if !strings.HasSuffix(text, "\n") { text += "\n" diff --git a/src/cmd/trace/main.go b/src/cmd/trace/main.go index 3aeba223ee..a30db9a012 100644 --- a/src/cmd/trace/main.go +++ b/src/cmd/trace/main.go @@ -206,7 +206,7 @@ var templMain = template.Must(template.New("").Parse(` `)) -func dief(msg string, args ...interface{}) { +func dief(msg string, args ...any) { fmt.Fprintf(os.Stderr, msg, args...) os.Exit(1) } diff --git a/src/cmd/trace/mmu.go b/src/cmd/trace/mmu.go index 1d1fd2ea94..b71dcd6411 100644 --- a/src/cmd/trace/mmu.go +++ b/src/cmd/trace/mmu.go @@ -155,7 +155,7 @@ func httpMMUPlot(w http.ResponseWriter, r *http.Request) { } // Create JSON response. - err = json.NewEncoder(w).Encode(map[string]interface{}{"xMin": int64(xMin), "xMax": int64(xMax), "quantiles": quantiles, "curve": plot}) + err = json.NewEncoder(w).Encode(map[string]any{"xMin": int64(xMin), "xMax": int64(xMax), "quantiles": quantiles, "curve": plot}) if err != nil { log.Printf("failed to serialize response: %v", err) return diff --git a/src/cmd/trace/trace.go b/src/cmd/trace/trace.go index ca10736c32..0139639dae 100644 --- a/src/cmd/trace/trace.go +++ b/src/cmd/trace/trace.go @@ -1054,7 +1054,7 @@ func (ctx *traceContext) emitInstant(ev *trace.Event, name, category string) { cname = colorLightGrey } } - var arg interface{} + var arg any if ev.Type == trace.EvProcStart { type Arg struct { ThreadID uint64 diff --git a/src/container/heap/example_intheap_test.go b/src/container/heap/example_intheap_test.go index 02d3d8668e..7e7ef8b8df 100644 --- a/src/container/heap/example_intheap_test.go +++ b/src/container/heap/example_intheap_test.go @@ -17,13 +17,13 @@ func (h IntHeap) Len() int { return len(h) } func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] } func (h IntHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } -func (h *IntHeap) Push(x interface{}) { +func (h *IntHeap) Push(x any) { // Push and Pop use pointer receivers because they modify the slice's length, // not just its contents. *h = append(*h, x.(int)) } -func (h *IntHeap) Pop() interface{} { +func (h *IntHeap) Pop() any { old := *h n := len(old) x := old[n-1] diff --git a/src/container/heap/example_pq_test.go b/src/container/heap/example_pq_test.go index da1a233b70..4511b6c33e 100644 --- a/src/container/heap/example_pq_test.go +++ b/src/container/heap/example_pq_test.go @@ -34,14 +34,14 @@ func (pq PriorityQueue) Swap(i, j int) { pq[j].index = j } -func (pq *PriorityQueue) Push(x interface{}) { +func (pq *PriorityQueue) Push(x any) { n := len(*pq) item := x.(*Item) item.index = n *pq = append(*pq, item) } -func (pq *PriorityQueue) Pop() interface{} { +func (pq *PriorityQueue) Pop() any { old := *pq n := len(old) item := old[n-1] diff --git a/src/container/heap/heap.go b/src/container/heap/heap.go index 2e09da8613..c3168f9b27 100644 --- a/src/container/heap/heap.go +++ b/src/container/heap/heap.go @@ -31,8 +31,8 @@ import "sort" // use heap.Push and heap.Pop. type Interface interface { sort.Interface - Push(x interface{}) // add x as element Len() - Pop() interface{} // remove and return element Len() - 1. + Push(x any) // add x as element Len() + Pop() any // remove and return element Len() - 1. } // Init establishes the heap invariants required by the other routines in this package. @@ -49,7 +49,7 @@ func Init(h Interface) { // Push pushes the element x onto the heap. // The complexity is O(log n) where n = h.Len(). -func Push(h Interface, x interface{}) { +func Push(h Interface, x any) { h.Push(x) up(h, h.Len()-1) } @@ -57,7 +57,7 @@ func Push(h Interface, x interface{}) { // Pop removes and returns the minimum element (according to Less) from the heap. // The complexity is O(log n) where n = h.Len(). // Pop is equivalent to Remove(h, 0). -func Pop(h Interface) interface{} { +func Pop(h Interface) any { n := h.Len() - 1 h.Swap(0, n) down(h, 0, n) @@ -66,7 +66,7 @@ func Pop(h Interface) interface{} { // Remove removes and returns the element at index i from the heap. // The complexity is O(log n) where n = h.Len(). -func Remove(h Interface, i int) interface{} { +func Remove(h Interface, i int) any { n := h.Len() - 1 if n != i { h.Swap(i, n) diff --git a/src/container/heap/heap_test.go b/src/container/heap/heap_test.go index f19f9cfa74..c9f9f140ea 100644 --- a/src/container/heap/heap_test.go +++ b/src/container/heap/heap_test.go @@ -23,12 +23,12 @@ func (h *myHeap) Len() int { return len(*h) } -func (h *myHeap) Pop() (v interface{}) { +func (h *myHeap) Pop() (v any) { *h, v = (*h)[:h.Len()-1], (*h)[h.Len()-1] return } -func (h *myHeap) Push(v interface{}) { +func (h *myHeap) Push(v any) { *h = append(*h, v.(int)) } diff --git a/src/container/list/list.go b/src/container/list/list.go index aa89b7f599..9555ad3900 100644 --- a/src/container/list/list.go +++ b/src/container/list/list.go @@ -24,7 +24,7 @@ type Element struct { list *List // The value stored with this element. - Value interface{} + Value any } // Next returns the next list element or nil. @@ -100,7 +100,7 @@ func (l *List) insert(e, at *Element) *Element { } // insertValue is a convenience wrapper for insert(&Element{Value: v}, at). -func (l *List) insertValue(v interface{}, at *Element) *Element { +func (l *List) insertValue(v any, at *Element) *Element { return l.insert(&Element{Value: v}, at) } @@ -131,7 +131,7 @@ func (l *List) move(e, at *Element) { // Remove removes e from l if e is an element of list l. // It returns the element value e.Value. // The element must not be nil. -func (l *List) Remove(e *Element) interface{} { +func (l *List) Remove(e *Element) any { if e.list == l { // if e.list == l, l must have been initialized when e was inserted // in l or l == nil (e is a zero Element) and l.remove will crash @@ -141,13 +141,13 @@ func (l *List) Remove(e *Element) interface{} { } // PushFront inserts a new element e with value v at the front of list l and returns e. -func (l *List) PushFront(v interface{}) *Element { +func (l *List) PushFront(v any) *Element { l.lazyInit() return l.insertValue(v, &l.root) } // PushBack inserts a new element e with value v at the back of list l and returns e. -func (l *List) PushBack(v interface{}) *Element { +func (l *List) PushBack(v any) *Element { l.lazyInit() return l.insertValue(v, l.root.prev) } @@ -155,7 +155,7 @@ func (l *List) PushBack(v interface{}) *Element { // InsertBefore inserts a new element e with value v immediately before mark and returns e. // If mark is not an element of l, the list is not modified. // The mark must not be nil. -func (l *List) InsertBefore(v interface{}, mark *Element) *Element { +func (l *List) InsertBefore(v any, mark *Element) *Element { if mark.list != l { return nil } @@ -166,7 +166,7 @@ func (l *List) InsertBefore(v interface{}, mark *Element) *Element { // InsertAfter inserts a new element e with value v immediately after mark and returns e. // If mark is not an element of l, the list is not modified. // The mark must not be nil. -func (l *List) InsertAfter(v interface{}, mark *Element) *Element { +func (l *List) InsertAfter(v any, mark *Element) *Element { if mark.list != l { return nil } diff --git a/src/container/list/list_test.go b/src/container/list/list_test.go index c74724b398..daa2114997 100644 --- a/src/container/list/list_test.go +++ b/src/container/list/list_test.go @@ -141,7 +141,7 @@ func TestList(t *testing.T) { checkListPointers(t, l, []*Element{}) } -func checkList(t *testing.T, l *List, es []interface{}) { +func checkList(t *testing.T, l *List, es []any) { if !checkListLen(t, l, len(es)) { return } @@ -169,36 +169,36 @@ func TestExtending(t *testing.T) { l3 := New() l3.PushBackList(l1) - checkList(t, l3, []interface{}{1, 2, 3}) + checkList(t, l3, []any{1, 2, 3}) l3.PushBackList(l2) - checkList(t, l3, []interface{}{1, 2, 3, 4, 5}) + checkList(t, l3, []any{1, 2, 3, 4, 5}) l3 = New() l3.PushFrontList(l2) - checkList(t, l3, []interface{}{4, 5}) + checkList(t, l3, []any{4, 5}) l3.PushFrontList(l1) - checkList(t, l3, []interface{}{1, 2, 3, 4, 5}) + checkList(t, l3, []any{1, 2, 3, 4, 5}) - checkList(t, l1, []interface{}{1, 2, 3}) - checkList(t, l2, []interface{}{4, 5}) + checkList(t, l1, []any{1, 2, 3}) + checkList(t, l2, []any{4, 5}) l3 = New() l3.PushBackList(l1) - checkList(t, l3, []interface{}{1, 2, 3}) + checkList(t, l3, []any{1, 2, 3}) l3.PushBackList(l3) - checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3}) + checkList(t, l3, []any{1, 2, 3, 1, 2, 3}) l3 = New() l3.PushFrontList(l1) - checkList(t, l3, []interface{}{1, 2, 3}) + checkList(t, l3, []any{1, 2, 3}) l3.PushFrontList(l3) - checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3}) + checkList(t, l3, []any{1, 2, 3, 1, 2, 3}) l3 = New() l1.PushBackList(l3) - checkList(t, l1, []interface{}{1, 2, 3}) + checkList(t, l1, []any{1, 2, 3}) l1.PushFrontList(l3) - checkList(t, l1, []interface{}{1, 2, 3}) + checkList(t, l1, []any{1, 2, 3}) } func TestRemove(t *testing.T) { @@ -289,19 +289,19 @@ func TestMove(t *testing.T) { func TestZeroList(t *testing.T) { var l1 = new(List) l1.PushFront(1) - checkList(t, l1, []interface{}{1}) + checkList(t, l1, []any{1}) var l2 = new(List) l2.PushBack(1) - checkList(t, l2, []interface{}{1}) + checkList(t, l2, []any{1}) var l3 = new(List) l3.PushFrontList(l1) - checkList(t, l3, []interface{}{1}) + checkList(t, l3, []any{1}) var l4 = new(List) l4.PushBackList(l2) - checkList(t, l4, []interface{}{1}) + checkList(t, l4, []any{1}) } // Test that a list l is not modified when calling InsertBefore with a mark that is not an element of l. @@ -311,7 +311,7 @@ func TestInsertBeforeUnknownMark(t *testing.T) { l.PushBack(2) l.PushBack(3) l.InsertBefore(1, new(Element)) - checkList(t, &l, []interface{}{1, 2, 3}) + checkList(t, &l, []any{1, 2, 3}) } // Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l. @@ -321,7 +321,7 @@ func TestInsertAfterUnknownMark(t *testing.T) { l.PushBack(2) l.PushBack(3) l.InsertAfter(1, new(Element)) - checkList(t, &l, []interface{}{1, 2, 3}) + checkList(t, &l, []any{1, 2, 3}) } // Test that a list l is not modified when calling MoveAfter or MoveBefore with a mark that is not an element of l. @@ -333,10 +333,10 @@ func TestMoveUnknownMark(t *testing.T) { e2 := l2.PushBack(2) l1.MoveAfter(e1, e2) - checkList(t, &l1, []interface{}{1}) - checkList(t, &l2, []interface{}{2}) + checkList(t, &l1, []any{1}) + checkList(t, &l2, []any{2}) l1.MoveBefore(e1, e2) - checkList(t, &l1, []interface{}{1}) - checkList(t, &l2, []interface{}{2}) + checkList(t, &l1, []any{1}) + checkList(t, &l2, []any{2}) } diff --git a/src/container/ring/example_test.go b/src/container/ring/example_test.go index 30bd0d74c9..4b659d25da 100644 --- a/src/container/ring/example_test.go +++ b/src/container/ring/example_test.go @@ -88,7 +88,7 @@ func ExampleRing_Do() { } // Iterate through the ring and print its contents - r.Do(func(p interface{}) { + r.Do(func(p any) { fmt.Println(p.(int)) }) @@ -117,7 +117,7 @@ func ExampleRing_Move() { r = r.Move(3) // Iterate through the ring and print its contents - r.Do(func(p interface{}) { + r.Do(func(p any) { fmt.Println(p.(int)) }) @@ -154,7 +154,7 @@ func ExampleRing_Link() { rs := r.Link(s) // Iterate through the combined ring and print its contents - rs.Do(func(p interface{}) { + rs.Do(func(p any) { fmt.Println(p.(int)) }) @@ -182,7 +182,7 @@ func ExampleRing_Unlink() { r.Unlink(3) // Iterate through the remaining ring and print its contents - r.Do(func(p interface{}) { + r.Do(func(p any) { fmt.Println(p.(int)) }) diff --git a/src/container/ring/ring.go b/src/container/ring/ring.go index 6d3b3e5b32..ce15032543 100644 --- a/src/container/ring/ring.go +++ b/src/container/ring/ring.go @@ -13,7 +13,7 @@ package ring // type Ring struct { next, prev *Ring - Value interface{} // for use by client; untouched by this library + Value any // for use by client; untouched by this library } func (r *Ring) init() *Ring { @@ -131,7 +131,7 @@ func (r *Ring) Len() int { // Do calls function f on each element of the ring, in forward order. // The behavior of Do is undefined if f changes *r. -func (r *Ring) Do(f func(interface{})) { +func (r *Ring) Do(f func(any)) { if r != nil { f(r.Value) for p := r.Next(); p != r; p = p.next { diff --git a/src/container/ring/ring_test.go b/src/container/ring/ring_test.go index 41d18abf8b..28acbbc250 100644 --- a/src/container/ring/ring_test.go +++ b/src/container/ring/ring_test.go @@ -33,7 +33,7 @@ func verify(t *testing.T, r *Ring, N int, sum int) { // iteration n = 0 s := 0 - r.Do(func(p interface{}) { + r.Do(func(p any) { n++ if p != nil { s += p.(int) diff --git a/src/context/context.go b/src/context/context.go index a9e14703fd..cf010b2a69 100644 --- a/src/context/context.go +++ b/src/context/context.go @@ -150,7 +150,7 @@ type Context interface { // u, ok := ctx.Value(userKey).(*User) // return u, ok // } - Value(key interface{}) interface{} + Value(key any) any } // Canceled is the error returned by Context.Err when the context is canceled. @@ -182,7 +182,7 @@ func (*emptyCtx) Err() error { return nil } -func (*emptyCtx) Value(key interface{}) interface{} { +func (*emptyCtx) Value(key any) any { return nil } @@ -348,7 +348,7 @@ type cancelCtx struct { err error // set to non-nil by the first cancel call } -func (c *cancelCtx) Value(key interface{}) interface{} { +func (c *cancelCtx) Value(key any) any { if key == &cancelCtxKey { return c } @@ -520,7 +520,7 @@ func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc) { // interface{}, context keys often have concrete type // struct{}. Alternatively, exported context key variables' static // type should be a pointer or interface. -func WithValue(parent Context, key, val interface{}) Context { +func WithValue(parent Context, key, val any) Context { if parent == nil { panic("cannot create context from nil parent") } @@ -537,13 +537,13 @@ func WithValue(parent Context, key, val interface{}) Context { // delegates all other calls to the embedded Context. type valueCtx struct { Context - key, val interface{} + key, val any } // stringify tries a bit to stringify v, without using fmt, since we don't // want context depending on the unicode tables. This is only used by // *valueCtx.String(). -func stringify(v interface{}) string { +func stringify(v any) string { switch s := v.(type) { case stringer: return s.String() @@ -559,14 +559,14 @@ func (c *valueCtx) String() string { ", val " + stringify(c.val) + ")" } -func (c *valueCtx) Value(key interface{}) interface{} { +func (c *valueCtx) Value(key any) any { if c.key == key { return c.val } return value(c.Context, key) } -func value(c Context, key interface{}) interface{} { +func value(c Context, key any) any { for { switch ctx := c.(type) { case *valueCtx: diff --git a/src/context/context_test.go b/src/context/context_test.go index a2e2324a0e..8673c0fdea 100644 --- a/src/context/context_test.go +++ b/src/context/context_test.go @@ -16,21 +16,21 @@ import ( type testingT interface { Deadline() (time.Time, bool) - Error(args ...interface{}) - Errorf(format string, args ...interface{}) + Error(args ...any) + Errorf(format string, args ...any) Fail() FailNow() Failed() bool - Fatal(args ...interface{}) - Fatalf(format string, args ...interface{}) + Fatal(args ...any) + Fatalf(format string, args ...any) Helper() - Log(args ...interface{}) - Logf(format string, args ...interface{}) + Log(args ...any) + Logf(format string, args ...any) Name() string Parallel() - Skip(args ...interface{}) + Skip(args ...any) SkipNow() - Skipf(format string, args ...interface{}) + Skipf(format string, args ...any) Skipped() bool } @@ -553,7 +553,7 @@ func testLayers(t testingT, seed int64, testTimeout bool) { t.Parallel() r := rand.New(rand.NewSource(seed)) - errorf := func(format string, a ...interface{}) { + errorf := func(format string, a ...any) { t.Errorf(fmt.Sprintf("seed=%d: %s", seed, format), a...) } const ( @@ -691,7 +691,7 @@ func XTestInvalidDerivedFail(t testingT) { } } -func recoveredValue(fn func()) (v interface{}) { +func recoveredValue(fn func()) (v any) { defer func() { v = recover() }() fn() return diff --git a/src/crypto/crypto.go b/src/crypto/crypto.go index cb87972afc..fe1c0690bc 100644 --- a/src/crypto/crypto.go +++ b/src/crypto/crypto.go @@ -159,7 +159,7 @@ func RegisterHash(h Hash, f func() hash.Hash) { // } // // which can be used for increased type safety within applications. -type PublicKey interface{} +type PublicKey any // PrivateKey represents a private key using an unspecified algorithm. // @@ -173,7 +173,7 @@ type PublicKey interface{} // // as well as purpose-specific interfaces such as Signer and Decrypter, which // can be used for increased type safety within applications. -type PrivateKey interface{} +type PrivateKey any // Signer is an interface for an opaque private key that can be used for // signing operations. For example, an RSA key kept in a hardware module. @@ -220,4 +220,4 @@ type Decrypter interface { Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error) } -type DecrypterOpts interface{} +type DecrypterOpts any diff --git a/src/crypto/ed25519/internal/edwards25519/scalar_alias_test.go b/src/crypto/ed25519/internal/edwards25519/scalar_alias_test.go index 18d800d556..827153b9bd 100644 --- a/src/crypto/ed25519/internal/edwards25519/scalar_alias_test.go +++ b/src/crypto/ed25519/internal/edwards25519/scalar_alias_test.go @@ -71,7 +71,7 @@ func TestScalarAliasing(t *testing.T) { return x == x1 && y == y1 } - for name, f := range map[string]interface{}{ + for name, f := range map[string]any{ "Negate": func(v, x Scalar) bool { return checkAliasingOneArg((*Scalar).Negate, v, x) }, diff --git a/src/crypto/tls/cipher_suites.go b/src/crypto/tls/cipher_suites.go index 4bf06468c6..d164991eec 100644 --- a/src/crypto/tls/cipher_suites.go +++ b/src/crypto/tls/cipher_suites.go @@ -140,7 +140,7 @@ type cipherSuite struct { ka func(version uint16) keyAgreement // flags is a bitmask of the suite* values, above. flags int - cipher func(key, iv []byte, isRead bool) interface{} + cipher func(key, iv []byte, isRead bool) any mac func(key []byte) hash.Hash aead func(key, fixedNonce []byte) aead } @@ -399,12 +399,12 @@ func aesgcmPreferred(ciphers []uint16) bool { return false } -func cipherRC4(key, iv []byte, isRead bool) interface{} { +func cipherRC4(key, iv []byte, isRead bool) any { cipher, _ := rc4.NewCipher(key) return cipher } -func cipher3DES(key, iv []byte, isRead bool) interface{} { +func cipher3DES(key, iv []byte, isRead bool) any { block, _ := des.NewTripleDESCipher(key) if isRead { return cipher.NewCBCDecrypter(block, iv) @@ -412,7 +412,7 @@ func cipher3DES(key, iv []byte, isRead bool) interface{} { return cipher.NewCBCEncrypter(block, iv) } -func cipherAES(key, iv []byte, isRead bool) interface{} { +func cipherAES(key, iv []byte, isRead bool) any { block, _ := aes.NewCipher(key) if isRead { return cipher.NewCBCDecrypter(block, iv) diff --git a/src/crypto/tls/common.go b/src/crypto/tls/common.go index bb5bec3c4d..e6e7598ce9 100644 --- a/src/crypto/tls/common.go +++ b/src/crypto/tls/common.go @@ -1466,7 +1466,7 @@ func defaultConfig() *Config { return &emptyConfig } -func unexpectedMessageError(wanted, got interface{}) error { +func unexpectedMessageError(wanted, got any) error { return fmt.Errorf("tls: received unexpected handshake message of type %T when waiting for %T", got, wanted) } diff --git a/src/crypto/tls/conn.go b/src/crypto/tls/conn.go index 300e9a233c..28ab063782 100644 --- a/src/crypto/tls/conn.go +++ b/src/crypto/tls/conn.go @@ -163,16 +163,16 @@ func (c *Conn) NetConn() net.Conn { type halfConn struct { sync.Mutex - err error // first permanent error - version uint16 // protocol version - cipher interface{} // cipher algorithm + err error // first permanent error + version uint16 // protocol version + cipher any // cipher algorithm mac hash.Hash seq [8]byte // 64-bit sequence number scratchBuf [13]byte // to avoid allocs; interface method args escape - nextCipher interface{} // next encryption state - nextMac hash.Hash // next MAC algorithm + nextCipher any // next encryption state + nextMac hash.Hash // next MAC algorithm trafficSecret []byte // current TLS 1.3 traffic secret } @@ -197,7 +197,7 @@ func (hc *halfConn) setErrorLocked(err error) error { // prepareCipherSpec sets the encryption and MAC states // that a subsequent changeCipherSpec will use. -func (hc *halfConn) prepareCipherSpec(version uint16, cipher interface{}, mac hash.Hash) { +func (hc *halfConn) prepareCipherSpec(version uint16, cipher any, mac hash.Hash) { hc.version = version hc.nextCipher = cipher hc.nextMac = mac @@ -935,7 +935,7 @@ func (c *Conn) flush() (int, error) { // outBufPool pools the record-sized scratch buffers used by writeRecordLocked. var outBufPool = sync.Pool{ - New: func() interface{} { + New: func() any { return new([]byte) }, } @@ -1011,7 +1011,7 @@ func (c *Conn) writeRecord(typ recordType, data []byte) (int, error) { // readHandshake reads the next handshake message from // the record layer. -func (c *Conn) readHandshake() (interface{}, error) { +func (c *Conn) readHandshake() (any, error) { for c.hand.Len() < 4 { if err := c.readRecord(); err != nil { return nil, err diff --git a/src/crypto/tls/generate_cert.go b/src/crypto/tls/generate_cert.go index 58fdd025db..74509c9dea 100644 --- a/src/crypto/tls/generate_cert.go +++ b/src/crypto/tls/generate_cert.go @@ -37,7 +37,7 @@ var ( ed25519Key = flag.Bool("ed25519", false, "Generate an Ed25519 key") ) -func publicKey(priv interface{}) interface{} { +func publicKey(priv any) any { switch k := priv.(type) { case *rsa.PrivateKey: return &k.PublicKey @@ -57,7 +57,7 @@ func main() { log.Fatalf("Missing required --host parameter") } - var priv interface{} + var priv any var err error switch *ecdsaCurve { case "": diff --git a/src/crypto/tls/handshake_client.go b/src/crypto/tls/handshake_client.go index 2ae6f3f534..a3e00777f1 100644 --- a/src/crypto/tls/handshake_client.go +++ b/src/crypto/tls/handshake_client.go @@ -657,7 +657,7 @@ func (hs *clientHandshakeState) establishKeys() error { clientMAC, serverMAC, clientKey, serverKey, clientIV, serverIV := keysFromMasterSecret(c.vers, hs.suite, hs.masterSecret, hs.hello.random, hs.serverHello.random, hs.suite.macLen, hs.suite.keyLen, hs.suite.ivLen) - var clientCipher, serverCipher interface{} + var clientCipher, serverCipher any var clientHash, serverHash hash.Hash if hs.suite.cipher != nil { clientCipher = hs.suite.cipher(clientKey, clientIV, false /* not for reading */) diff --git a/src/crypto/tls/handshake_client_test.go b/src/crypto/tls/handshake_client_test.go index 2158f3247b..0950bb0ac4 100644 --- a/src/crypto/tls/handshake_client_test.go +++ b/src/crypto/tls/handshake_client_test.go @@ -134,7 +134,7 @@ type clientTest struct { cert []byte // key, if not nil, contains either a *rsa.PrivateKey, ed25519.PrivateKey or // *ecdsa.PrivateKey which is the private key for the reference server. - key interface{} + key any // extensions, if not nil, contains a list of extension data to be returned // from the ServerHello. The data should be in standard TLS format with // a 2-byte uint16 type, 2-byte data length, followed by the extension data. @@ -171,7 +171,7 @@ func (test *clientTest) connFromCommand() (conn *recordingConn, child *exec.Cmd, certPath := tempFile(string(cert)) defer os.Remove(certPath) - var key interface{} = testRSAPrivateKey + var key any = testRSAPrivateKey if test.key != nil { key = test.key } diff --git a/src/crypto/tls/handshake_messages_test.go b/src/crypto/tls/handshake_messages_test.go index bb8aea8670..cc427bf72a 100644 --- a/src/crypto/tls/handshake_messages_test.go +++ b/src/crypto/tls/handshake_messages_test.go @@ -14,7 +14,7 @@ import ( "time" ) -var tests = []interface{}{ +var tests = []any{ &clientHelloMsg{}, &serverHelloMsg{}, &finishedMsg{}, diff --git a/src/crypto/tls/handshake_server.go b/src/crypto/tls/handshake_server.go index 5cb152755b..097046340b 100644 --- a/src/crypto/tls/handshake_server.go +++ b/src/crypto/tls/handshake_server.go @@ -681,7 +681,7 @@ func (hs *serverHandshakeState) establishKeys() error { clientMAC, serverMAC, clientKey, serverKey, clientIV, serverIV := keysFromMasterSecret(c.vers, hs.suite, hs.masterSecret, hs.clientHello.random, hs.hello.random, hs.suite.macLen, hs.suite.keyLen, hs.suite.ivLen) - var clientCipher, serverCipher interface{} + var clientCipher, serverCipher any var clientHash, serverHash hash.Hash if hs.suite.aead == nil { diff --git a/src/crypto/tls/handshake_server_test.go b/src/crypto/tls/handshake_server_test.go index 5fb2ebbbb3..6d2c405626 100644 --- a/src/crypto/tls/handshake_server_test.go +++ b/src/crypto/tls/handshake_server_test.go @@ -249,7 +249,7 @@ func TestTLS12OnlyCipherSuites(t *testing.T) { } c, s := localPipe(t) - replyChan := make(chan interface{}) + replyChan := make(chan any) go func() { cli := Client(c, testConfig) cli.vers = clientHello.vers @@ -304,7 +304,7 @@ func TestTLSPointFormats(t *testing.T) { } c, s := localPipe(t) - replyChan := make(chan interface{}) + replyChan := make(chan any) go func() { cli := Client(c, testConfig) cli.vers = clientHello.vers @@ -600,7 +600,7 @@ func (test *serverTest) connFromCommand() (conn *recordingConn, child *exec.Cmd, return nil, nil, err } - connChan := make(chan interface{}, 1) + connChan := make(chan any, 1) go func() { tcpConn, err := l.Accept() if err != nil { diff --git a/src/crypto/x509/name_constraints_test.go b/src/crypto/x509/name_constraints_test.go index a6b5aa1ee6..04c1e7a627 100644 --- a/src/crypto/x509/name_constraints_test.go +++ b/src/crypto/x509/name_constraints_test.go @@ -1850,7 +1850,7 @@ func parseEKUs(ekuStrs []string) (ekus []ExtKeyUsage, unknowns []asn1.ObjectIden func TestConstraintCases(t *testing.T) { privateKeys := sync.Pool{ - New: func() interface{} { + New: func() any { priv, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) if err != nil { panic(err) diff --git a/src/crypto/x509/parser.go b/src/crypto/x509/parser.go index c2770f3f08..5e6bd54368 100644 --- a/src/crypto/x509/parser.go +++ b/src/crypto/x509/parser.go @@ -229,7 +229,7 @@ func parseExtension(der cryptobyte.String) (pkix.Extension, error) { return ext, nil } -func parsePublicKey(algo PublicKeyAlgorithm, keyData *publicKeyInfo) (interface{}, error) { +func parsePublicKey(algo PublicKeyAlgorithm, keyData *publicKeyInfo) (any, error) { der := cryptobyte.String(keyData.PublicKey.RightAlign()) switch algo { case RSA: diff --git a/src/crypto/x509/pkcs8.go b/src/crypto/x509/pkcs8.go index a5ee4cfbfe..d77efa3156 100644 --- a/src/crypto/x509/pkcs8.go +++ b/src/crypto/x509/pkcs8.go @@ -30,7 +30,7 @@ type pkcs8 struct { // More types might be supported in the future. // // This kind of key is commonly encoded in PEM blocks of type "PRIVATE KEY". -func ParsePKCS8PrivateKey(der []byte) (key interface{}, err error) { +func ParsePKCS8PrivateKey(der []byte) (key any, err error) { var privKey pkcs8 if _, err := asn1.Unmarshal(der, &privKey); err != nil { if _, err := asn1.Unmarshal(der, &ecPrivateKey{}); err == nil { @@ -85,7 +85,7 @@ func ParsePKCS8PrivateKey(der []byte) (key interface{}, err error) { // and ed25519.PrivateKey. Unsupported key types result in an error. // // This kind of key is commonly encoded in PEM blocks of type "PRIVATE KEY". -func MarshalPKCS8PrivateKey(key interface{}) ([]byte, error) { +func MarshalPKCS8PrivateKey(key any) ([]byte, error) { var privKey pkcs8 switch k := key.(type) { diff --git a/src/crypto/x509/pkix/pkix.go b/src/crypto/x509/pkix/pkix.go index 62ae065496..e9179ed067 100644 --- a/src/crypto/x509/pkix/pkix.go +++ b/src/crypto/x509/pkix/pkix.go @@ -98,7 +98,7 @@ type RelativeDistinguishedNameSET []AttributeTypeAndValue // RFC 5280, Section 4.1.2.4. type AttributeTypeAndValue struct { Type asn1.ObjectIdentifier - Value interface{} + Value any } // AttributeTypeAndValueSET represents a set of ASN.1 sequences of diff --git a/src/crypto/x509/verify.go b/src/crypto/x509/verify.go index 1562ee57af..e8c7707f3f 100644 --- a/src/crypto/x509/verify.go +++ b/src/crypto/x509/verify.go @@ -500,9 +500,9 @@ func (c *Certificate) checkNameConstraints(count *int, maxConstraintComparisons int, nameType string, name string, - parsedName interface{}, - match func(parsedName, constraint interface{}) (match bool, err error), - permitted, excluded interface{}) error { + parsedName any, + match func(parsedName, constraint any) (match bool, err error), + permitted, excluded any) error { excludedValue := reflect.ValueOf(excluded) @@ -609,7 +609,7 @@ func (c *Certificate) isValid(certType int, currentChain []*Certificate, opts *V } if err := c.checkNameConstraints(&comparisonCount, maxConstraintComparisons, "email address", name, mailbox, - func(parsedName, constraint interface{}) (bool, error) { + func(parsedName, constraint any) (bool, error) { return matchEmailConstraint(parsedName.(rfc2821Mailbox), constraint.(string)) }, c.PermittedEmailAddresses, c.ExcludedEmailAddresses); err != nil { return err @@ -622,7 +622,7 @@ func (c *Certificate) isValid(certType int, currentChain []*Certificate, opts *V } if err := c.checkNameConstraints(&comparisonCount, maxConstraintComparisons, "DNS name", name, name, - func(parsedName, constraint interface{}) (bool, error) { + func(parsedName, constraint any) (bool, error) { return matchDomainConstraint(parsedName.(string), constraint.(string)) }, c.PermittedDNSDomains, c.ExcludedDNSDomains); err != nil { return err @@ -636,7 +636,7 @@ func (c *Certificate) isValid(certType int, currentChain []*Certificate, opts *V } if err := c.checkNameConstraints(&comparisonCount, maxConstraintComparisons, "URI", name, uri, - func(parsedName, constraint interface{}) (bool, error) { + func(parsedName, constraint any) (bool, error) { return matchURIConstraint(parsedName.(*url.URL), constraint.(string)) }, c.PermittedURIDomains, c.ExcludedURIDomains); err != nil { return err @@ -649,7 +649,7 @@ func (c *Certificate) isValid(certType int, currentChain []*Certificate, opts *V } if err := c.checkNameConstraints(&comparisonCount, maxConstraintComparisons, "IP address", ip.String(), ip, - func(parsedName, constraint interface{}) (bool, error) { + func(parsedName, constraint any) (bool, error) { return matchIPConstraint(parsedName.(net.IP), constraint.(*net.IPNet)) }, c.PermittedIPRanges, c.ExcludedIPRanges); err != nil { return err diff --git a/src/crypto/x509/x509.go b/src/crypto/x509/x509.go index b5c2b22cd7..47be77d994 100644 --- a/src/crypto/x509/x509.go +++ b/src/crypto/x509/x509.go @@ -52,7 +52,7 @@ type pkixPublicKey struct { // ed25519.PublicKey. More types might be supported in the future. // // This kind of key is commonly encoded in PEM blocks of type "PUBLIC KEY". -func ParsePKIXPublicKey(derBytes []byte) (pub interface{}, err error) { +func ParsePKIXPublicKey(derBytes []byte) (pub any, err error) { var pki publicKeyInfo if rest, err := asn1.Unmarshal(derBytes, &pki); err != nil { if _, err := asn1.Unmarshal(derBytes, &pkcs1PublicKey{}); err == nil { @@ -69,7 +69,7 @@ func ParsePKIXPublicKey(derBytes []byte) (pub interface{}, err error) { return parsePublicKey(algo, &pki) } -func marshalPublicKey(pub interface{}) (publicKeyBytes []byte, publicKeyAlgorithm pkix.AlgorithmIdentifier, err error) { +func marshalPublicKey(pub any) (publicKeyBytes []byte, publicKeyAlgorithm pkix.AlgorithmIdentifier, err error) { switch pub := pub.(type) { case *rsa.PublicKey: publicKeyBytes, err = asn1.Marshal(pkcs1PublicKey{ @@ -114,7 +114,7 @@ func marshalPublicKey(pub interface{}) (publicKeyBytes []byte, publicKeyAlgorith // and ed25519.PublicKey. Unsupported key types result in an error. // // This kind of key is commonly encoded in PEM blocks of type "PUBLIC KEY". -func MarshalPKIXPublicKey(pub interface{}) ([]byte, error) { +func MarshalPKIXPublicKey(pub any) ([]byte, error) { var publicKeyBytes []byte var publicKeyAlgorithm pkix.AlgorithmIdentifier var err error @@ -636,7 +636,7 @@ type Certificate struct { SignatureAlgorithm SignatureAlgorithm PublicKeyAlgorithm PublicKeyAlgorithm - PublicKey interface{} + PublicKey any Version int SerialNumber *big.Int @@ -814,7 +814,7 @@ func (c *Certificate) getSANExtension() []byte { return nil } -func signaturePublicKeyAlgoMismatchError(expectedPubKeyAlgo PublicKeyAlgorithm, pubKey interface{}) error { +func signaturePublicKeyAlgoMismatchError(expectedPubKeyAlgo PublicKeyAlgorithm, pubKey any) error { return fmt.Errorf("x509: signature algorithm specifies an %s public key, but have public key of type %T", expectedPubKeyAlgo.String(), pubKey) } @@ -1357,7 +1357,7 @@ func subjectBytes(cert *Certificate) ([]byte, error) { // signingParamsForPublicKey returns the parameters to use for signing with // priv. If requestedSigAlgo is not zero then it overrides the default // signature algorithm. -func signingParamsForPublicKey(pub interface{}, requestedSigAlgo SignatureAlgorithm) (hashFunc crypto.Hash, sigAlgo pkix.AlgorithmIdentifier, err error) { +func signingParamsForPublicKey(pub any, requestedSigAlgo SignatureAlgorithm) (hashFunc crypto.Hash, sigAlgo pkix.AlgorithmIdentifier, err error) { var pubType PublicKeyAlgorithm switch pub := pub.(type) { @@ -1483,7 +1483,7 @@ var emptyASN1Subject = []byte{0x30, 0} // // If SubjectKeyId from template is empty and the template is a CA, SubjectKeyId // will be generated from the hash of the public key. -func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv interface{}) ([]byte, error) { +func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv any) ([]byte, error) { key, ok := priv.(crypto.Signer) if !ok { return nil, errors.New("x509: certificate private key does not implement crypto.Signer") @@ -1648,7 +1648,7 @@ func ParseDERCRL(derBytes []byte) (*pkix.CertificateList, error) { // // Note: this method does not generate an RFC 5280 conformant X.509 v2 CRL. // To generate a standards compliant CRL, use CreateRevocationList instead. -func (c *Certificate) CreateCRL(rand io.Reader, priv interface{}, revokedCerts []pkix.RevokedCertificate, now, expiry time.Time) (crlBytes []byte, err error) { +func (c *Certificate) CreateCRL(rand io.Reader, priv any, revokedCerts []pkix.RevokedCertificate, now, expiry time.Time) (crlBytes []byte, err error) { key, ok := priv.(crypto.Signer) if !ok { return nil, errors.New("x509: certificate private key does not implement crypto.Signer") @@ -1723,7 +1723,7 @@ type CertificateRequest struct { SignatureAlgorithm SignatureAlgorithm PublicKeyAlgorithm PublicKeyAlgorithm - PublicKey interface{} + PublicKey any Subject pkix.Name @@ -1860,7 +1860,7 @@ func parseCSRExtensions(rawAttributes []asn1.RawValue) ([]pkix.Extension, error) // ed25519.PrivateKey satisfies this.) // // The returned slice is the certificate request in DER encoding. -func CreateCertificateRequest(rand io.Reader, template *CertificateRequest, priv interface{}) (csr []byte, err error) { +func CreateCertificateRequest(rand io.Reader, template *CertificateRequest, priv any) (csr []byte, err error) { key, ok := priv.(crypto.Signer) if !ok { return nil, errors.New("x509: certificate private key does not implement crypto.Signer") diff --git a/src/crypto/x509/x509_test.go b/src/crypto/x509/x509_test.go index 3345f57075..a42b852a42 100644 --- a/src/crypto/x509/x509_test.go +++ b/src/crypto/x509/x509_test.go @@ -68,7 +68,7 @@ func TestPKCS1MismatchPublicKeyFormat(t *testing.T) { } } -func testParsePKIXPublicKey(t *testing.T, pemBytes string) (pub interface{}) { +func testParsePKIXPublicKey(t *testing.T, pemBytes string) (pub any) { block, _ := pem.Decode([]byte(pemBytes)) pub, err := ParsePKIXPublicKey(block.Bytes) if err != nil { @@ -581,7 +581,7 @@ func TestCreateSelfSignedCertificate(t *testing.T) { tests := []struct { name string - pub, priv interface{} + pub, priv any checkSig bool sigAlgo SignatureAlgorithm }{ @@ -1233,7 +1233,7 @@ func TestCRLCreation(t *testing.T) { tests := []struct { name string - priv interface{} + priv any cert *Certificate }{ {"RSA CA", privRSA, certRSA}, @@ -1385,7 +1385,7 @@ func TestCreateCertificateRequest(t *testing.T) { tests := []struct { name string - priv interface{} + priv any sigAlgo SignatureAlgorithm }{ {"RSA", testPrivateKey, SHA256WithRSA}, diff --git a/src/database/sql/convert.go b/src/database/sql/convert.go index c0997b7fc5..4d9d070137 100644 --- a/src/database/sql/convert.go +++ b/src/database/sql/convert.go @@ -104,7 +104,7 @@ func defaultCheckNamedValue(nv *driver.NamedValue) (err error) { // The statement ds may be nil, if no statement is available. // // ci must be locked. -func driverArgsConnLocked(ci driver.Conn, ds *driverStmt, args []interface{}) ([]driver.NamedValue, error) { +func driverArgsConnLocked(ci driver.Conn, ds *driverStmt, args []any) ([]driver.NamedValue, error) { nvargs := make([]driver.NamedValue, len(args)) // -1 means the driver doesn't know how to count the number of @@ -207,7 +207,7 @@ func driverArgsConnLocked(ci driver.Conn, ds *driverStmt, args []interface{}) ([ // convertAssign is the same as convertAssignRows, but without the optional // rows argument. -func convertAssign(dest, src interface{}) error { +func convertAssign(dest, src any) error { return convertAssignRows(dest, src, nil) } @@ -216,7 +216,7 @@ func convertAssign(dest, src interface{}) error { // dest should be a pointer type. If rows is passed in, the rows will // be used as the parent for any cursor values converted from a // driver.Rows to a *Rows. -func convertAssignRows(dest, src interface{}, rows *Rows) error { +func convertAssignRows(dest, src any, rows *Rows) error { // Common cases, without reflect. switch s := src.(type) { case string: @@ -248,7 +248,7 @@ func convertAssignRows(dest, src interface{}, rows *Rows) error { } *d = string(s) return nil - case *interface{}: + case *any: if d == nil { return errNilPtr } @@ -295,7 +295,7 @@ func convertAssignRows(dest, src interface{}, rows *Rows) error { } case nil: switch d := dest.(type) { - case *interface{}: + case *any: if d == nil { return errNilPtr } @@ -376,7 +376,7 @@ func convertAssignRows(dest, src interface{}, rows *Rows) error { *d = bv.(bool) } return err - case *interface{}: + case *any: *d = src return nil } @@ -495,7 +495,7 @@ func cloneBytes(b []byte) []byte { return c } -func asString(src interface{}) string { +func asString(src any) string { switch v := src.(type) { case string: return v diff --git a/src/database/sql/convert_test.go b/src/database/sql/convert_test.go index 400da7ea57..6d09fa1eae 100644 --- a/src/database/sql/convert_test.go +++ b/src/database/sql/convert_test.go @@ -25,7 +25,7 @@ type ( ) type conversionTest struct { - s, d interface{} // source and destination + s, d any // source and destination // following are used if they're non-zero wantint int64 @@ -38,7 +38,7 @@ type conversionTest struct { wanttime time.Time wantbool bool // used if d is of type *bool wanterr string - wantiface interface{} + wantiface any wantptr *int64 // if non-nil, *d's pointed value must be equal to *wantptr wantnil bool // if true, *d must be *int64(nil) wantusrdef userDefined @@ -58,7 +58,7 @@ var ( scanf64 float64 scantime time.Time scanptr *int64 - scaniface interface{} + scaniface any ) func conversionTests() []conversionTest { @@ -161,7 +161,7 @@ func conversionTests() []conversionTest { {s: "1.5", d: &scanf64, wantf64: float64(1.5)}, // Pointers - {s: interface{}(nil), d: &scanptr, wantnil: true}, + {s: any(nil), d: &scanptr, wantnil: true}, {s: int64(42), d: &scanptr, wantptr: &answer}, // To interface{} @@ -185,27 +185,27 @@ func conversionTests() []conversionTest { } } -func intPtrValue(intptr interface{}) interface{} { +func intPtrValue(intptr any) any { return reflect.Indirect(reflect.Indirect(reflect.ValueOf(intptr))).Int() } -func intValue(intptr interface{}) int64 { +func intValue(intptr any) int64 { return reflect.Indirect(reflect.ValueOf(intptr)).Int() } -func uintValue(intptr interface{}) uint64 { +func uintValue(intptr any) uint64 { return reflect.Indirect(reflect.ValueOf(intptr)).Uint() } -func float64Value(ptr interface{}) float64 { +func float64Value(ptr any) float64 { return *(ptr.(*float64)) } -func float32Value(ptr interface{}) float32 { +func float32Value(ptr any) float32 { return *(ptr.(*float32)) } -func timeValue(ptr interface{}) time.Time { +func timeValue(ptr any) time.Time { return *(ptr.(*time.Time)) } @@ -216,7 +216,7 @@ func TestConversions(t *testing.T) { if err != nil { errstr = err.Error() } - errf := func(format string, args ...interface{}) { + errf := func(format string, args ...any) { base := fmt.Sprintf("convertAssign #%d: for %v (%T) -> %T, ", n, ct.s, ct.s, ct.d) t.Errorf(base+format, args...) } @@ -260,7 +260,7 @@ func TestConversions(t *testing.T) { errf("want pointer to %v, got %v", *ct.wantptr, intPtrValue(ct.d)) } } - if ifptr, ok := ct.d.(*interface{}); ok { + if ifptr, ok := ct.d.(*any); ok { if !reflect.DeepEqual(ct.wantiface, scaniface) { errf("want interface %#v, got %#v", ct.wantiface, scaniface) continue @@ -301,7 +301,7 @@ func TestNullString(t *testing.T) { type valueConverterTest struct { c driver.ValueConverter - in, out interface{} + in, out any err string } @@ -335,7 +335,7 @@ func TestValueConverters(t *testing.T) { func TestRawBytesAllocs(t *testing.T) { var tests = []struct { name string - in interface{} + in any want string }{ {"uint64", uint64(12345678), "12345678"}, @@ -355,7 +355,7 @@ func TestRawBytesAllocs(t *testing.T) { } buf := make(RawBytes, 10) - test := func(name string, in interface{}, want string) { + test := func(name string, in any, want string) { if err := convertAssign(&buf, in); err != nil { t.Fatalf("%s: convertAssign = %v", name, err) } @@ -430,11 +430,11 @@ func TestDriverArgs(t *testing.T) { var nilValuerPPtr *Valuer_P var nilStrPtr *string tests := []struct { - args []interface{} + args []any want []driver.NamedValue }{ 0: { - args: []interface{}{Valuer_V("foo")}, + args: []any{Valuer_V("foo")}, want: []driver.NamedValue{ { Ordinal: 1, @@ -443,7 +443,7 @@ func TestDriverArgs(t *testing.T) { }, }, 1: { - args: []interface{}{nilValuerVPtr}, + args: []any{nilValuerVPtr}, want: []driver.NamedValue{ { Ordinal: 1, @@ -452,7 +452,7 @@ func TestDriverArgs(t *testing.T) { }, }, 2: { - args: []interface{}{nilValuerPPtr}, + args: []any{nilValuerPPtr}, want: []driver.NamedValue{ { Ordinal: 1, @@ -461,7 +461,7 @@ func TestDriverArgs(t *testing.T) { }, }, 3: { - args: []interface{}{"plain-str"}, + args: []any{"plain-str"}, want: []driver.NamedValue{ { Ordinal: 1, @@ -470,7 +470,7 @@ func TestDriverArgs(t *testing.T) { }, }, 4: { - args: []interface{}{nilStrPtr}, + args: []any{nilStrPtr}, want: []driver.NamedValue{ { Ordinal: 1, diff --git a/src/database/sql/driver/driver.go b/src/database/sql/driver/driver.go index ea1de5a8fb..5342315d12 100644 --- a/src/database/sql/driver/driver.go +++ b/src/database/sql/driver/driver.go @@ -58,7 +58,7 @@ import ( // in this package. This is used, for example, when a user selects a cursor // such as "select cursor(select * from my_table) from dual". If the Rows // from the select is closed, the cursor Rows will also be closed. -type Value interface{} +type Value any // NamedValue holds both the value name and value. type NamedValue struct { diff --git a/src/database/sql/driver/types.go b/src/database/sql/driver/types.go index 3337c2e0bc..506ce6c2cd 100644 --- a/src/database/sql/driver/types.go +++ b/src/database/sql/driver/types.go @@ -29,7 +29,7 @@ import ( // to a user's type in a scan. type ValueConverter interface { // ConvertValue converts a value to a driver Value. - ConvertValue(v interface{}) (Value, error) + ConvertValue(v any) (Value, error) } // Valuer is the interface providing the Value method. @@ -60,7 +60,7 @@ var _ ValueConverter = boolType{} func (boolType) String() string { return "Bool" } -func (boolType) ConvertValue(src interface{}) (Value, error) { +func (boolType) ConvertValue(src any) (Value, error) { switch s := src.(type) { case bool: return s, nil @@ -105,7 +105,7 @@ type int32Type struct{} var _ ValueConverter = int32Type{} -func (int32Type) ConvertValue(v interface{}) (Value, error) { +func (int32Type) ConvertValue(v any) (Value, error) { rv := reflect.ValueOf(v) switch rv.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: @@ -138,7 +138,7 @@ var String stringType type stringType struct{} -func (stringType) ConvertValue(v interface{}) (Value, error) { +func (stringType) ConvertValue(v any) (Value, error) { switch v.(type) { case string, []byte: return v, nil @@ -152,7 +152,7 @@ type Null struct { Converter ValueConverter } -func (n Null) ConvertValue(v interface{}) (Value, error) { +func (n Null) ConvertValue(v any) (Value, error) { if v == nil { return nil, nil } @@ -165,7 +165,7 @@ type NotNull struct { Converter ValueConverter } -func (n NotNull) ConvertValue(v interface{}) (Value, error) { +func (n NotNull) ConvertValue(v any) (Value, error) { if v == nil { return nil, fmt.Errorf("nil value not allowed") } @@ -173,7 +173,7 @@ func (n NotNull) ConvertValue(v interface{}) (Value, error) { } // IsValue reports whether v is a valid Value parameter type. -func IsValue(v interface{}) bool { +func IsValue(v any) bool { if v == nil { return true } @@ -188,7 +188,7 @@ func IsValue(v interface{}) bool { // IsScanValue is equivalent to IsValue. // It exists for compatibility. -func IsScanValue(v interface{}) bool { +func IsScanValue(v any) bool { return IsValue(v) } @@ -233,7 +233,7 @@ func callValuerValue(vr Valuer) (v Value, err error) { return vr.Value() } -func (defaultConverter) ConvertValue(v interface{}) (Value, error) { +func (defaultConverter) ConvertValue(v any) (Value, error) { if IsValue(v) { return v, nil } diff --git a/src/database/sql/driver/types_test.go b/src/database/sql/driver/types_test.go index 4c2996da85..80e5e05469 100644 --- a/src/database/sql/driver/types_test.go +++ b/src/database/sql/driver/types_test.go @@ -12,8 +12,8 @@ import ( type valueConverterTest struct { c ValueConverter - in interface{} - out interface{} + in any + out any err string } diff --git a/src/database/sql/fakedb_test.go b/src/database/sql/fakedb_test.go index 34e97e012b..8f953f6cb6 100644 --- a/src/database/sql/fakedb_test.go +++ b/src/database/sql/fakedb_test.go @@ -126,7 +126,7 @@ func (t *table) columnIndex(name string) int { } type row struct { - cols []interface{} // must be same size as its table colname + coltype + cols []any // must be same size as its table colname + coltype } type memToucher interface { @@ -198,10 +198,10 @@ type fakeStmt struct { closed bool - colName []string // used by CREATE, INSERT, SELECT (selected columns) - colType []string // used by CREATE - colValue []interface{} // used by INSERT (mix of strings and "?" for bound params) - placeholders int // used by INSERT/SELECT: number of ? params + colName []string // used by CREATE, INSERT, SELECT (selected columns) + colType []string // used by CREATE + colValue []any // used by INSERT (mix of strings and "?" for bound params) + placeholders int // used by INSERT/SELECT: number of ? params whereCol []boundCol // used by SELECT (all placeholders) @@ -504,7 +504,7 @@ func (c *fakeConn) QueryContext(ctx context.Context, query string, args []driver return nil, driver.ErrSkip } -func errf(msg string, args ...interface{}) error { +func errf(msg string, args ...any) error { return errors.New("fakedb: " + fmt.Sprintf(msg, args...)) } @@ -586,7 +586,7 @@ func (c *fakeConn) prepareInsert(ctx context.Context, stmt *fakeStmt, parts []st stmt.colName = append(stmt.colName, column) if !strings.HasPrefix(value, "?") { - var subsetVal interface{} + var subsetVal any // Convert to driver subset type switch ctype { case "string": @@ -829,9 +829,9 @@ func (s *fakeStmt) execInsert(args []driver.NamedValue, doInsert bool) (driver.R t.mu.Lock() defer t.mu.Unlock() - var cols []interface{} + var cols []any if doInsert { - cols = make([]interface{}, len(t.colname)) + cols = make([]any, len(t.colname)) } argPos := 0 for n, colname := range s.colName { @@ -839,7 +839,7 @@ func (s *fakeStmt) execInsert(args []driver.NamedValue, doInsert bool) (driver.R if colidx == -1 { return nil, fmt.Errorf("fakedb: column %q doesn't exist or dropped since prepared statement was created", colname) } - var val interface{} + var val any if strvalue, ok := s.colValue[n].(string); ok && strings.HasPrefix(strvalue, "?") { if strvalue == "?" { val = args[argPos].Value @@ -930,7 +930,7 @@ func (s *fakeStmt) QueryContext(ctx context.Context, args []driver.NamedValue) ( rows: [][]*row{ { { - cols: []interface{}{ + cols: []any{ txStatus, }, }, @@ -980,7 +980,7 @@ func (s *fakeStmt) QueryContext(ctx context.Context, args []driver.NamedValue) ( // lazy hack to avoid sprintf %v on a []byte tcol = string(bs) } - var argValue interface{} + var argValue any if wcol.Placeholder == "?" { argValue = args[wcol.Ordinal-1].Value } else { @@ -996,7 +996,7 @@ func (s *fakeStmt) QueryContext(ctx context.Context, args []driver.NamedValue) ( continue rows } } - mrow := &row{cols: make([]interface{}, len(s.colName))} + mrow := &row{cols: make([]any, len(s.colName))} for seli, name := range s.colName { mrow.cols[seli] = trow.cols[colIdx[name]] } @@ -1174,7 +1174,7 @@ func (rc *rowsCursor) NextResultSet() error { // type fakeDriverString struct{} -func (fakeDriverString) ConvertValue(v interface{}) (driver.Value, error) { +func (fakeDriverString) ConvertValue(v any) (driver.Value, error) { switch c := v.(type) { case string, []byte: return v, nil @@ -1189,7 +1189,7 @@ func (fakeDriverString) ConvertValue(v interface{}) (driver.Value, error) { type anyTypeConverter struct{} -func (anyTypeConverter) ConvertValue(v interface{}) (driver.Value, error) { +func (anyTypeConverter) ConvertValue(v any) (driver.Value, error) { return v, nil } @@ -1260,7 +1260,7 @@ func colTypeToReflectType(typ string) reflect.Type { case "datetime": return reflect.TypeOf(time.Time{}) case "any": - return reflect.TypeOf(new(interface{})).Elem() + return reflect.TypeOf(new(any)).Elem() } panic("invalid fakedb column type of " + typ) } diff --git a/src/database/sql/sql.go b/src/database/sql/sql.go index c5b4f50aa7..d55cee1210 100644 --- a/src/database/sql/sql.go +++ b/src/database/sql/sql.go @@ -92,7 +92,7 @@ type NamedArg struct { // Value is the value of the parameter. // It may be assigned the same value types as the query // arguments. - Value interface{} + Value any } // Named provides a more concise way to create NamedArg values. @@ -107,7 +107,7 @@ type NamedArg struct { // sql.Named("start", startTime), // sql.Named("end", endTime), // ) -func Named(name string, value interface{}) NamedArg { +func Named(name string, value any) NamedArg { // This method exists because the go1compat promise // doesn't guarantee that structs don't grow more fields, // so unkeyed struct literals are a vet error. Thus, we don't @@ -191,7 +191,7 @@ type NullString struct { } // Scan implements the Scanner interface. -func (ns *NullString) Scan(value interface{}) error { +func (ns *NullString) Scan(value any) error { if value == nil { ns.String, ns.Valid = "", false return nil @@ -217,7 +217,7 @@ type NullInt64 struct { } // Scan implements the Scanner interface. -func (n *NullInt64) Scan(value interface{}) error { +func (n *NullInt64) Scan(value any) error { if value == nil { n.Int64, n.Valid = 0, false return nil @@ -243,7 +243,7 @@ type NullInt32 struct { } // Scan implements the Scanner interface. -func (n *NullInt32) Scan(value interface{}) error { +func (n *NullInt32) Scan(value any) error { if value == nil { n.Int32, n.Valid = 0, false return nil @@ -269,7 +269,7 @@ type NullInt16 struct { } // Scan implements the Scanner interface. -func (n *NullInt16) Scan(value interface{}) error { +func (n *NullInt16) Scan(value any) error { if value == nil { n.Int16, n.Valid = 0, false return nil @@ -296,7 +296,7 @@ type NullByte struct { } // Scan implements the Scanner interface. -func (n *NullByte) Scan(value interface{}) error { +func (n *NullByte) Scan(value any) error { if value == nil { n.Byte, n.Valid = 0, false return nil @@ -323,7 +323,7 @@ type NullFloat64 struct { } // Scan implements the Scanner interface. -func (n *NullFloat64) Scan(value interface{}) error { +func (n *NullFloat64) Scan(value any) error { if value == nil { n.Float64, n.Valid = 0, false return nil @@ -349,7 +349,7 @@ type NullBool struct { } // Scan implements the Scanner interface. -func (n *NullBool) Scan(value interface{}) error { +func (n *NullBool) Scan(value any) error { if value == nil { n.Bool, n.Valid = false, false return nil @@ -375,7 +375,7 @@ type NullTime struct { } // Scan implements the Scanner interface. -func (n *NullTime) Scan(value interface{}) error { +func (n *NullTime) Scan(value any) error { if value == nil { n.Time, n.Valid = time.Time{}, false return nil @@ -412,7 +412,7 @@ type Scanner interface { // Reference types such as []byte are only valid until the next call to Scan // and should not be retained. Their underlying memory is owned by the driver. // If retention is necessary, copy their values before the next call to Scan. - Scan(src interface{}) error + Scan(src any) error } // Out may be used to retrieve OUTPUT value parameters from stored procedures. @@ -428,7 +428,7 @@ type Out struct { // Dest is a pointer to the value that will be set to the result of the // stored procedure's OUTPUT parameter. - Dest interface{} + Dest any // In is whether the parameter is an INOUT parameter. If so, the input value to the stored // procedure is the dereferenced value of Dest's pointer, which is then replaced with @@ -680,7 +680,7 @@ func (ds *driverStmt) Close() error { } // depSet is a finalCloser's outstanding dependencies -type depSet map[interface{}]bool // set of true bools +type depSet map[any]bool // set of true bools // The finalCloser interface is used by (*DB).addDep and related // dependency reference counting. @@ -692,13 +692,13 @@ type finalCloser interface { // addDep notes that x now depends on dep, and x's finalClose won't be // called until all of x's dependencies are removed with removeDep. -func (db *DB) addDep(x finalCloser, dep interface{}) { +func (db *DB) addDep(x finalCloser, dep any) { db.mu.Lock() defer db.mu.Unlock() db.addDepLocked(x, dep) } -func (db *DB) addDepLocked(x finalCloser, dep interface{}) { +func (db *DB) addDepLocked(x finalCloser, dep any) { if db.dep == nil { db.dep = make(map[finalCloser]depSet) } @@ -714,14 +714,14 @@ func (db *DB) addDepLocked(x finalCloser, dep interface{}) { // If x still has dependencies, nil is returned. // If x no longer has any dependencies, its finalClose method will be // called and its error value will be returned. -func (db *DB) removeDep(x finalCloser, dep interface{}) error { +func (db *DB) removeDep(x finalCloser, dep any) error { db.mu.Lock() fn := db.removeDepLocked(x, dep) db.mu.Unlock() return fn() } -func (db *DB) removeDepLocked(x finalCloser, dep interface{}) func() error { +func (db *DB) removeDepLocked(x finalCloser, dep any) func() error { xdep, ok := db.dep[x] if !ok { @@ -1627,7 +1627,7 @@ func (db *DB) prepareDC(ctx context.Context, dc *driverConn, release func(error) // ExecContext executes a query without returning any rows. // The args are for any placeholder parameters in the query. -func (db *DB) ExecContext(ctx context.Context, query string, args ...interface{}) (Result, error) { +func (db *DB) ExecContext(ctx context.Context, query string, args ...any) (Result, error) { var res Result var err error var isBadConn bool @@ -1649,11 +1649,11 @@ func (db *DB) ExecContext(ctx context.Context, query string, args ...interface{} // // Exec uses context.Background internally; to specify the context, use // ExecContext. -func (db *DB) Exec(query string, args ...interface{}) (Result, error) { +func (db *DB) Exec(query string, args ...any) (Result, error) { return db.ExecContext(context.Background(), query, args...) } -func (db *DB) exec(ctx context.Context, query string, args []interface{}, strategy connReuseStrategy) (Result, error) { +func (db *DB) exec(ctx context.Context, query string, args []any, strategy connReuseStrategy) (Result, error) { dc, err := db.conn(ctx, strategy) if err != nil { return nil, err @@ -1661,7 +1661,7 @@ func (db *DB) exec(ctx context.Context, query string, args []interface{}, strate return db.execDC(ctx, dc, dc.releaseConn, query, args) } -func (db *DB) execDC(ctx context.Context, dc *driverConn, release func(error), query string, args []interface{}) (res Result, err error) { +func (db *DB) execDC(ctx context.Context, dc *driverConn, release func(error), query string, args []any) (res Result, err error) { defer func() { release(err) }() @@ -1702,7 +1702,7 @@ func (db *DB) execDC(ctx context.Context, dc *driverConn, release func(error), q // QueryContext executes a query that returns rows, typically a SELECT. // The args are for any placeholder parameters in the query. -func (db *DB) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) { +func (db *DB) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error) { var rows *Rows var err error var isBadConn bool @@ -1724,11 +1724,11 @@ func (db *DB) QueryContext(ctx context.Context, query string, args ...interface{ // // Query uses context.Background internally; to specify the context, use // QueryContext. -func (db *DB) Query(query string, args ...interface{}) (*Rows, error) { +func (db *DB) Query(query string, args ...any) (*Rows, error) { return db.QueryContext(context.Background(), query, args...) } -func (db *DB) query(ctx context.Context, query string, args []interface{}, strategy connReuseStrategy) (*Rows, error) { +func (db *DB) query(ctx context.Context, query string, args []any, strategy connReuseStrategy) (*Rows, error) { dc, err := db.conn(ctx, strategy) if err != nil { return nil, err @@ -1741,7 +1741,7 @@ func (db *DB) query(ctx context.Context, query string, args []interface{}, strat // The connection gets released by the releaseConn function. // The ctx context is from a query method and the txctx context is from an // optional transaction context. -func (db *DB) queryDC(ctx, txctx context.Context, dc *driverConn, releaseConn func(error), query string, args []interface{}) (*Rows, error) { +func (db *DB) queryDC(ctx, txctx context.Context, dc *driverConn, releaseConn func(error), query string, args []any) (*Rows, error) { queryerCtx, ok := dc.ci.(driver.QueryerContext) var queryer driver.Queryer if !ok { @@ -1811,7 +1811,7 @@ func (db *DB) queryDC(ctx, txctx context.Context, dc *driverConn, releaseConn fu // If the query selects no rows, the *Row's Scan will return ErrNoRows. // Otherwise, the *Row's Scan scans the first selected row and discards // the rest. -func (db *DB) QueryRowContext(ctx context.Context, query string, args ...interface{}) *Row { +func (db *DB) QueryRowContext(ctx context.Context, query string, args ...any) *Row { rows, err := db.QueryContext(ctx, query, args...) return &Row{rows: rows, err: err} } @@ -1825,7 +1825,7 @@ func (db *DB) QueryRowContext(ctx context.Context, query string, args ...interfa // // QueryRow uses context.Background internally; to specify the context, use // QueryRowContext. -func (db *DB) QueryRow(query string, args ...interface{}) *Row { +func (db *DB) QueryRow(query string, args ...any) *Row { return db.QueryRowContext(context.Background(), query, args...) } @@ -1995,7 +1995,7 @@ func (c *Conn) PingContext(ctx context.Context) error { // ExecContext executes a query without returning any rows. // The args are for any placeholder parameters in the query. -func (c *Conn) ExecContext(ctx context.Context, query string, args ...interface{}) (Result, error) { +func (c *Conn) ExecContext(ctx context.Context, query string, args ...any) (Result, error) { dc, release, err := c.grabConn(ctx) if err != nil { return nil, err @@ -2005,7 +2005,7 @@ func (c *Conn) ExecContext(ctx context.Context, query string, args ...interface{ // QueryContext executes a query that returns rows, typically a SELECT. // The args are for any placeholder parameters in the query. -func (c *Conn) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) { +func (c *Conn) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error) { dc, release, err := c.grabConn(ctx) if err != nil { return nil, err @@ -2019,7 +2019,7 @@ func (c *Conn) QueryContext(ctx context.Context, query string, args ...interface // If the query selects no rows, the *Row's Scan will return ErrNoRows. // Otherwise, the *Row's Scan scans the first selected row and discards // the rest. -func (c *Conn) QueryRowContext(ctx context.Context, query string, args ...interface{}) *Row { +func (c *Conn) QueryRowContext(ctx context.Context, query string, args ...any) *Row { rows, err := c.QueryContext(ctx, query, args...) return &Row{rows: rows, err: err} } @@ -2045,7 +2045,7 @@ func (c *Conn) PrepareContext(ctx context.Context, query string) (*Stmt, error) // // Once f returns and err is not driver.ErrBadConn, the Conn will continue to be usable // until Conn.Close is called. -func (c *Conn) Raw(f func(driverConn interface{}) error) (err error) { +func (c *Conn) Raw(f func(driverConn any) error) (err error) { var dc *driverConn var release releaseConn @@ -2483,7 +2483,7 @@ func (tx *Tx) Stmt(stmt *Stmt) *Stmt { // ExecContext executes a query that doesn't return rows. // For example: an INSERT and UPDATE. -func (tx *Tx) ExecContext(ctx context.Context, query string, args ...interface{}) (Result, error) { +func (tx *Tx) ExecContext(ctx context.Context, query string, args ...any) (Result, error) { dc, release, err := tx.grabConn(ctx) if err != nil { return nil, err @@ -2496,12 +2496,12 @@ func (tx *Tx) ExecContext(ctx context.Context, query string, args ...interface{} // // Exec uses context.Background internally; to specify the context, use // ExecContext. -func (tx *Tx) Exec(query string, args ...interface{}) (Result, error) { +func (tx *Tx) Exec(query string, args ...any) (Result, error) { return tx.ExecContext(context.Background(), query, args...) } // QueryContext executes a query that returns rows, typically a SELECT. -func (tx *Tx) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) { +func (tx *Tx) QueryContext(ctx context.Context, query string, args ...any) (*Rows, error) { dc, release, err := tx.grabConn(ctx) if err != nil { return nil, err @@ -2514,7 +2514,7 @@ func (tx *Tx) QueryContext(ctx context.Context, query string, args ...interface{ // // Query uses context.Background internally; to specify the context, use // QueryContext. -func (tx *Tx) Query(query string, args ...interface{}) (*Rows, error) { +func (tx *Tx) Query(query string, args ...any) (*Rows, error) { return tx.QueryContext(context.Background(), query, args...) } @@ -2524,7 +2524,7 @@ func (tx *Tx) Query(query string, args ...interface{}) (*Rows, error) { // If the query selects no rows, the *Row's Scan will return ErrNoRows. // Otherwise, the *Row's Scan scans the first selected row and discards // the rest. -func (tx *Tx) QueryRowContext(ctx context.Context, query string, args ...interface{}) *Row { +func (tx *Tx) QueryRowContext(ctx context.Context, query string, args ...any) *Row { rows, err := tx.QueryContext(ctx, query, args...) return &Row{rows: rows, err: err} } @@ -2538,7 +2538,7 @@ func (tx *Tx) QueryRowContext(ctx context.Context, query string, args ...interfa // // QueryRow uses context.Background internally; to specify the context, use // QueryRowContext. -func (tx *Tx) QueryRow(query string, args ...interface{}) *Row { +func (tx *Tx) QueryRow(query string, args ...any) *Row { return tx.QueryRowContext(context.Background(), query, args...) } @@ -2615,7 +2615,7 @@ type Stmt struct { // ExecContext executes a prepared statement with the given arguments and // returns a Result summarizing the effect of the statement. -func (s *Stmt) ExecContext(ctx context.Context, args ...interface{}) (Result, error) { +func (s *Stmt) ExecContext(ctx context.Context, args ...any) (Result, error) { s.closemu.RLock() defer s.closemu.RUnlock() @@ -2647,11 +2647,11 @@ func (s *Stmt) ExecContext(ctx context.Context, args ...interface{}) (Result, er // // Exec uses context.Background internally; to specify the context, use // ExecContext. -func (s *Stmt) Exec(args ...interface{}) (Result, error) { +func (s *Stmt) Exec(args ...any) (Result, error) { return s.ExecContext(context.Background(), args...) } -func resultFromStatement(ctx context.Context, ci driver.Conn, ds *driverStmt, args ...interface{}) (Result, error) { +func resultFromStatement(ctx context.Context, ci driver.Conn, ds *driverStmt, args ...any) (Result, error) { ds.Lock() defer ds.Unlock() @@ -2763,7 +2763,7 @@ func (s *Stmt) prepareOnConnLocked(ctx context.Context, dc *driverConn) (*driver // QueryContext executes a prepared query statement with the given arguments // and returns the query results as a *Rows. -func (s *Stmt) QueryContext(ctx context.Context, args ...interface{}) (*Rows, error) { +func (s *Stmt) QueryContext(ctx context.Context, args ...any) (*Rows, error) { s.closemu.RLock() defer s.closemu.RUnlock() @@ -2821,11 +2821,11 @@ func (s *Stmt) QueryContext(ctx context.Context, args ...interface{}) (*Rows, er // // Query uses context.Background internally; to specify the context, use // QueryContext. -func (s *Stmt) Query(args ...interface{}) (*Rows, error) { +func (s *Stmt) Query(args ...any) (*Rows, error) { return s.QueryContext(context.Background(), args...) } -func rowsiFromStatement(ctx context.Context, ci driver.Conn, ds *driverStmt, args ...interface{}) (driver.Rows, error) { +func rowsiFromStatement(ctx context.Context, ci driver.Conn, ds *driverStmt, args ...any) (driver.Rows, error) { ds.Lock() defer ds.Unlock() dargs, err := driverArgsConnLocked(ci, ds, args) @@ -2841,7 +2841,7 @@ func rowsiFromStatement(ctx context.Context, ci driver.Conn, ds *driverStmt, arg // If the query selects no rows, the *Row's Scan will return ErrNoRows. // Otherwise, the *Row's Scan scans the first selected row and discards // the rest. -func (s *Stmt) QueryRowContext(ctx context.Context, args ...interface{}) *Row { +func (s *Stmt) QueryRowContext(ctx context.Context, args ...any) *Row { rows, err := s.QueryContext(ctx, args...) if err != nil { return &Row{err: err} @@ -2863,7 +2863,7 @@ func (s *Stmt) QueryRowContext(ctx context.Context, args ...interface{}) *Row { // // QueryRow uses context.Background internally; to specify the context, use // QueryRowContext. -func (s *Stmt) QueryRow(args ...interface{}) *Row { +func (s *Stmt) QueryRow(args ...any) *Row { return s.QueryRowContext(context.Background(), args...) } @@ -3185,7 +3185,7 @@ func rowsColumnInfoSetupConnLocked(rowsi driver.Rows) []*ColumnType { if prop, ok := rowsi.(driver.RowsColumnTypeScanType); ok { ci.scanType = prop.ColumnTypeScanType(i) } else { - ci.scanType = reflect.TypeOf(new(interface{})).Elem() + ci.scanType = reflect.TypeOf(new(any)).Elem() } if prop, ok := rowsi.(driver.RowsColumnTypeDatabaseTypeName); ok { ci.databaseType = prop.ColumnTypeDatabaseTypeName(i) @@ -3263,7 +3263,7 @@ func rowsColumnInfoSetupConnLocked(rowsi driver.Rows) []*ColumnType { // // If any of the first arguments implementing Scanner returns an error, // that error will be wrapped in the returned error -func (rs *Rows) Scan(dest ...interface{}) error { +func (rs *Rows) Scan(dest ...any) error { rs.closemu.RLock() if rs.lasterr != nil && rs.lasterr != io.EOF { @@ -3346,7 +3346,7 @@ type Row struct { // If more than one row matches the query, // Scan uses the first row and discards the rest. If no row matches // the query, Scan returns ErrNoRows. -func (r *Row) Scan(dest ...interface{}) error { +func (r *Row) Scan(dest ...any) error { if r.err != nil { return r.err } diff --git a/src/database/sql/sql_test.go b/src/database/sql/sql_test.go index b887b40d71..1bb9afc407 100644 --- a/src/database/sql/sql_test.go +++ b/src/database/sql/sql_test.go @@ -135,7 +135,7 @@ func TestDriverPanic(t *testing.T) { exec(t, db, "WIPE") // check not deadlocked } -func exec(t testing.TB, db *DB, query string, args ...interface{}) { +func exec(t testing.TB, db *DB, query string, args ...any) { t.Helper() _, err := db.Exec(query, args...) if err != nil { @@ -743,7 +743,7 @@ func TestRowsColumnTypes(t *testing.T) { } types[i] = st } - values := make([]interface{}, len(tt)) + values := make([]any, len(tt)) for i := range values { values[i] = reflect.New(types[i]).Interface() } @@ -1006,23 +1006,23 @@ func TestExec(t *testing.T) { defer stmt.Close() type execTest struct { - args []interface{} + args []any wantErr string } execTests := []execTest{ // Okay: - {[]interface{}{"Brad", 31}, ""}, - {[]interface{}{"Brad", int64(31)}, ""}, - {[]interface{}{"Bob", "32"}, ""}, - {[]interface{}{7, 9}, ""}, + {[]any{"Brad", 31}, ""}, + {[]any{"Brad", int64(31)}, ""}, + {[]any{"Bob", "32"}, ""}, + {[]any{7, 9}, ""}, // Invalid conversions: - {[]interface{}{"Brad", int64(0xFFFFFFFF)}, "sql: converting argument $2 type: sql/driver: value 4294967295 overflows int32"}, - {[]interface{}{"Brad", "strconv fail"}, `sql: converting argument $2 type: sql/driver: value "strconv fail" can't be converted to int32`}, + {[]any{"Brad", int64(0xFFFFFFFF)}, "sql: converting argument $2 type: sql/driver: value 4294967295 overflows int32"}, + {[]any{"Brad", "strconv fail"}, `sql: converting argument $2 type: sql/driver: value "strconv fail" can't be converted to int32`}, // Wrong number of args: - {[]interface{}{}, "sql: expected 2 arguments, got 0"}, - {[]interface{}{1, 2, 3}, "sql: expected 2 arguments, got 3"}, + {[]any{}, "sql: expected 2 arguments, got 0"}, + {[]any{1, 2, 3}, "sql: expected 2 arguments, got 3"}, } for n, et := range execTests { _, err := stmt.Exec(et.args...) @@ -1409,7 +1409,7 @@ func TestConnRaw(t *testing.T) { defer conn.Close() sawFunc := false - err = conn.Raw(func(dc interface{}) error { + err = conn.Raw(func(dc any) error { sawFunc = true if _, ok := dc.(*fakeConn); !ok { return fmt.Errorf("got %T want *fakeConn", dc) @@ -1436,7 +1436,7 @@ func TestConnRaw(t *testing.T) { t.Fatal("expected connection to be closed after panic") } }() - err = conn.Raw(func(dc interface{}) error { + err = conn.Raw(func(dc any) error { panic("Conn.Raw panic should return an error") }) t.Fatal("expected panic from Raw func") @@ -1495,7 +1495,7 @@ func TestInvalidNilValues(t *testing.T) { tests := []struct { name string - input interface{} + input any expectedError string }{ { @@ -1593,7 +1593,7 @@ func TestConnIsValid(t *testing.T) { t.Fatal(err) } - err = c.Raw(func(raw interface{}) error { + err = c.Raw(func(raw any) error { dc := raw.(*fakeConn) dc.stickyBad = true return nil @@ -1772,9 +1772,9 @@ func TestIssue6651(t *testing.T) { } type nullTestRow struct { - nullParam interface{} - notNullParam interface{} - scanNullVal interface{} + nullParam any + notNullParam any + scanNullVal any } type nullTestSpec struct { @@ -4129,7 +4129,7 @@ func TestNamedValueChecker(t *testing.T) { t.Fatal("select", err) } - list := []struct{ got, want interface{} }{ + list := []struct{ got, want any }{ {o1, "from-server"}, {dec1, decimalInt{123}}, {str1, "hello"}, @@ -4318,7 +4318,7 @@ type alwaysErrScanner struct{} var errTestScanWrap = errors.New("errTestScanWrap") -func (alwaysErrScanner) Scan(interface{}) error { +func (alwaysErrScanner) Scan(any) error { return errTestScanWrap } diff --git a/src/debug/dwarf/entry.go b/src/debug/dwarf/entry.go index 25a3b5beec..cbdc838a12 100644 --- a/src/debug/dwarf/entry.go +++ b/src/debug/dwarf/entry.go @@ -261,7 +261,7 @@ type Entry struct { // ClassUnknown. type Field struct { Attr Attr - Val interface{} + Val any Class Class } @@ -382,7 +382,7 @@ func (i Class) GoString() string { // the check that the value has the expected dynamic type, as in: // v, ok := e.Val(AttrSibling).(int64) // -func (e *Entry) Val(a Attr) interface{} { +func (e *Entry) Val(a Attr) any { if f := e.AttrField(a); f != nil { return f.Val } @@ -501,7 +501,7 @@ func (b *buf) entry(cu *Entry, atab abbrevTable, ubase Offset, vers int) *Entry fmt = format(b.uint()) e.Field[i].Class = formToClass(fmt, a.field[i].attr, vers, b) } - var val interface{} + var val any switch fmt { default: b.error("unknown entry attr format 0x" + strconv.FormatInt(int64(fmt), 16)) diff --git a/src/debug/dwarf/entry_test.go b/src/debug/dwarf/entry_test.go index 1f41d742ea..8c6ca7259e 100644 --- a/src/debug/dwarf/entry_test.go +++ b/src/debug/dwarf/entry_test.go @@ -277,7 +277,7 @@ func TestUnitIteration(t *testing.T) { for _, file := range files { t.Run(file, func(t *testing.T) { d := elfData(t, file) - var units [2][]interface{} + var units [2][]any for method := range units { for r := d.Reader(); ; { ent, err := r.Next() diff --git a/src/debug/elf/elf_test.go b/src/debug/elf/elf_test.go index f8985a8992..a61b491090 100644 --- a/src/debug/elf/elf_test.go +++ b/src/debug/elf/elf_test.go @@ -10,7 +10,7 @@ import ( ) type nameTest struct { - val interface{} + val any str string } diff --git a/src/debug/elf/file.go b/src/debug/elf/file.go index e265796ddc..eefcaab8d6 100644 --- a/src/debug/elf/file.go +++ b/src/debug/elf/file.go @@ -185,7 +185,7 @@ type Symbol struct { type FormatError struct { off int64 msg string - val interface{} + val any } func (e *FormatError) Error() string { diff --git a/src/debug/gosym/symtab.go b/src/debug/gosym/symtab.go index 72490dca8a..4e63f1cdf7 100644 --- a/src/debug/gosym/symtab.go +++ b/src/debug/gosym/symtab.go @@ -751,7 +751,7 @@ func (e *UnknownLineError) Error() string { type DecodingError struct { off int msg string - val interface{} + val any } func (e *DecodingError) Error() string { diff --git a/src/debug/macho/file.go b/src/debug/macho/file.go index cdc500e476..b57dba8496 100644 --- a/src/debug/macho/file.go +++ b/src/debug/macho/file.go @@ -184,7 +184,7 @@ type Symbol struct { type FormatError struct { off int64 msg string - val interface{} + val any } func (e *FormatError) Error() string { diff --git a/src/debug/macho/file_test.go b/src/debug/macho/file_test.go index 9beeb80dd2..313c376c54 100644 --- a/src/debug/macho/file_test.go +++ b/src/debug/macho/file_test.go @@ -15,7 +15,7 @@ import ( type fileTest struct { file string hdr FileHeader - loads []interface{} + loads []any sections []*SectionHeader relocations map[string][]Reloc } @@ -24,7 +24,7 @@ var fileTests = []fileTest{ { "testdata/gcc-386-darwin-exec.base64", FileHeader{0xfeedface, Cpu386, 0x3, 0x2, 0xc, 0x3c0, 0x85}, - []interface{}{ + []any{ &SegmentHeader{LoadCmdSegment, 0x38, "__PAGEZERO", 0x0, 0x1000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, &SegmentHeader{LoadCmdSegment, 0xc0, "__TEXT", 0x1000, 0x1000, 0x0, 0x1000, 0x7, 0x5, 0x2, 0x0}, &SegmentHeader{LoadCmdSegment, 0xc0, "__DATA", 0x2000, 0x1000, 0x1000, 0x1000, 0x7, 0x3, 0x2, 0x0}, @@ -50,7 +50,7 @@ var fileTests = []fileTest{ { "testdata/gcc-amd64-darwin-exec.base64", FileHeader{0xfeedfacf, CpuAmd64, 0x80000003, 0x2, 0xb, 0x568, 0x85}, - []interface{}{ + []any{ &SegmentHeader{LoadCmdSegment64, 0x48, "__PAGEZERO", 0x0, 0x100000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, &SegmentHeader{LoadCmdSegment64, 0x1d8, "__TEXT", 0x100000000, 0x1000, 0x0, 0x1000, 0x7, 0x5, 0x5, 0x0}, &SegmentHeader{LoadCmdSegment64, 0x138, "__DATA", 0x100001000, 0x1000, 0x1000, 0x1000, 0x7, 0x3, 0x3, 0x0}, @@ -78,7 +78,7 @@ var fileTests = []fileTest{ { "testdata/gcc-amd64-darwin-exec-debug.base64", FileHeader{0xfeedfacf, CpuAmd64, 0x80000003, 0xa, 0x4, 0x5a0, 0}, - []interface{}{ + []any{ nil, // LC_UUID &SegmentHeader{LoadCmdSegment64, 0x1d8, "__TEXT", 0x100000000, 0x1000, 0x0, 0x0, 0x7, 0x5, 0x5, 0x0}, &SegmentHeader{LoadCmdSegment64, 0x138, "__DATA", 0x100001000, 0x1000, 0x0, 0x0, 0x7, 0x3, 0x3, 0x0}, @@ -106,7 +106,7 @@ var fileTests = []fileTest{ { "testdata/clang-386-darwin-exec-with-rpath.base64", FileHeader{0xfeedface, Cpu386, 0x3, 0x2, 0x10, 0x42c, 0x1200085}, - []interface{}{ + []any{ nil, // LC_SEGMENT nil, // LC_SEGMENT nil, // LC_SEGMENT @@ -130,7 +130,7 @@ var fileTests = []fileTest{ { "testdata/clang-amd64-darwin-exec-with-rpath.base64", FileHeader{0xfeedfacf, CpuAmd64, 0x80000003, 0x2, 0x10, 0x4c8, 0x200085}, - []interface{}{ + []any{ nil, // LC_SEGMENT nil, // LC_SEGMENT nil, // LC_SEGMENT diff --git a/src/debug/pe/file.go b/src/debug/pe/file.go index ab00a48f5c..aa0955a133 100644 --- a/src/debug/pe/file.go +++ b/src/debug/pe/file.go @@ -22,7 +22,7 @@ const seekStart = 0 // A File represents an open PE file. type File struct { FileHeader - OptionalHeader interface{} // of type *OptionalHeader32 or *OptionalHeader64 + OptionalHeader any // of type *OptionalHeader32 or *OptionalHeader64 Sections []*Section Symbols []*Symbol // COFF symbols with auxiliary symbol records removed COFFSymbols []COFFSymbol // all COFF symbols (including auxiliary symbol records) @@ -452,7 +452,7 @@ func (e *FormatError) Error() string { // and its size as seen in the file header. // It parses the given size of bytes and returns optional header. It infers whether the // bytes being parsed refer to 32 bit or 64 bit version of optional header. -func readOptionalHeader(r io.ReadSeeker, sz uint16) (interface{}, error) { +func readOptionalHeader(r io.ReadSeeker, sz uint16) (any, error) { // If optional header size is 0, return empty optional header. if sz == 0 { return nil, nil @@ -473,7 +473,7 @@ func readOptionalHeader(r io.ReadSeeker, sz uint16) (interface{}, error) { // read reads from io.ReadSeeke, r, into data. var err error - read := func(data interface{}) bool { + read := func(data any) bool { err = binary.Read(r, binary.LittleEndian, data) return err == nil } diff --git a/src/debug/pe/file_test.go b/src/debug/pe/file_test.go index 8964b4f847..5368e08ad7 100644 --- a/src/debug/pe/file_test.go +++ b/src/debug/pe/file_test.go @@ -22,7 +22,7 @@ import ( type fileTest struct { file string hdr FileHeader - opthdr interface{} + opthdr any sections []*SectionHeader symbols []*Symbol hasNoDwarfInfo bool @@ -250,7 +250,7 @@ var fileTests = []fileTest{ }, } -func isOptHdrEq(a, b interface{}) bool { +func isOptHdrEq(a, b any) bool { switch va := a.(type) { case *OptionalHeader32: vb, ok := b.(*OptionalHeader32) diff --git a/src/debug/plan9obj/file.go b/src/debug/plan9obj/file.go index c054635148..0c33fa10bb 100644 --- a/src/debug/plan9obj/file.go +++ b/src/debug/plan9obj/file.go @@ -82,7 +82,7 @@ type Sym struct { type formatError struct { off int msg string - val interface{} + val any } func (e *formatError) Error() string { diff --git a/src/embed/embed.go b/src/embed/embed.go index 24c3a89e9b..9737ccdf6b 100644 --- a/src/embed/embed.go +++ b/src/embed/embed.go @@ -232,7 +232,7 @@ func (f *file) Name() string { _, elem, _ := split(f.name); return func (f *file) Size() int64 { return int64(len(f.data)) } func (f *file) ModTime() time.Time { return time.Time{} } func (f *file) IsDir() bool { _, _, isDir := split(f.name); return isDir } -func (f *file) Sys() interface{} { return nil } +func (f *file) Sys() any { return nil } func (f *file) Type() fs.FileMode { return f.Mode().Type() } func (f *file) Info() (fs.FileInfo, error) { return f, nil } diff --git a/src/embed/internal/embedtest/embed_test.go b/src/embed/internal/embedtest/embed_test.go index 1337e421bd..cbd58ee846 100644 --- a/src/embed/internal/embedtest/embed_test.go +++ b/src/embed/internal/embedtest/embed_test.go @@ -162,7 +162,7 @@ func TestAliases(t *testing.T) { if e != nil { t.Fatal("ReadFile:", e) } - check := func(g interface{}) { + check := func(g any) { got := reflect.ValueOf(g) for i := 0; i < got.Len(); i++ { if byte(got.Index(i).Uint()) != want[i] { diff --git a/src/encoding/ascii85/ascii85_test.go b/src/encoding/ascii85/ascii85_test.go index c637103942..9e6b34e997 100644 --- a/src/encoding/ascii85/ascii85_test.go +++ b/src/encoding/ascii85/ascii85_test.go @@ -42,7 +42,7 @@ var pairs = []testpair{ }, } -func testEqual(t *testing.T, msg string, args ...interface{}) bool { +func testEqual(t *testing.T, msg string, args ...any) bool { t.Helper() if args[len(args)-2] != args[len(args)-1] { t.Errorf(msg, args...) diff --git a/src/encoding/asn1/asn1.go b/src/encoding/asn1/asn1.go index d0e1c6b176..cad1d7b08f 100644 --- a/src/encoding/asn1/asn1.go +++ b/src/encoding/asn1/asn1.go @@ -695,7 +695,7 @@ func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParam err = SyntaxError{"data truncated"} return } - var result interface{} + var result any if !t.isCompound && t.class == ClassUniversal { innerBytes := bytes[offset : offset+t.length] switch t.tag { @@ -1086,7 +1086,7 @@ func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) { // // Other ASN.1 types are not supported; if it encounters them, // Unmarshal returns a parse error. -func Unmarshal(b []byte, val interface{}) (rest []byte, err error) { +func Unmarshal(b []byte, val any) (rest []byte, err error) { return UnmarshalWithParams(b, val, "") } @@ -1109,7 +1109,7 @@ func (e *invalidUnmarshalError) Error() string { // UnmarshalWithParams allows field parameters to be specified for the // top-level element. The form of the params is the same as the field tags. -func UnmarshalWithParams(b []byte, val interface{}, params string) (rest []byte, err error) { +func UnmarshalWithParams(b []byte, val any, params string) (rest []byte, err error) { v := reflect.ValueOf(val) if v.Kind() != reflect.Pointer || v.IsNil() { return nil, &invalidUnmarshalError{reflect.TypeOf(val)} diff --git a/src/encoding/asn1/asn1_test.go b/src/encoding/asn1/asn1_test.go index 8985538468..b1e05b96ae 100644 --- a/src/encoding/asn1/asn1_test.go +++ b/src/encoding/asn1/asn1_test.go @@ -479,7 +479,7 @@ type TestSet struct { var unmarshalTestData = []struct { in []byte - out interface{} + out any }{ {[]byte{0x02, 0x01, 0x42}, newInt(0x42)}, {[]byte{0x05, 0x00}, &RawValue{0, 5, false, []byte{}, []byte{0x05, 0x00}}}, @@ -521,7 +521,7 @@ func TestUnmarshal(t *testing.T) { func TestUnmarshalWithNilOrNonPointer(t *testing.T) { tests := []struct { b []byte - v interface{} + v any want string }{ {b: []byte{0x05, 0x00}, v: nil, want: "asn1: Unmarshal recipient value is nil"}, @@ -567,7 +567,7 @@ type RelativeDistinguishedNameSET []AttributeTypeAndValue type AttributeTypeAndValue struct { Type ObjectIdentifier - Value interface{} + Value any } type Validity struct { @@ -998,9 +998,9 @@ func TestUnmarshalInvalidUTF8(t *testing.T) { } func TestMarshalNilValue(t *testing.T) { - nilValueTestData := []interface{}{ + nilValueTestData := []any{ nil, - struct{ V interface{} }{}, + struct{ V any }{}, } for i, test := range nilValueTestData { if _, err := Marshal(test); err == nil { diff --git a/src/encoding/asn1/marshal.go b/src/encoding/asn1/marshal.go index 5b4d786d49..c243349175 100644 --- a/src/encoding/asn1/marshal.go +++ b/src/encoding/asn1/marshal.go @@ -730,13 +730,13 @@ func makeField(v reflect.Value, params fieldParameters) (e encoder, err error) { // utf8: causes strings to be marshaled as ASN.1, UTF8String values // utc: causes time.Time to be marshaled as ASN.1, UTCTime values // generalized: causes time.Time to be marshaled as ASN.1, GeneralizedTime values -func Marshal(val interface{}) ([]byte, error) { +func Marshal(val any) ([]byte, error) { return MarshalWithParams(val, "") } // MarshalWithParams allows field parameters to be specified for the // top-level element. The form of the params is the same as the field tags. -func MarshalWithParams(val interface{}, params string) ([]byte, error) { +func MarshalWithParams(val any, params string) ([]byte, error) { e, err := makeField(reflect.ValueOf(val), parseFieldParameters(params)) if err != nil { return nil, err diff --git a/src/encoding/asn1/marshal_test.go b/src/encoding/asn1/marshal_test.go index f0217ba8a5..d9c3cf48fa 100644 --- a/src/encoding/asn1/marshal_test.go +++ b/src/encoding/asn1/marshal_test.go @@ -97,7 +97,7 @@ type testSET []int var PST = time.FixedZone("PST", -8*60*60) type marshalTest struct { - in interface{} + in any out string // hex encoded } @@ -196,7 +196,7 @@ func TestMarshal(t *testing.T) { } type marshalWithParamsTest struct { - in interface{} + in any params string out string // hex encoded } @@ -222,7 +222,7 @@ func TestMarshalWithParams(t *testing.T) { } type marshalErrTest struct { - in interface{} + in any err string } @@ -276,7 +276,7 @@ func TestMarshalOID(t *testing.T) { func TestIssue11130(t *testing.T) { data := []byte("\x06\x010") // == \x06\x01\x30 == OID = 0 (the figure) - var v interface{} + var v any // v has Zero value here and Elem() would panic _, err := Unmarshal(data, &v) if err != nil { @@ -299,7 +299,7 @@ func TestIssue11130(t *testing.T) { return } - var v1 interface{} + var v1 any _, err = Unmarshal(data1, &v1) if err != nil { t.Errorf("%v", err) @@ -382,7 +382,7 @@ func BenchmarkUnmarshal(b *testing.B) { type testCase struct { in []byte - out interface{} + out any } var testData []testCase for _, test := range unmarshalTestData { diff --git a/src/encoding/base32/base32_test.go b/src/encoding/base32/base32_test.go index 8fb22b9078..dbd2b613b4 100644 --- a/src/encoding/base32/base32_test.go +++ b/src/encoding/base32/base32_test.go @@ -42,7 +42,7 @@ var bigtest = testpair{ "KR3WC4ZAMJZGS3DMNFTSYIDBNZSCA5DIMUQHG3DJORUHSIDUN53GK4Y=", } -func testEqual(t *testing.T, msg string, args ...interface{}) bool { +func testEqual(t *testing.T, msg string, args ...any) bool { t.Helper() if args[len(args)-2] != args[len(args)-1] { t.Errorf(msg, args...) diff --git a/src/encoding/base64/base64_test.go b/src/encoding/base64/base64_test.go index 51047402bd..57256a3846 100644 --- a/src/encoding/base64/base64_test.go +++ b/src/encoding/base64/base64_test.go @@ -98,7 +98,7 @@ var bigtest = testpair{ "VHdhcyBicmlsbGlnLCBhbmQgdGhlIHNsaXRoeSB0b3Zlcw==", } -func testEqual(t *testing.T, msg string, args ...interface{}) bool { +func testEqual(t *testing.T, msg string, args ...any) bool { t.Helper() if args[len(args)-2] != args[len(args)-1] { t.Errorf(msg, args...) diff --git a/src/encoding/binary/binary.go b/src/encoding/binary/binary.go index 52417a7933..ee933461ee 100644 --- a/src/encoding/binary/binary.go +++ b/src/encoding/binary/binary.go @@ -159,7 +159,7 @@ func (bigEndian) GoString() string { return "binary.BigEndian" } // The error is EOF only if no bytes were read. // If an EOF happens after reading some but not all the bytes, // Read returns ErrUnexpectedEOF. -func Read(r io.Reader, order ByteOrder, data interface{}) error { +func Read(r io.Reader, order ByteOrder, data any) error { // Fast path for basic types and slices. if n := intDataSize(data); n != 0 { bs := make([]byte, n) @@ -268,7 +268,7 @@ func Read(r io.Reader, order ByteOrder, data interface{}) error { // and read from successive fields of the data. // When writing structs, zero values are written for fields // with blank (_) field names. -func Write(w io.Writer, order ByteOrder, data interface{}) error { +func Write(w io.Writer, order ByteOrder, data any) error { // Fast path for basic types and slices. if n := intDataSize(data); n != 0 { bs := make([]byte, n) @@ -392,7 +392,7 @@ func Write(w io.Writer, order ByteOrder, data interface{}) error { // Size returns how many bytes Write would generate to encode the value v, which // must be a fixed-size value or a slice of fixed-size values, or a pointer to such data. // If v is neither of these, Size returns -1. -func Size(v interface{}) int { +func Size(v any) int { return dataSize(reflect.Indirect(reflect.ValueOf(v))) } @@ -696,7 +696,7 @@ func (e *encoder) skip(v reflect.Value) { // intDataSize returns the size of the data required to represent the data when encoded. // It returns zero if the type cannot be implemented by the fast path in Read or Write. -func intDataSize(data interface{}) int { +func intDataSize(data any) int { switch data := data.(type) { case bool, int8, uint8, *bool, *int8, *uint8: return 1 diff --git a/src/encoding/binary/binary_test.go b/src/encoding/binary/binary_test.go index 83af89e8a7..9e1b5f12db 100644 --- a/src/encoding/binary/binary_test.go +++ b/src/encoding/binary/binary_test.go @@ -113,7 +113,7 @@ var src = []byte{1, 2, 3, 4, 5, 6, 7, 8} var res = []int32{0x01020304, 0x05060708} var putbuf = []byte{0, 0, 0, 0, 0, 0, 0, 0} -func checkResult(t *testing.T, dir string, order ByteOrder, err error, have, want interface{}) { +func checkResult(t *testing.T, dir string, order ByteOrder, err error, have, want any) { if err != nil { t.Errorf("%v %v: %v", dir, order, err) return @@ -123,13 +123,13 @@ func checkResult(t *testing.T, dir string, order ByteOrder, err error, have, wan } } -func testRead(t *testing.T, order ByteOrder, b []byte, s1 interface{}) { +func testRead(t *testing.T, order ByteOrder, b []byte, s1 any) { var s2 Struct err := Read(bytes.NewReader(b), order, &s2) checkResult(t, "Read", order, err, s2, s1) } -func testWrite(t *testing.T, order ByteOrder, b []byte, s1 interface{}) { +func testWrite(t *testing.T, order ByteOrder, b []byte, s1 any) { buf := new(bytes.Buffer) err := Write(buf, order, s1) checkResult(t, "Write", order, err, buf.Bytes(), b) @@ -175,7 +175,7 @@ func TestReadBoolSlice(t *testing.T) { } // Addresses of arrays are easier to manipulate with reflection than are slices. -var intArrays = []interface{}{ +var intArrays = []any{ &[100]int8{}, &[100]int16{}, &[100]int32{}, @@ -304,7 +304,7 @@ func TestSizeStructCache(t *testing.T) { count := func() int { var i int - structSize.Range(func(_, _ interface{}) bool { + structSize.Range(func(_, _ any) bool { i++ return true }) @@ -329,7 +329,7 @@ func TestSizeStructCache(t *testing.T) { } testcases := []struct { - val interface{} + val any want int }{ {new(foo), 1}, @@ -376,7 +376,7 @@ func TestUnexportedRead(t *testing.T) { func TestReadErrorMsg(t *testing.T) { var buf bytes.Buffer - read := func(data interface{}) { + read := func(data any) { err := Read(&buf, LittleEndian, data) want := "binary.Read: invalid type " + reflect.TypeOf(data).String() if err == nil { @@ -457,7 +457,7 @@ func TestReadInvalidDestination(t *testing.T) { } func testReadInvalidDestination(t *testing.T, order ByteOrder) { - destinations := []interface{}{ + destinations := []any{ int8(0), int16(0), int32(0), diff --git a/src/encoding/binary/example_test.go b/src/encoding/binary/example_test.go index b994b897ce..4c10daaf68 100644 --- a/src/encoding/binary/example_test.go +++ b/src/encoding/binary/example_test.go @@ -24,7 +24,7 @@ func ExampleWrite() { func ExampleWrite_multi() { buf := new(bytes.Buffer) - var data = []interface{}{ + var data = []any{ uint16(61374), int8(-54), uint8(254), diff --git a/src/encoding/gob/codec_test.go b/src/encoding/gob/codec_test.go index f38e88b638..1ca9d878ee 100644 --- a/src/encoding/gob/codec_test.go +++ b/src/encoding/gob/codec_test.go @@ -1178,13 +1178,13 @@ func TestInterface(t *testing.T) { // A struct with all basic types, stored in interfaces. type BasicInterfaceItem struct { - Int, Int8, Int16, Int32, Int64 interface{} - Uint, Uint8, Uint16, Uint32, Uint64 interface{} - Float32, Float64 interface{} - Complex64, Complex128 interface{} - Bool interface{} - String interface{} - Bytes interface{} + Int, Int8, Int16, Int32, Int64 any + Uint, Uint8, Uint16, Uint32, Uint64 any + Float32, Float64 any + Complex64, Complex128 any + Bool any + String any + Bytes any } func TestInterfaceBasic(t *testing.T) { @@ -1223,8 +1223,8 @@ func TestInterfaceBasic(t *testing.T) { type String string type PtrInterfaceItem struct { - Str1 interface{} // basic - Str2 interface{} // derived + Str1 any // basic + Str2 any // derived } // We'll send pointers; should receive values. @@ -1318,7 +1318,7 @@ func TestUnexportedFields(t *testing.T) { } } -var singletons = []interface{}{ +var singletons = []any{ true, 7, uint(10), @@ -1354,9 +1354,9 @@ type DT struct { A int B string C float64 - I interface{} - J interface{} - I_nil interface{} + I any + J any + I_nil any M map[string]int T [3]int S []string @@ -1396,7 +1396,7 @@ func TestDebugStruct(t *testing.T) { debugFunc(debugBuffer) } -func encFuzzDec(rng *rand.Rand, in interface{}) error { +func encFuzzDec(rng *rand.Rand, in any) error { buf := new(bytes.Buffer) enc := NewEncoder(buf) if err := enc.Encode(&in); err != nil { @@ -1411,7 +1411,7 @@ func encFuzzDec(rng *rand.Rand, in interface{}) error { } dec := NewDecoder(buf) - var e interface{} + var e any if err := dec.Decode(&e); err != nil { return err } @@ -1425,7 +1425,7 @@ func TestFuzz(t *testing.T) { } // all possible inputs - input := []interface{}{ + input := []any{ new(int), new(float32), new(float64), @@ -1450,7 +1450,7 @@ func TestFuzzRegressions(t *testing.T) { testFuzz(t, 1330522872628565000, 100, new(int)) } -func testFuzz(t *testing.T, seed int64, n int, input ...interface{}) { +func testFuzz(t *testing.T, seed int64, n int, input ...any) { for _, e := range input { t.Logf("seed=%d n=%d e=%T", seed, n, e) rng := rand.New(rand.NewSource(seed)) diff --git a/src/encoding/gob/debug.go b/src/encoding/gob/debug.go index 5ceb2bfac7..b6d5a3e95c 100644 --- a/src/encoding/gob/debug.go +++ b/src/encoding/gob/debug.go @@ -118,7 +118,7 @@ type debugger struct { // dump prints the next nBytes of the input. // It arranges to print the output aligned from call to // call, to make it easy to see what has been consumed. -func (deb *debugger) dump(format string, args ...interface{}) { +func (deb *debugger) dump(format string, args ...any) { if !dumpBytes { return } diff --git a/src/encoding/gob/decoder.go b/src/encoding/gob/decoder.go index 96e215eb8c..86f54b4193 100644 --- a/src/encoding/gob/decoder.go +++ b/src/encoding/gob/decoder.go @@ -186,7 +186,7 @@ func (dec *Decoder) decodeTypeSequence(isInterface bool) typeId { // correct type for the next data item received. // If the input is at EOF, Decode returns io.EOF and // does not modify e. -func (dec *Decoder) Decode(e interface{}) error { +func (dec *Decoder) Decode(e any) error { if e == nil { return dec.DecodeValue(reflect.Value{}) } diff --git a/src/encoding/gob/encode.go b/src/encoding/gob/encode.go index e49b452f6c..548d614f52 100644 --- a/src/encoding/gob/encode.go +++ b/src/encoding/gob/encode.go @@ -40,7 +40,7 @@ type encBuffer struct { } var encBufferPool = sync.Pool{ - New: func() interface{} { + New: func() any { e := new(encBuffer) e.data = e.scratch[0:0] return e diff --git a/src/encoding/gob/encoder.go b/src/encoding/gob/encoder.go index 32865a7ede..5a80e6c3e8 100644 --- a/src/encoding/gob/encoder.go +++ b/src/encoding/gob/encoder.go @@ -172,7 +172,7 @@ func (enc *Encoder) sendType(w io.Writer, state *encoderState, origt reflect.Typ // Encode transmits the data item represented by the empty interface value, // guaranteeing that all necessary type information has been transmitted first. // Passing a nil pointer to Encoder will panic, as they cannot be transmitted by gob. -func (enc *Encoder) Encode(e interface{}) error { +func (enc *Encoder) Encode(e any) error { return enc.EncodeValue(reflect.ValueOf(e)) } diff --git a/src/encoding/gob/encoder_test.go b/src/encoding/gob/encoder_test.go index a358d5bc30..6934841b3a 100644 --- a/src/encoding/gob/encoder_test.go +++ b/src/encoding/gob/encoder_test.go @@ -18,7 +18,7 @@ import ( // Test basic operations in a safe manner. func TestBasicEncoderDecoder(t *testing.T) { - var values = []interface{}{ + var values = []any{ true, int(123), int8(123), @@ -228,7 +228,7 @@ func TestEncoderDecoder(t *testing.T) { // Run one value through the encoder/decoder, but use the wrong type. // Input is always an ET1; we compare it to whatever is under 'e'. -func badTypeCheck(e interface{}, shouldFail bool, msg string, t *testing.T) { +func badTypeCheck(e any, shouldFail bool, msg string, t *testing.T) { b := new(bytes.Buffer) enc := NewEncoder(b) et1 := new(ET1) @@ -256,7 +256,7 @@ func TestWrongTypeDecoder(t *testing.T) { } // Types not supported at top level by the Encoder. -var unsupportedValues = []interface{}{ +var unsupportedValues = []any{ make(chan int), func(a int) bool { return true }, } @@ -272,7 +272,7 @@ func TestUnsupported(t *testing.T) { } } -func encAndDec(in, out interface{}) error { +func encAndDec(in, out any) error { b := new(bytes.Buffer) enc := NewEncoder(b) err := enc.Encode(in) @@ -418,8 +418,8 @@ var testMap map[string]int var testArray [7]int type SingleTest struct { - in interface{} - out interface{} + in any + out any err string } @@ -536,7 +536,7 @@ func TestInterfaceIndirect(t *testing.T) { // encoder and decoder don't skew with respect to type definitions. type Struct0 struct { - I interface{} + I any } type NewType0 struct { @@ -544,7 +544,7 @@ type NewType0 struct { } type ignoreTest struct { - in, out interface{} + in, out any } var ignoreTests = []ignoreTest{ @@ -559,7 +559,7 @@ var ignoreTests = []ignoreTest{ // Decode struct containing an interface into a nil. {&Struct0{&NewType0{"value0"}}, nil}, // Decode singleton slice of interfaces into a nil. - {[]interface{}{"hi", &NewType0{"value1"}, 23}, nil}, + {[]any{"hi", &NewType0{"value1"}, 23}, nil}, } func TestDecodeIntoNothing(t *testing.T) { @@ -621,7 +621,7 @@ func TestIgnoreRecursiveType(t *testing.T) { // Another bug from golang-nuts, involving nested interfaces. type Bug0Outer struct { - Bug0Field interface{} + Bug0Field any } type Bug0Inner struct { @@ -635,7 +635,7 @@ func TestNestedInterfaces(t *testing.T) { Register(new(Bug0Outer)) Register(new(Bug0Inner)) f := &Bug0Outer{&Bug0Outer{&Bug0Inner{7}}} - var v interface{} = f + var v any = f err := e.Encode(&v) if err != nil { t.Fatal("Encode:", err) @@ -694,7 +694,7 @@ func TestMapBug1(t *testing.T) { } func TestGobMapInterfaceEncode(t *testing.T) { - m := map[string]interface{}{ + m := map[string]any{ "up": uintptr(0), "i0": []int{-1}, "i1": []int8{-1}, @@ -876,10 +876,10 @@ func TestGobPtrSlices(t *testing.T) { // getDecEnginePtr cached engine for ut.base instead of ut.user so we passed // a *map and then tried to reuse its engine to decode the inner map. func TestPtrToMapOfMap(t *testing.T) { - Register(make(map[string]interface{})) - subdata := make(map[string]interface{}) + Register(make(map[string]any)) + subdata := make(map[string]any) subdata["bar"] = "baz" - data := make(map[string]interface{}) + data := make(map[string]any) data["foo"] = subdata b := new(bytes.Buffer) @@ -887,7 +887,7 @@ func TestPtrToMapOfMap(t *testing.T) { if err != nil { t.Fatal("encode:", err) } - var newData map[string]interface{} + var newData map[string]any err = NewDecoder(b).Decode(&newData) if err != nil { t.Fatal("decode:", err) @@ -927,7 +927,7 @@ func TestTopLevelNilPointer(t *testing.T) { } } -func encodeAndRecover(value interface{}) (encodeErr, panicErr error) { +func encodeAndRecover(value any) (encodeErr, panicErr error) { defer func() { e := recover() if e != nil { @@ -959,7 +959,7 @@ func TestNilPointerPanics(t *testing.T) { ) testCases := []struct { - value interface{} + value any mustPanic bool }{ {nilStringPtr, true}, @@ -991,7 +991,7 @@ func TestNilPointerPanics(t *testing.T) { func TestNilPointerInsideInterface(t *testing.T) { var ip *int si := struct { - I interface{} + I any }{ I: ip, } @@ -1049,7 +1049,7 @@ type Z struct { func Test29ElementSlice(t *testing.T) { Register(Z{}) - src := make([]interface{}, 100) // Size needs to be bigger than size of type definition. + src := make([]any, 100) // Size needs to be bigger than size of type definition. for i := range src { src[i] = Z{} } @@ -1060,7 +1060,7 @@ func Test29ElementSlice(t *testing.T) { return } - var dst []interface{} + var dst []any err = NewDecoder(buf).Decode(&dst) if err != nil { t.Errorf("decode: %v", err) @@ -1091,9 +1091,9 @@ func TestErrorForHugeSlice(t *testing.T) { } type badDataTest struct { - input string // The input encoded as a hex string. - error string // A substring of the error that should result. - data interface{} // What to decode into. + input string // The input encoded as a hex string. + error string // A substring of the error that should result. + data any // What to decode into. } var badDataTests = []badDataTest{ diff --git a/src/encoding/gob/error.go b/src/encoding/gob/error.go index 949333bc03..3c9515b5ed 100644 --- a/src/encoding/gob/error.go +++ b/src/encoding/gob/error.go @@ -20,7 +20,7 @@ type gobError struct { // errorf is like error_ but takes Printf-style arguments to construct an error. // It always prefixes the message with "gob: ". -func errorf(format string, args ...interface{}) { +func errorf(format string, args ...any) { error_(fmt.Errorf("gob: "+format, args...)) } diff --git a/src/encoding/gob/gobencdec_test.go b/src/encoding/gob/gobencdec_test.go index 6d2c8db42d..1d5dde22a4 100644 --- a/src/encoding/gob/gobencdec_test.go +++ b/src/encoding/gob/gobencdec_test.go @@ -734,7 +734,7 @@ func (a *isZeroBugArray) GobDecode(data []byte) error { } type isZeroBugInterface struct { - I interface{} + I any } func (i isZeroBugInterface) GobEncode() (b []byte, e error) { diff --git a/src/encoding/gob/timing_test.go b/src/encoding/gob/timing_test.go index 516aeea92c..bdee39c447 100644 --- a/src/encoding/gob/timing_test.go +++ b/src/encoding/gob/timing_test.go @@ -20,7 +20,7 @@ type Bench struct { D []byte } -func benchmarkEndToEnd(b *testing.B, ctor func() interface{}, pipe func() (r io.Reader, w io.Writer, err error)) { +func benchmarkEndToEnd(b *testing.B, ctor func() any, pipe func() (r io.Reader, w io.Writer, err error)) { b.RunParallel(func(pb *testing.PB) { r, w, err := pipe() if err != nil { @@ -41,7 +41,7 @@ func benchmarkEndToEnd(b *testing.B, ctor func() interface{}, pipe func() (r io. } func BenchmarkEndToEndPipe(b *testing.B) { - benchmarkEndToEnd(b, func() interface{} { + benchmarkEndToEnd(b, func() any { return &Bench{7, 3.2, "now is the time", bytes.Repeat([]byte("for all good men"), 100)} }, func() (r io.Reader, w io.Writer, err error) { r, w, err = os.Pipe() @@ -50,7 +50,7 @@ func BenchmarkEndToEndPipe(b *testing.B) { } func BenchmarkEndToEndByteBuffer(b *testing.B) { - benchmarkEndToEnd(b, func() interface{} { + benchmarkEndToEnd(b, func() any { return &Bench{7, 3.2, "now is the time", bytes.Repeat([]byte("for all good men"), 100)} }, func() (r io.Reader, w io.Writer, err error) { var buf bytes.Buffer @@ -59,10 +59,10 @@ func BenchmarkEndToEndByteBuffer(b *testing.B) { } func BenchmarkEndToEndSliceByteBuffer(b *testing.B) { - benchmarkEndToEnd(b, func() interface{} { + benchmarkEndToEnd(b, func() any { v := &Bench{7, 3.2, "now is the time", nil} Register(v) - arr := make([]interface{}, 100) + arr := make([]any, 100) for i := range arr { arr[i] = v } @@ -133,7 +133,7 @@ func TestCountDecodeMallocs(t *testing.T) { } } -func benchmarkEncodeSlice(b *testing.B, a interface{}) { +func benchmarkEncodeSlice(b *testing.B, a any) { b.ResetTimer() b.RunParallel(func(pb *testing.PB) { var buf bytes.Buffer @@ -182,7 +182,7 @@ func BenchmarkEncodeStringSlice(b *testing.B) { } func BenchmarkEncodeInterfaceSlice(b *testing.B) { - a := make([]interface{}, 1000) + a := make([]any, 1000) for i := range a { a[i] = "now is the time" } @@ -217,7 +217,7 @@ func (b *benchmarkBuf) reset() { b.offset = 0 } -func benchmarkDecodeSlice(b *testing.B, a interface{}) { +func benchmarkDecodeSlice(b *testing.B, a any) { var buf bytes.Buffer enc := NewEncoder(&buf) err := enc.Encode(a) @@ -295,7 +295,7 @@ func BenchmarkDecodeBytesSlice(b *testing.B) { } func BenchmarkDecodeInterfaceSlice(b *testing.B) { - a := make([]interface{}, 1000) + a := make([]any, 1000) for i := range a { a[i] = "now is the time" } diff --git a/src/encoding/gob/type.go b/src/encoding/gob/type.go index 412a348137..6e2c724232 100644 --- a/src/encoding/gob/type.go +++ b/src/encoding/gob/type.go @@ -244,7 +244,7 @@ var ( tBytes = bootstrapType("bytes", (*[]byte)(nil), 5) tString = bootstrapType("string", (*string)(nil), 6) tComplex = bootstrapType("complex", (*complex128)(nil), 7) - tInterface = bootstrapType("interface", (*interface{})(nil), 8) + tInterface = bootstrapType("interface", (*any)(nil), 8) // Reserve some Ids for compatible expansion tReserved7 = bootstrapType("_reserved1", (*struct{ r7 int })(nil), 9) tReserved6 = bootstrapType("_reserved1", (*struct{ r6 int })(nil), 10) @@ -611,7 +611,7 @@ func checkId(want, got typeId) { // used for building the basic types; called only from init(). the incoming // interface always refers to a pointer. -func bootstrapType(name string, e interface{}, expect typeId) typeId { +func bootstrapType(name string, e any, expect typeId) typeId { rt := reflect.TypeOf(e).Elem() _, present := types[rt] if present { @@ -804,7 +804,7 @@ var ( // RegisterName is like Register but uses the provided name rather than the // type's default. -func RegisterName(name string, value interface{}) { +func RegisterName(name string, value any) { if name == "" { // reserved for nil panic("attempt to register empty name") @@ -833,7 +833,7 @@ func RegisterName(name string, value interface{}) { // transferred as implementations of interface values need to be registered. // Expecting to be used only during initialization, it panics if the mapping // between types and names is not a bijection. -func Register(value interface{}) { +func Register(value any) { // Default to printed representation for unnamed types rt := reflect.TypeOf(value) name := rt.String() diff --git a/src/encoding/gob/type_test.go b/src/encoding/gob/type_test.go index fa3e802d4e..f5f8db8bcb 100644 --- a/src/encoding/gob/type_test.go +++ b/src/encoding/gob/type_test.go @@ -168,7 +168,7 @@ type N2 struct{} // See comment in type.go/Register. func TestRegistrationNaming(t *testing.T) { testCases := []struct { - t interface{} + t any name string }{ {&N1{}, "*gob.N1"}, @@ -231,7 +231,7 @@ func TestTypeRace(t *testing.T) { var buf bytes.Buffer enc := NewEncoder(&buf) dec := NewDecoder(&buf) - var x interface{} + var x any switch i { case 0: x = &N1{} diff --git a/src/encoding/json/bench_test.go b/src/encoding/json/bench_test.go index 73c7b09fb6..95609140b0 100644 --- a/src/encoding/json/bench_test.go +++ b/src/encoding/json/bench_test.go @@ -192,7 +192,7 @@ func BenchmarkDecoderStream(b *testing.B) { var buf bytes.Buffer dec := NewDecoder(&buf) buf.WriteString(`"` + strings.Repeat("x", 1000000) + `"` + "\n\n\n") - var x interface{} + var x any if err := dec.Decode(&x); err != nil { b.Fatal("Decode:", err) } diff --git a/src/encoding/json/decode.go b/src/encoding/json/decode.go index df4c5e1a16..555df0b7e8 100644 --- a/src/encoding/json/decode.go +++ b/src/encoding/json/decode.go @@ -93,7 +93,7 @@ import ( // Instead, they are replaced by the Unicode replacement // character U+FFFD. // -func Unmarshal(data []byte, v interface{}) error { +func Unmarshal(data []byte, v any) error { // Check for well-formedness. // Avoids filling out half a data structure // before discovering a JSON syntax error. @@ -167,7 +167,7 @@ func (e *InvalidUnmarshalError) Error() string { return "json: Unmarshal(nil " + e.Type.String() + ")" } -func (d *decodeState) unmarshal(v interface{}) error { +func (d *decodeState) unmarshal(v any) error { rv := reflect.ValueOf(v) if rv.Kind() != reflect.Pointer || rv.IsNil() { return &InvalidUnmarshalError{reflect.TypeOf(v)} @@ -398,7 +398,7 @@ type unquotedValue struct{} // quoted string literal or literal null into an interface value. // If it finds anything other than a quoted string literal or null, // valueQuoted returns unquotedValue{}. -func (d *decodeState) valueQuoted() interface{} { +func (d *decodeState) valueQuoted() any { switch d.opcode { default: panic(phasePanicMsg) @@ -840,7 +840,7 @@ func (d *decodeState) object(v reflect.Value) error { // convertNumber converts the number literal s to a float64 or a Number // depending on the setting of d.useNumber. -func (d *decodeState) convertNumber(s string) (interface{}, error) { +func (d *decodeState) convertNumber(s string) (any, error) { if d.useNumber { return Number(s), nil } @@ -1037,7 +1037,7 @@ func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool // but they avoid the weight of reflection in this common case. // valueInterface is like value but returns interface{} -func (d *decodeState) valueInterface() (val interface{}) { +func (d *decodeState) valueInterface() (val any) { switch d.opcode { default: panic(phasePanicMsg) @@ -1054,8 +1054,8 @@ func (d *decodeState) valueInterface() (val interface{}) { } // arrayInterface is like array but returns []interface{}. -func (d *decodeState) arrayInterface() []interface{} { - var v = make([]interface{}, 0) +func (d *decodeState) arrayInterface() []any { + var v = make([]any, 0) for { // Look ahead for ] - can only happen on first iteration. d.scanWhile(scanSkipSpace) @@ -1080,8 +1080,8 @@ func (d *decodeState) arrayInterface() []interface{} { } // objectInterface is like object but returns map[string]interface{}. -func (d *decodeState) objectInterface() map[string]interface{} { - m := make(map[string]interface{}) +func (d *decodeState) objectInterface() map[string]any { + m := make(map[string]any) for { // Read opening " of string key or closing }. d.scanWhile(scanSkipSpace) @@ -1131,7 +1131,7 @@ func (d *decodeState) objectInterface() map[string]interface{} { // literalInterface consumes and returns a literal from d.data[d.off-1:] and // it reads the following byte ahead. The first byte of the literal has been // read already (that's how the caller knows it's a literal). -func (d *decodeState) literalInterface() interface{} { +func (d *decodeState) literalInterface() any { // All bytes inside literal return scanContinue op code. start := d.readIndex() d.rescanLiteral() diff --git a/src/encoding/json/decode_test.go b/src/encoding/json/decode_test.go index 96bf9fb5ff..c2c036b609 100644 --- a/src/encoding/json/decode_test.go +++ b/src/encoding/json/decode_test.go @@ -31,7 +31,7 @@ type U struct { } type V struct { - F1 interface{} + F1 any F2 int32 F3 Number F4 *VOuter @@ -62,18 +62,18 @@ func (*SS) UnmarshalJSON(data []byte) error { // ifaceNumAsFloat64/ifaceNumAsNumber are used to test unmarshaling with and // without UseNumber -var ifaceNumAsFloat64 = map[string]interface{}{ +var ifaceNumAsFloat64 = map[string]any{ "k1": float64(1), "k2": "s", - "k3": []interface{}{float64(1), float64(2.0), float64(3e-3)}, - "k4": map[string]interface{}{"kk1": "s", "kk2": float64(2)}, + "k3": []any{float64(1), float64(2.0), float64(3e-3)}, + "k4": map[string]any{"kk1": "s", "kk2": float64(2)}, } -var ifaceNumAsNumber = map[string]interface{}{ +var ifaceNumAsNumber = map[string]any{ "k1": Number("1"), "k2": "s", - "k3": []interface{}{Number("1"), Number("2.0"), Number("3e-3")}, - "k4": map[string]interface{}{"kk1": "s", "kk2": Number("2")}, + "k3": []any{Number("1"), Number("2.0"), Number("3e-3")}, + "k4": map[string]any{"kk1": "s", "kk2": Number("2")}, } type tx struct { @@ -262,9 +262,9 @@ type Ambig struct { } type XYZ struct { - X interface{} - Y interface{} - Z interface{} + X any + Y any + Z any } type unexportedWithMethods struct{} @@ -389,8 +389,8 @@ type mapStringToStringData struct { type unmarshalTest struct { in string - ptr interface{} // new(type) - out interface{} + ptr any // new(type) + out any err error useNumber bool golden bool @@ -414,13 +414,13 @@ var unmarshalTests = []unmarshalTest{ {in: `-5`, ptr: new(int16), out: int16(-5)}, {in: `2`, ptr: new(Number), out: Number("2"), useNumber: true}, {in: `2`, ptr: new(Number), out: Number("2")}, - {in: `2`, ptr: new(interface{}), out: float64(2.0)}, - {in: `2`, ptr: new(interface{}), out: Number("2"), useNumber: true}, + {in: `2`, ptr: new(any), out: float64(2.0)}, + {in: `2`, ptr: new(any), out: Number("2"), useNumber: true}, {in: `"a\u1234"`, ptr: new(string), out: "a\u1234"}, {in: `"http:\/\/"`, ptr: new(string), out: "http://"}, {in: `"g-clef: \uD834\uDD1E"`, ptr: new(string), out: "g-clef: \U0001D11E"}, {in: `"invalid: \uD834x\uDD1E"`, ptr: new(string), out: "invalid: \uFFFDx\uFFFD"}, - {in: "null", ptr: new(interface{}), out: nil}, + {in: "null", ptr: new(any), out: nil}, {in: `{"X": [1,2,3], "Y": 4}`, ptr: new(T), out: T{Y: 4}, err: &UnmarshalTypeError{"array", reflect.TypeOf(""), 7, "T", "X"}}, {in: `{"X": 23}`, ptr: new(T), out: T{}, err: &UnmarshalTypeError{"number", reflect.TypeOf(""), 8, "T", "X"}}, {in: `{"x": 1}`, ptr: new(tx), out: tx{}}, {in: `{"x": 1}`, ptr: new(tx), out: tx{}}, @@ -428,8 +428,8 @@ var unmarshalTests = []unmarshalTest{ {in: `{"S": 23}`, ptr: new(W), out: W{}, err: &UnmarshalTypeError{"number", reflect.TypeOf(SS("")), 0, "W", "S"}}, {in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: float64(1), F2: int32(2), F3: Number("3")}}, {in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: Number("1"), F2: int32(2), F3: Number("3")}, useNumber: true}, - {in: `{"k1":1,"k2":"s","k3":[1,2.0,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsFloat64}, - {in: `{"k1":1,"k2":"s","k3":[1,2.0,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsNumber, useNumber: true}, + {in: `{"k1":1,"k2":"s","k3":[1,2.0,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(any), out: ifaceNumAsFloat64}, + {in: `{"k1":1,"k2":"s","k3":[1,2.0,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(any), out: ifaceNumAsNumber, useNumber: true}, // raw values with whitespace {in: "\n true ", ptr: new(bool), out: true}, @@ -472,10 +472,10 @@ var unmarshalTests = []unmarshalTest{ {in: `[1, 2, 3]`, ptr: new(MustNotUnmarshalJSON), err: errors.New("MustNotUnmarshalJSON was used")}, // empty array to interface test - {in: `[]`, ptr: new([]interface{}), out: []interface{}{}}, - {in: `null`, ptr: new([]interface{}), out: []interface{}(nil)}, - {in: `{"T":[]}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": []interface{}{}}}, - {in: `{"T":null}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": interface{}(nil)}}, + {in: `[]`, ptr: new([]any), out: []any{}}, + {in: `null`, ptr: new([]any), out: []any(nil)}, + {in: `{"T":[]}`, ptr: new(map[string]any), out: map[string]any{"T": []any{}}}, + {in: `{"T":null}`, ptr: new(map[string]any), out: map[string]any{"T": any(nil)}}, // composite tests {in: allValueIndent, ptr: new(All), out: allValue}, @@ -1176,7 +1176,7 @@ func TestUnmarshal(t *testing.T) { func TestUnmarshalMarshal(t *testing.T) { initBig() - var v interface{} + var v any if err := Unmarshal(jsonBig, &v); err != nil { t.Fatalf("Unmarshal: %v", err) } @@ -1248,7 +1248,7 @@ type Xint struct { func TestUnmarshalInterface(t *testing.T) { var xint Xint - var i interface{} = &xint + var i any = &xint if err := Unmarshal([]byte(`{"X":1}`), &i); err != nil { t.Fatalf("Unmarshal: %v", err) } @@ -1382,8 +1382,8 @@ type All struct { PSmall *Small PPSmall **Small - Interface interface{} - PInterface *interface{} + Interface any + PInterface *any unexported int } @@ -1717,9 +1717,9 @@ func intpp(x *int) **int { } var interfaceSetTests = []struct { - pre interface{} + pre any json string - post interface{} + post any }{ {"foo", `"bar"`, "bar"}, {"foo", `2`, 2.0}, @@ -1738,7 +1738,7 @@ var interfaceSetTests = []struct { func TestInterfaceSet(t *testing.T) { for _, tt := range interfaceSetTests { - b := struct{ X interface{} }{tt.pre} + b := struct{ X any }{tt.pre} blob := `{"X":` + tt.json + `}` if err := Unmarshal([]byte(blob), &b); err != nil { t.Errorf("Unmarshal %#q: %v", blob, err) @@ -1768,7 +1768,7 @@ type NullTest struct { PBool *bool Map map[string]string Slice []string - Interface interface{} + Interface any PRaw *RawMessage PTime *time.Time @@ -1989,7 +1989,7 @@ func TestSliceOfCustomByte(t *testing.T) { } var decodeTypeErrorTests = []struct { - dest interface{} + dest any src string }{ {new(string), `{"user": "name"}`}, // issue 4628. @@ -2022,7 +2022,7 @@ var unmarshalSyntaxTests = []string{ } func TestUnmarshalSyntax(t *testing.T) { - var x interface{} + var x any for _, src := range unmarshalSyntaxTests { err := Unmarshal([]byte(src), &x) if _, ok := err.(*SyntaxError); !ok { @@ -2035,8 +2035,8 @@ func TestUnmarshalSyntax(t *testing.T) { // Issue 4660 type unexportedFields struct { Name string - m map[string]interface{} `json:"-"` - m2 map[string]interface{} `json:"abcd"` + m map[string]any `json:"-"` + m2 map[string]any `json:"abcd"` s []int `json:"-"` } @@ -2087,7 +2087,7 @@ func TestUnmarshalJSONLiteralError(t *testing.T) { // Issue 3717 func TestSkipArrayObjects(t *testing.T) { json := `[{}]` - var dest [0]interface{} + var dest [0]any err := Unmarshal([]byte(json), &dest) if err != nil { @@ -2102,8 +2102,8 @@ func TestPrefilled(t *testing.T) { // Values here change, cannot reuse table across runs. var prefillTests = []struct { in string - ptr interface{} - out interface{} + ptr any + out any }{ { in: `{"X": 1, "Y": 2}`, @@ -2112,8 +2112,8 @@ func TestPrefilled(t *testing.T) { }, { in: `{"X": 1, "Y": 2}`, - ptr: &map[string]interface{}{"X": float32(3), "Y": int16(4), "Z": 1.5}, - out: &map[string]interface{}{"X": float64(1), "Y": float64(2), "Z": 1.5}, + ptr: &map[string]any{"X": float32(3), "Y": int16(4), "Z": 1.5}, + out: &map[string]any{"X": float64(1), "Y": float64(2), "Z": 1.5}, }, { in: `[2]`, @@ -2150,7 +2150,7 @@ func TestPrefilled(t *testing.T) { } var invalidUnmarshalTests = []struct { - v interface{} + v any want string }{ {nil, "json: Unmarshal(nil)"}, @@ -2173,7 +2173,7 @@ func TestInvalidUnmarshal(t *testing.T) { } var invalidUnmarshalTextTests = []struct { - v interface{} + v any want string }{ {nil, "json: Unmarshal(nil)"}, @@ -2205,7 +2205,7 @@ func TestInvalidStringOption(t *testing.T) { M map[string]string `json:",string"` S []string `json:",string"` A [1]string `json:",string"` - I interface{} `json:",string"` + I any `json:",string"` P *int `json:",string"` }{M: make(map[string]string), S: make([]string, 0), I: num, P: &num} @@ -2276,8 +2276,8 @@ func TestUnmarshalEmbeddedUnexported(t *testing.T) { tests := []struct { in string - ptr interface{} - out interface{} + ptr any + out any err error }{{ // Error since we cannot set S1.embed1, but still able to set S1.R. @@ -2375,7 +2375,7 @@ func TestUnmarshalErrorAfterMultipleJSON(t *testing.T) { dec := NewDecoder(strings.NewReader(tt.in)) var err error for { - var v interface{} + var v any if err = dec.Decode(&v); err != nil { break } @@ -2403,7 +2403,7 @@ func TestUnmarshalPanic(t *testing.T) { // The decoder used to hang if decoding into an interface pointing to its own address. // See golang.org/issues/31740. func TestUnmarshalRecursivePointer(t *testing.T) { - var v interface{} + var v any v = &v data := []byte(`{"a": "b"}`) @@ -2517,36 +2517,36 @@ func TestUnmarshalMaxDepth(t *testing.T) { targets := []struct { name string - newValue func() interface{} + newValue func() any }{ { name: "unstructured", - newValue: func() interface{} { - var v interface{} + newValue: func() any { + var v any return &v }, }, { name: "typed named field", - newValue: func() interface{} { + newValue: func() any { v := struct { - A interface{} `json:"a"` + A any `json:"a"` }{} return &v }, }, { name: "typed missing field", - newValue: func() interface{} { + newValue: func() any { v := struct { - B interface{} `json:"b"` + B any `json:"b"` }{} return &v }, }, { name: "custom unmarshaler", - newValue: func() interface{} { + newValue: func() any { v := unmarshaler{} return &v }, diff --git a/src/encoding/json/encode.go b/src/encoding/json/encode.go index 4f40197797..1f5e3e446a 100644 --- a/src/encoding/json/encode.go +++ b/src/encoding/json/encode.go @@ -155,7 +155,7 @@ import ( // handle them. Passing cyclic structures to Marshal will result in // an error. // -func Marshal(v interface{}) ([]byte, error) { +func Marshal(v any) ([]byte, error) { e := newEncodeState() err := e.marshal(v, encOpts{escapeHTML: true}) @@ -172,7 +172,7 @@ func Marshal(v interface{}) ([]byte, error) { // MarshalIndent is like Marshal but applies Indent to format the output. // Each JSON element in the output will begin on a new line beginning with prefix // followed by one or more copies of indent according to the indentation nesting. -func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) { +func MarshalIndent(v any, prefix, indent string) ([]byte, error) { b, err := Marshal(v) if err != nil { return nil, err @@ -294,7 +294,7 @@ type encodeState struct { // startDetectingCyclesAfter, so that we skip the work if we're within a // reasonable amount of nested pointers deep. ptrLevel uint - ptrSeen map[interface{}]struct{} + ptrSeen map[any]struct{} } const startDetectingCyclesAfter = 1000 @@ -311,7 +311,7 @@ func newEncodeState() *encodeState { e.ptrLevel = 0 return e } - return &encodeState{ptrSeen: make(map[interface{}]struct{})} + return &encodeState{ptrSeen: make(map[any]struct{})} } // jsonError is an error wrapper type for internal use only. @@ -319,7 +319,7 @@ func newEncodeState() *encodeState { // can distinguish intentional panics from this package. type jsonError struct{ error } -func (e *encodeState) marshal(v interface{}, opts encOpts) (err error) { +func (e *encodeState) marshal(v any, opts encOpts) (err error) { defer func() { if r := recover(); r != nil { if je, ok := r.(jsonError); ok { diff --git a/src/encoding/json/encode_test.go b/src/encoding/json/encode_test.go index 0dad951095..0b021f0074 100644 --- a/src/encoding/json/encode_test.go +++ b/src/encoding/json/encode_test.go @@ -28,8 +28,8 @@ type Optionals struct { Slr []string `json:"slr,random"` Slo []string `json:"slo,omitempty"` - Mr map[string]interface{} `json:"mr"` - Mo map[string]interface{} `json:",omitempty"` + Mr map[string]any `json:"mr"` + Mo map[string]any `json:",omitempty"` Fr float64 `json:"fr"` Fo float64 `json:"fo,omitempty"` @@ -59,8 +59,8 @@ var optionalsExpected = `{ func TestOmitEmpty(t *testing.T) { var o Optionals o.Sw = "something" - o.Mr = map[string]interface{}{} - o.Mo = map[string]interface{}{} + o.Mr = map[string]any{} + o.Mo = map[string]any{} got, err := MarshalIndent(&o, "", " ") if err != nil { @@ -180,16 +180,16 @@ type PointerCycle struct { var pointerCycle = &PointerCycle{} type PointerCycleIndirect struct { - Ptrs []interface{} + Ptrs []any } type RecursiveSlice []RecursiveSlice var ( pointerCycleIndirect = &PointerCycleIndirect{} - mapCycle = make(map[string]interface{}) - sliceCycle = []interface{}{nil} - sliceNoCycle = []interface{}{nil, nil} + mapCycle = make(map[string]any) + sliceCycle = []any{nil} + sliceNoCycle = []any{nil, nil} recursiveSliceCycle = []RecursiveSlice{nil} ) @@ -199,13 +199,13 @@ func init() { samePointerNoCycle.Ptr2 = ptr pointerCycle.Ptr = pointerCycle - pointerCycleIndirect.Ptrs = []interface{}{pointerCycleIndirect} + pointerCycleIndirect.Ptrs = []any{pointerCycleIndirect} mapCycle["x"] = mapCycle sliceCycle[0] = sliceCycle sliceNoCycle[1] = sliceNoCycle[:1] for i := startDetectingCyclesAfter; i > 0; i-- { - sliceNoCycle = []interface{}{sliceNoCycle} + sliceNoCycle = []any{sliceNoCycle} } recursiveSliceCycle[0] = recursiveSliceCycle } @@ -222,7 +222,7 @@ func TestSliceNoCycle(t *testing.T) { } } -var unsupportedValues = []interface{}{ +var unsupportedValues = []any{ math.NaN(), math.Inf(-1), math.Inf(1), @@ -367,15 +367,15 @@ func TestMarshalerEscaping(t *testing.T) { func TestAnonymousFields(t *testing.T) { tests := []struct { - label string // Test name - makeInput func() interface{} // Function to create input value - want string // Expected JSON output + label string // Test name + makeInput func() any // Function to create input value + want string // Expected JSON output }{{ // Both S1 and S2 have a field named X. From the perspective of S, // it is ambiguous which one X refers to. // This should not serialize either field. label: "AmbiguousField", - makeInput: func() interface{} { + makeInput: func() any { type ( S1 struct{ x, X int } S2 struct{ x, X int } @@ -391,7 +391,7 @@ func TestAnonymousFields(t *testing.T) { label: "DominantField", // Both S1 and S2 have a field named X, but since S has an X field as // well, it takes precedence over S1.X and S2.X. - makeInput: func() interface{} { + makeInput: func() any { type ( S1 struct{ x, X int } S2 struct{ x, X int } @@ -407,7 +407,7 @@ func TestAnonymousFields(t *testing.T) { }, { // Unexported embedded field of non-struct type should not be serialized. label: "UnexportedEmbeddedInt", - makeInput: func() interface{} { + makeInput: func() any { type ( myInt int S struct{ myInt } @@ -418,7 +418,7 @@ func TestAnonymousFields(t *testing.T) { }, { // Exported embedded field of non-struct type should be serialized. label: "ExportedEmbeddedInt", - makeInput: func() interface{} { + makeInput: func() any { type ( MyInt int S struct{ MyInt } @@ -430,7 +430,7 @@ func TestAnonymousFields(t *testing.T) { // Unexported embedded field of pointer to non-struct type // should not be serialized. label: "UnexportedEmbeddedIntPointer", - makeInput: func() interface{} { + makeInput: func() any { type ( myInt int S struct{ *myInt } @@ -444,7 +444,7 @@ func TestAnonymousFields(t *testing.T) { // Exported embedded field of pointer to non-struct type // should be serialized. label: "ExportedEmbeddedIntPointer", - makeInput: func() interface{} { + makeInput: func() any { type ( MyInt int S struct{ *MyInt } @@ -459,7 +459,7 @@ func TestAnonymousFields(t *testing.T) { // exported fields be serialized regardless of whether the struct types // themselves are exported. label: "EmbeddedStruct", - makeInput: func() interface{} { + makeInput: func() any { type ( s1 struct{ x, X int } S2 struct{ y, Y int } @@ -476,7 +476,7 @@ func TestAnonymousFields(t *testing.T) { // exported fields be serialized regardless of whether the struct types // themselves are exported. label: "EmbeddedStructPointer", - makeInput: func() interface{} { + makeInput: func() any { type ( s1 struct{ x, X int } S2 struct{ y, Y int } @@ -492,7 +492,7 @@ func TestAnonymousFields(t *testing.T) { // Exported fields on embedded unexported structs at multiple levels // of nesting should still be serialized. label: "NestedStructAndInts", - makeInput: func() interface{} { + makeInput: func() any { type ( MyInt1 int MyInt2 int @@ -519,7 +519,7 @@ func TestAnonymousFields(t *testing.T) { // the embedded fields behind it. Not properly doing so may // result in the wrong output or reflect panics. label: "EmbeddedFieldBehindNilPointer", - makeInput: func() interface{} { + makeInput: func() any { type ( S2 struct{ Field string } S struct{ *S2 } @@ -589,22 +589,22 @@ func (nm *nilTextMarshaler) MarshalText() ([]byte, error) { // See golang.org/issue/16042 and golang.org/issue/34235. func TestNilMarshal(t *testing.T) { testCases := []struct { - v interface{} + v any want string }{ {v: nil, want: `null`}, {v: new(float64), want: `0`}, - {v: []interface{}(nil), want: `null`}, + {v: []any(nil), want: `null`}, {v: []string(nil), want: `null`}, {v: map[string]string(nil), want: `null`}, {v: []byte(nil), want: `null`}, {v: struct{ M string }{"gopher"}, want: `{"M":"gopher"}`}, {v: struct{ M Marshaler }{}, want: `{"M":null}`}, {v: struct{ M Marshaler }{(*nilJSONMarshaler)(nil)}, want: `{"M":"0zenil0"}`}, - {v: struct{ M interface{} }{(*nilJSONMarshaler)(nil)}, want: `{"M":null}`}, + {v: struct{ M any }{(*nilJSONMarshaler)(nil)}, want: `{"M":null}`}, {v: struct{ M encoding.TextMarshaler }{}, want: `{"M":null}`}, {v: struct{ M encoding.TextMarshaler }{(*nilTextMarshaler)(nil)}, want: `{"M":"0zenil0"}`}, - {v: struct{ M interface{} }{(*nilTextMarshaler)(nil)}, want: `{"M":null}`}, + {v: struct{ M any }{(*nilTextMarshaler)(nil)}, want: `{"M":null}`}, } for _, tt := range testCases { @@ -864,7 +864,7 @@ type textint int func (i textint) MarshalText() ([]byte, error) { return tenc(`TI:%d`, i) } -func tenc(format string, a ...interface{}) ([]byte, error) { +func tenc(format string, a ...any) ([]byte, error) { var buf bytes.Buffer fmt.Fprintf(&buf, format, a...) return buf.Bytes(), nil @@ -877,7 +877,7 @@ func (f textfloat) MarshalText() ([]byte, error) { return tenc(`TF:%0.2f`, f) } // Issue 13783 func TestEncodeBytekind(t *testing.T) { testdata := []struct { - data interface{} + data any want string }{ {byte(7), "7"}, @@ -966,7 +966,7 @@ func TestMarshalFloat(t *testing.T) { t.Parallel() nfail := 0 test := func(f float64, bits int) { - vf := interface{}(f) + vf := any(f) if bits == 32 { f = float64(float32(f)) // round vf = float32(f) @@ -1062,25 +1062,25 @@ func TestMarshalRawMessageValue(t *testing.T) { ) tests := []struct { - in interface{} + in any want string ok bool }{ // Test with nil RawMessage. {rawNil, "null", true}, {&rawNil, "null", true}, - {[]interface{}{rawNil}, "[null]", true}, - {&[]interface{}{rawNil}, "[null]", true}, - {[]interface{}{&rawNil}, "[null]", true}, - {&[]interface{}{&rawNil}, "[null]", true}, + {[]any{rawNil}, "[null]", true}, + {&[]any{rawNil}, "[null]", true}, + {[]any{&rawNil}, "[null]", true}, + {&[]any{&rawNil}, "[null]", true}, {struct{ M RawMessage }{rawNil}, `{"M":null}`, true}, {&struct{ M RawMessage }{rawNil}, `{"M":null}`, true}, {struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true}, {&struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true}, - {map[string]interface{}{"M": rawNil}, `{"M":null}`, true}, - {&map[string]interface{}{"M": rawNil}, `{"M":null}`, true}, - {map[string]interface{}{"M": &rawNil}, `{"M":null}`, true}, - {&map[string]interface{}{"M": &rawNil}, `{"M":null}`, true}, + {map[string]any{"M": rawNil}, `{"M":null}`, true}, + {&map[string]any{"M": rawNil}, `{"M":null}`, true}, + {map[string]any{"M": &rawNil}, `{"M":null}`, true}, + {&map[string]any{"M": &rawNil}, `{"M":null}`, true}, {T1{rawNil}, "{}", true}, {T2{&rawNil}, `{"M":null}`, true}, {&T1{rawNil}, "{}", true}, @@ -1089,18 +1089,18 @@ func TestMarshalRawMessageValue(t *testing.T) { // Test with empty, but non-nil, RawMessage. {rawEmpty, "", false}, {&rawEmpty, "", false}, - {[]interface{}{rawEmpty}, "", false}, - {&[]interface{}{rawEmpty}, "", false}, - {[]interface{}{&rawEmpty}, "", false}, - {&[]interface{}{&rawEmpty}, "", false}, + {[]any{rawEmpty}, "", false}, + {&[]any{rawEmpty}, "", false}, + {[]any{&rawEmpty}, "", false}, + {&[]any{&rawEmpty}, "", false}, {struct{ X RawMessage }{rawEmpty}, "", false}, {&struct{ X RawMessage }{rawEmpty}, "", false}, {struct{ X *RawMessage }{&rawEmpty}, "", false}, {&struct{ X *RawMessage }{&rawEmpty}, "", false}, - {map[string]interface{}{"nil": rawEmpty}, "", false}, - {&map[string]interface{}{"nil": rawEmpty}, "", false}, - {map[string]interface{}{"nil": &rawEmpty}, "", false}, - {&map[string]interface{}{"nil": &rawEmpty}, "", false}, + {map[string]any{"nil": rawEmpty}, "", false}, + {&map[string]any{"nil": rawEmpty}, "", false}, + {map[string]any{"nil": &rawEmpty}, "", false}, + {&map[string]any{"nil": &rawEmpty}, "", false}, {T1{rawEmpty}, "{}", true}, {T2{&rawEmpty}, "", false}, {&T1{rawEmpty}, "{}", true}, @@ -1113,18 +1113,18 @@ func TestMarshalRawMessageValue(t *testing.T) { // See https://golang.org/issues/14493#issuecomment-255857318 {rawText, `"foo"`, true}, // Issue6458 {&rawText, `"foo"`, true}, - {[]interface{}{rawText}, `["foo"]`, true}, // Issue6458 - {&[]interface{}{rawText}, `["foo"]`, true}, // Issue6458 - {[]interface{}{&rawText}, `["foo"]`, true}, - {&[]interface{}{&rawText}, `["foo"]`, true}, + {[]any{rawText}, `["foo"]`, true}, // Issue6458 + {&[]any{rawText}, `["foo"]`, true}, // Issue6458 + {[]any{&rawText}, `["foo"]`, true}, + {&[]any{&rawText}, `["foo"]`, true}, {struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true}, // Issue6458 {&struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true}, {struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true}, {&struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true}, - {map[string]interface{}{"M": rawText}, `{"M":"foo"}`, true}, // Issue6458 - {&map[string]interface{}{"M": rawText}, `{"M":"foo"}`, true}, // Issue6458 - {map[string]interface{}{"M": &rawText}, `{"M":"foo"}`, true}, - {&map[string]interface{}{"M": &rawText}, `{"M":"foo"}`, true}, + {map[string]any{"M": rawText}, `{"M":"foo"}`, true}, // Issue6458 + {&map[string]any{"M": rawText}, `{"M":"foo"}`, true}, // Issue6458 + {map[string]any{"M": &rawText}, `{"M":"foo"}`, true}, + {&map[string]any{"M": &rawText}, `{"M":"foo"}`, true}, {T1{rawText}, `{"M":"foo"}`, true}, // Issue6458 {T2{&rawText}, `{"M":"foo"}`, true}, {&T1{rawText}, `{"M":"foo"}`, true}, diff --git a/src/encoding/json/example_test.go b/src/encoding/json/example_test.go index fbecf1b593..2261c770c0 100644 --- a/src/encoding/json/example_test.go +++ b/src/encoding/json/example_test.go @@ -200,7 +200,7 @@ func ExampleRawMessage_unmarshal() { } for _, c := range colors { - var dst interface{} + var dst any switch c.Space { case "RGB": dst = new(RGB) diff --git a/src/encoding/json/fuzz.go b/src/encoding/json/fuzz.go index f00898a798..b8f4ff2c1d 100644 --- a/src/encoding/json/fuzz.go +++ b/src/encoding/json/fuzz.go @@ -11,10 +11,10 @@ import ( ) func Fuzz(data []byte) (score int) { - for _, ctor := range []func() interface{}{ - func() interface{} { return new(interface{}) }, - func() interface{} { return new(map[string]interface{}) }, - func() interface{} { return new([]interface{}) }, + for _, ctor := range []func() any{ + func() any { return new(any) }, + func() any { return new(map[string]any) }, + func() any { return new([]any) }, } { v := ctor() err := Unmarshal(data, v) diff --git a/src/encoding/json/scanner.go b/src/encoding/json/scanner.go index 9dc1903e2d..dbaa821bec 100644 --- a/src/encoding/json/scanner.go +++ b/src/encoding/json/scanner.go @@ -83,7 +83,7 @@ type scanner struct { } var scannerPool = sync.Pool{ - New: func() interface{} { + New: func() any { return &scanner{} }, } diff --git a/src/encoding/json/scanner_test.go b/src/encoding/json/scanner_test.go index 3737516a45..3474b3e481 100644 --- a/src/encoding/json/scanner_test.go +++ b/src/encoding/json/scanner_test.go @@ -237,7 +237,7 @@ func initBig() { jsonBig = b } -func genValue(n int) interface{} { +func genValue(n int) any { if n > 1 { switch rand.Intn(2) { case 0: @@ -270,7 +270,7 @@ func genString(stddev float64) string { return string(c) } -func genArray(n int) []interface{} { +func genArray(n int) []any { f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2))) if f > n { f = n @@ -278,14 +278,14 @@ func genArray(n int) []interface{} { if f < 1 { f = 1 } - x := make([]interface{}, f) + x := make([]any, f) for i := range x { x[i] = genValue(((i+1)*n)/f - (i*n)/f) } return x } -func genMap(n int) map[string]interface{} { +func genMap(n int) map[string]any { f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2))) if f > n { f = n @@ -293,7 +293,7 @@ func genMap(n int) map[string]interface{} { if n > 0 && f == 0 { f = 1 } - x := make(map[string]interface{}) + x := make(map[string]any) for i := 0; i < f; i++ { x[genString(10)] = genValue(((i+1)*n)/f - (i*n)/f) } diff --git a/src/encoding/json/stream.go b/src/encoding/json/stream.go index 81f404f426..6362170d5d 100644 --- a/src/encoding/json/stream.go +++ b/src/encoding/json/stream.go @@ -46,7 +46,7 @@ func (dec *Decoder) DisallowUnknownFields() { dec.d.disallowUnknownFields = true // // See the documentation for Unmarshal for details about // the conversion of JSON into a Go value. -func (dec *Decoder) Decode(v interface{}) error { +func (dec *Decoder) Decode(v any) error { if dec.err != nil { return dec.err } @@ -198,7 +198,7 @@ func NewEncoder(w io.Writer) *Encoder { // // See the documentation for Marshal for details about the // conversion of Go values to JSON. -func (enc *Encoder) Encode(v interface{}) error { +func (enc *Encoder) Encode(v any) error { if enc.err != nil { return enc.err } @@ -288,7 +288,7 @@ var _ Unmarshaler = (*RawMessage)(nil) // string, for JSON string literals // nil, for JSON null // -type Token interface{} +type Token any const ( tokenTopValue = iota @@ -452,7 +452,7 @@ func (dec *Decoder) Token() (Token, error) { if !dec.tokenValueAllowed() { return dec.tokenError(c) } - var x interface{} + var x any if err := dec.Decode(&x); err != nil { return nil, err } diff --git a/src/encoding/json/stream_test.go b/src/encoding/json/stream_test.go index c284f2d965..0e156d98e9 100644 --- a/src/encoding/json/stream_test.go +++ b/src/encoding/json/stream_test.go @@ -18,14 +18,14 @@ import ( // Test values for the stream test. // One of each JSON kind. -var streamTest = []interface{}{ +var streamTest = []any{ 0.1, "hello", nil, true, false, - []interface{}{"a", "b", "c"}, - map[string]interface{}{"K": "Kelvin", "ß": "long s"}, + []any{"a", "b", "c"}, + map[string]any{"K": "Kelvin", "ß": "long s"}, 3.14, // another value to make sure something can follow map } @@ -124,7 +124,7 @@ func TestEncoderSetEscapeHTML(t *testing.T) { for _, tt := range []struct { name string - v interface{} + v any wantEscape string want string }{ @@ -182,7 +182,7 @@ func TestDecoder(t *testing.T) { buf.WriteRune(c) } } - out := make([]interface{}, i) + out := make([]any, i) dec := NewDecoder(&buf) for j := range out { if err := dec.Decode(&out[j]); err != nil { @@ -297,7 +297,7 @@ func TestBlocking(t *testing.T) { for _, enc := range blockingTests { r, w := net.Pipe() go w.Write([]byte(enc)) - var val interface{} + var val any // If Decode reads beyond what w.Write writes above, // it will block, and the test will deadlock. @@ -326,80 +326,80 @@ func BenchmarkEncoderEncode(b *testing.B) { type tokenStreamCase struct { json string - expTokens []interface{} + expTokens []any } type decodeThis struct { - v interface{} + v any } var tokenStreamCases = []tokenStreamCase{ // streaming token cases - {json: `10`, expTokens: []interface{}{float64(10)}}, - {json: ` [10] `, expTokens: []interface{}{ + {json: `10`, expTokens: []any{float64(10)}}, + {json: ` [10] `, expTokens: []any{ Delim('['), float64(10), Delim(']')}}, - {json: ` [false,10,"b"] `, expTokens: []interface{}{ + {json: ` [false,10,"b"] `, expTokens: []any{ Delim('['), false, float64(10), "b", Delim(']')}}, - {json: `{ "a": 1 }`, expTokens: []interface{}{ + {json: `{ "a": 1 }`, expTokens: []any{ Delim('{'), "a", float64(1), Delim('}')}}, - {json: `{"a": 1, "b":"3"}`, expTokens: []interface{}{ + {json: `{"a": 1, "b":"3"}`, expTokens: []any{ Delim('{'), "a", float64(1), "b", "3", Delim('}')}}, - {json: ` [{"a": 1},{"a": 2}] `, expTokens: []interface{}{ + {json: ` [{"a": 1},{"a": 2}] `, expTokens: []any{ Delim('['), Delim('{'), "a", float64(1), Delim('}'), Delim('{'), "a", float64(2), Delim('}'), Delim(']')}}, - {json: `{"obj": {"a": 1}}`, expTokens: []interface{}{ + {json: `{"obj": {"a": 1}}`, expTokens: []any{ Delim('{'), "obj", Delim('{'), "a", float64(1), Delim('}'), Delim('}')}}, - {json: `{"obj": [{"a": 1}]}`, expTokens: []interface{}{ + {json: `{"obj": [{"a": 1}]}`, expTokens: []any{ Delim('{'), "obj", Delim('['), Delim('{'), "a", float64(1), Delim('}'), Delim(']'), Delim('}')}}, // streaming tokens with intermittent Decode() - {json: `{ "a": 1 }`, expTokens: []interface{}{ + {json: `{ "a": 1 }`, expTokens: []any{ Delim('{'), "a", decodeThis{float64(1)}, Delim('}')}}, - {json: ` [ { "a" : 1 } ] `, expTokens: []interface{}{ + {json: ` [ { "a" : 1 } ] `, expTokens: []any{ Delim('['), - decodeThis{map[string]interface{}{"a": float64(1)}}, + decodeThis{map[string]any{"a": float64(1)}}, Delim(']')}}, - {json: ` [{"a": 1},{"a": 2}] `, expTokens: []interface{}{ + {json: ` [{"a": 1},{"a": 2}] `, expTokens: []any{ Delim('['), - decodeThis{map[string]interface{}{"a": float64(1)}}, - decodeThis{map[string]interface{}{"a": float64(2)}}, + decodeThis{map[string]any{"a": float64(1)}}, + decodeThis{map[string]any{"a": float64(2)}}, Delim(']')}}, - {json: `{ "obj" : [ { "a" : 1 } ] }`, expTokens: []interface{}{ + {json: `{ "obj" : [ { "a" : 1 } ] }`, expTokens: []any{ Delim('{'), "obj", Delim('['), - decodeThis{map[string]interface{}{"a": float64(1)}}, + decodeThis{map[string]any{"a": float64(1)}}, Delim(']'), Delim('}')}}, - {json: `{"obj": {"a": 1}}`, expTokens: []interface{}{ + {json: `{"obj": {"a": 1}}`, expTokens: []any{ Delim('{'), "obj", - decodeThis{map[string]interface{}{"a": float64(1)}}, + decodeThis{map[string]any{"a": float64(1)}}, Delim('}')}}, - {json: `{"obj": [{"a": 1}]}`, expTokens: []interface{}{ + {json: `{"obj": [{"a": 1}]}`, expTokens: []any{ Delim('{'), "obj", - decodeThis{[]interface{}{ - map[string]interface{}{"a": float64(1)}, + decodeThis{[]any{ + map[string]any{"a": float64(1)}, }}, Delim('}')}}, - {json: ` [{"a": 1} {"a": 2}] `, expTokens: []interface{}{ + {json: ` [{"a": 1} {"a": 2}] `, expTokens: []any{ Delim('['), - decodeThis{map[string]interface{}{"a": float64(1)}}, + decodeThis{map[string]any{"a": float64(1)}}, decodeThis{&SyntaxError{"expected comma after array element", 11}}, }}, - {json: `{ "` + strings.Repeat("a", 513) + `" 1 }`, expTokens: []interface{}{ + {json: `{ "` + strings.Repeat("a", 513) + `" 1 }`, expTokens: []any{ Delim('{'), strings.Repeat("a", 513), decodeThis{&SyntaxError{"expected colon after object key", 518}}, }}, - {json: `{ "\a" }`, expTokens: []interface{}{ + {json: `{ "\a" }`, expTokens: []any{ Delim('{'), &SyntaxError{"invalid character 'a' in string escape code", 3}, }}, - {json: ` \a`, expTokens: []interface{}{ + {json: ` \a`, expTokens: []any{ &SyntaxError{"invalid character '\\\\' looking for beginning of value", 1}, }}, } @@ -410,7 +410,7 @@ func TestDecodeInStream(t *testing.T) { dec := NewDecoder(strings.NewReader(tcase.json)) for i, etk := range tcase.expTokens { - var tk interface{} + var tk any var err error if dt, ok := etk.(decodeThis); ok { diff --git a/src/encoding/json/tagkey_test.go b/src/encoding/json/tagkey_test.go index bbb4e6a28d..6330efd3c2 100644 --- a/src/encoding/json/tagkey_test.go +++ b/src/encoding/json/tagkey_test.go @@ -73,7 +73,7 @@ type unicodeTag struct { } var structTagObjectKeyTests = []struct { - raw interface{} + raw any value string key string }{ @@ -101,12 +101,12 @@ func TestStructTagObjectKey(t *testing.T) { if err != nil { t.Fatalf("Marshal(%#q) failed: %v", tt.raw, err) } - var f interface{} + var f any err = Unmarshal(b, &f) if err != nil { t.Fatalf("Unmarshal(%#q) failed: %v", b, err) } - for i, v := range f.(map[string]interface{}) { + for i, v := range f.(map[string]any) { switch i { case tt.key: if s, ok := v.(string); !ok || s != tt.value { diff --git a/src/encoding/xml/marshal.go b/src/encoding/xml/marshal.go index 1f0eb76341..6859be04a2 100644 --- a/src/encoding/xml/marshal.go +++ b/src/encoding/xml/marshal.go @@ -76,7 +76,7 @@ const ( // See MarshalIndent for an example. // // Marshal will return an error if asked to marshal a channel, function, or map. -func Marshal(v interface{}) ([]byte, error) { +func Marshal(v any) ([]byte, error) { var b bytes.Buffer if err := NewEncoder(&b).Encode(v); err != nil { return nil, err @@ -122,7 +122,7 @@ type MarshalerAttr interface { // MarshalIndent works like Marshal, but each XML element begins on a new // indented line that starts with prefix and is followed by one or more // copies of indent according to the nesting depth. -func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error) { +func MarshalIndent(v any, prefix, indent string) ([]byte, error) { var b bytes.Buffer enc := NewEncoder(&b) enc.Indent(prefix, indent) @@ -158,7 +158,7 @@ func (enc *Encoder) Indent(prefix, indent string) { // of Go values to XML. // // Encode calls Flush before returning. -func (enc *Encoder) Encode(v interface{}) error { +func (enc *Encoder) Encode(v any) error { err := enc.p.marshalValue(reflect.ValueOf(v), nil, nil) if err != nil { return err @@ -173,7 +173,7 @@ func (enc *Encoder) Encode(v interface{}) error { // of Go values to XML. // // EncodeElement calls Flush before returning. -func (enc *Encoder) EncodeElement(v interface{}, start StartElement) error { +func (enc *Encoder) EncodeElement(v any, start StartElement) error { err := enc.p.marshalValue(reflect.ValueOf(v), nil, &start) if err != nil { return err diff --git a/src/encoding/xml/marshal_test.go b/src/encoding/xml/marshal_test.go index cb95905f5b..5fdbae7ef0 100644 --- a/src/encoding/xml/marshal_test.go +++ b/src/encoding/xml/marshal_test.go @@ -120,17 +120,17 @@ type MixedNested struct { } type NilTest struct { - A interface{} `xml:"parent1>parent2>a"` - B interface{} `xml:"parent1>b"` - C interface{} `xml:"parent1>parent2>c"` + A any `xml:"parent1>parent2>a"` + B any `xml:"parent1>b"` + C any `xml:"parent1>parent2>c"` } type Service struct { XMLName struct{} `xml:"service"` Domain *Domain `xml:"host>domain"` Port *Port `xml:"host>port"` - Extra1 interface{} - Extra2 interface{} `xml:"host>extra2"` + Extra1 any + Extra2 any `xml:"host>extra2"` } var nilStruct *Ship @@ -283,7 +283,7 @@ type Data struct { } type Plain struct { - V interface{} + V any } type MyInt int @@ -387,7 +387,7 @@ type NestedAndCData struct { CDATA string `xml:",cdata"` } -func ifaceptr(x interface{}) interface{} { +func ifaceptr(x any) any { return &x } @@ -412,7 +412,7 @@ type DirectComment struct { type IfaceComment struct { T1 T1 - Comment interface{} `xml:",comment"` + Comment any `xml:",comment"` T2 T2 } @@ -430,7 +430,7 @@ type DirectChardata struct { type IfaceChardata struct { T1 T1 - Chardata interface{} `xml:",chardata"` + Chardata any `xml:",chardata"` T2 T2 } @@ -448,7 +448,7 @@ type DirectCDATA struct { type IfaceCDATA struct { T1 T1 - CDATA interface{} `xml:",cdata"` + CDATA any `xml:",cdata"` T2 T2 } @@ -466,7 +466,7 @@ type DirectInnerXML struct { type IfaceInnerXML struct { T1 T1 - InnerXML interface{} `xml:",innerxml"` + InnerXML any `xml:",innerxml"` T2 T2 } @@ -484,7 +484,7 @@ type DirectElement struct { type IfaceElement struct { T1 T1 - Element interface{} + Element any T2 T2 } @@ -502,7 +502,7 @@ type DirectOmitEmpty struct { type IfaceOmitEmpty struct { T1 T1 - OmitEmpty interface{} `xml:",omitempty"` + OmitEmpty any `xml:",omitempty"` T2 T2 } @@ -520,7 +520,7 @@ type DirectAny struct { type IfaceAny struct { T1 T1 - Any interface{} `xml:",any"` + Any any `xml:",any"` T2 T2 } @@ -540,7 +540,7 @@ var ( // please try to make them two-way as well to ensure that // marshaling and unmarshaling are as symmetrical as feasible. var marshalTests = []struct { - Value interface{} + Value any ExpectXML string MarshalOnly bool MarshalError string @@ -1700,7 +1700,7 @@ type BadAttr struct { } var marshalErrorTests = []struct { - Value interface{} + Value any Err string Kind reflect.Kind }{ @@ -1738,7 +1738,7 @@ var marshalErrorTests = []struct { } var marshalIndentTests = []struct { - Value interface{} + Value any Prefix string Indent string ExpectXML string @@ -1933,7 +1933,7 @@ func BenchmarkUnmarshal(b *testing.B) { func TestStructPointerMarshal(t *testing.T) { type A struct { XMLName string `xml:"a"` - B []interface{} + B []any } type C struct { XMLName Name @@ -2327,7 +2327,7 @@ loop: continue loop } } - errorf := func(f string, a ...interface{}) { + errorf := func(f string, a ...any) { t.Errorf("#%d %s token #%d:%s", i, tt.desc, len(tt.toks)-1, fmt.Sprintf(f, a...)) } switch { diff --git a/src/encoding/xml/read.go b/src/encoding/xml/read.go index 48b0ec055c..0701e18625 100644 --- a/src/encoding/xml/read.go +++ b/src/encoding/xml/read.go @@ -129,13 +129,13 @@ import ( // A missing element or empty attribute value will be unmarshaled as a zero value. // If the field is a slice, a zero value will be appended to the field. Otherwise, the // field will be set to its zero value. -func Unmarshal(data []byte, v interface{}) error { +func Unmarshal(data []byte, v any) error { return NewDecoder(bytes.NewReader(data)).Decode(v) } // Decode works like Unmarshal, except it reads the decoder // stream to find the start element. -func (d *Decoder) Decode(v interface{}) error { +func (d *Decoder) Decode(v any) error { return d.DecodeElement(v, nil) } @@ -143,7 +143,7 @@ func (d *Decoder) Decode(v interface{}) error { // a pointer to the start XML element to decode into v. // It is useful when a client reads some raw XML tokens itself // but also wants to defer to Unmarshal for some elements. -func (d *Decoder) DecodeElement(v interface{}, start *StartElement) error { +func (d *Decoder) DecodeElement(v any, start *StartElement) error { val := reflect.ValueOf(v) if val.Kind() != reflect.Pointer { return errors.New("non-pointer passed to Unmarshal") @@ -188,7 +188,7 @@ type UnmarshalerAttr interface { } // receiverType returns the receiver type to use in an expression like "%s.MethodName". -func receiverType(val interface{}) string { +func receiverType(val any) string { t := reflect.TypeOf(val) if t.Name() != "" { return t.String() diff --git a/src/encoding/xml/read_test.go b/src/encoding/xml/read_test.go index 8c2e70fa22..391fe731a8 100644 --- a/src/encoding/xml/read_test.go +++ b/src/encoding/xml/read_test.go @@ -270,7 +270,7 @@ type PathTestE struct { Before, After string } -var pathTests = []interface{}{ +var pathTests = []any{ &PathTestA{Items: []PathTestItem{{"A"}, {"D"}}, Before: "1", After: "2"}, &PathTestB{Other: []PathTestItem{{"A"}, {"D"}}, Before: "1", After: "2"}, &PathTestC{Values1: []string{"A", "C", "D"}, Values2: []string{"B"}, Before: "1", After: "2"}, @@ -321,7 +321,7 @@ type BadPathEmbeddedB struct { } var badPathTests = []struct { - v, e interface{} + v, e any }{ {&BadPathTestA{}, &TagPathError{reflect.TypeOf(BadPathTestA{}), "First", "items>item1", "Second", "items"}}, {&BadPathTestB{}, &TagPathError{reflect.TypeOf(BadPathTestB{}), "First", "items>item1", "Second", "items>item1>value"}}, @@ -691,7 +691,7 @@ type Pea struct { } type Pod struct { - Pea interface{} `xml:"Pea"` + Pea any `xml:"Pea"` } // https://golang.org/issue/6836 diff --git a/src/encoding/xml/xml.go b/src/encoding/xml/xml.go index 33d0b417b9..8a0a9c253a 100644 --- a/src/encoding/xml/xml.go +++ b/src/encoding/xml/xml.go @@ -52,7 +52,7 @@ type Attr struct { // A Token is an interface holding one of the token types: // StartElement, EndElement, CharData, Comment, ProcInst, or Directive. -type Token interface{} +type Token any // A StartElement represents an XML start element. type StartElement struct { diff --git a/src/errors/wrap.go b/src/errors/wrap.go index ab3cdb86d3..263ae16b48 100644 --- a/src/errors/wrap.go +++ b/src/errors/wrap.go @@ -75,7 +75,7 @@ func Is(err, target error) bool { // // As panics if target is not a non-nil pointer to either a type that implements // error, or to any interface type. -func As(err error, target interface{}) bool { +func As(err error, target any) bool { if target == nil { panic("errors: target cannot be nil") } @@ -93,7 +93,7 @@ func As(err error, target interface{}) bool { val.Elem().Set(reflectlite.ValueOf(err)) return true } - if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target) { + if x, ok := err.(interface{ As(any) bool }); ok && x.As(target) { return true } err = Unwrap(err) diff --git a/src/errors/wrap_test.go b/src/errors/wrap_test.go index a22fee2f04..eb8314b04b 100644 --- a/src/errors/wrap_test.go +++ b/src/errors/wrap_test.go @@ -66,7 +66,7 @@ var poserPathErr = &fs.PathError{Op: "poser"} func (p *poser) Error() string { return p.msg } func (p *poser) Is(err error) bool { return p.f(err) } -func (p *poser) As(err interface{}) bool { +func (p *poser) As(err any) bool { switch x := err.(type) { case **poser: *x = p @@ -90,9 +90,9 @@ func TestAs(t *testing.T) { testCases := []struct { err error - target interface{} + target any match bool - want interface{} // value of target on match + want any // value of target on match }{{ nil, &errP, @@ -171,7 +171,7 @@ func TestAs(t *testing.T) { func TestAsValidation(t *testing.T) { var s string - testCases := []interface{}{ + testCases := []any{ nil, (*int)(nil), "error", diff --git a/src/expvar/expvar.go b/src/expvar/expvar.go index 13b5c99b6e..8bbf41b151 100644 --- a/src/expvar/expvar.go +++ b/src/expvar/expvar.go @@ -130,7 +130,7 @@ func (v *Map) Init() *Map { v.keysMu.Lock() defer v.keysMu.Unlock() v.keys = v.keys[:0] - v.m.Range(func(k, _ interface{}) bool { + v.m.Range(func(k, _ any) bool { v.m.Delete(k) return true }) @@ -252,9 +252,9 @@ func (v *String) Set(value string) { // Func implements Var by calling the function // and formatting the returned value using JSON. -type Func func() interface{} +type Func func() any -func (f Func) Value() interface{} { +func (f Func) Value() any { return f() } @@ -350,11 +350,11 @@ func Handler() http.Handler { return http.HandlerFunc(expvarHandler) } -func cmdline() interface{} { +func cmdline() any { return os.Args } -func memstats() interface{} { +func memstats() any { stats := new(runtime.MemStats) runtime.ReadMemStats(stats) return *stats diff --git a/src/expvar/expvar_test.go b/src/expvar/expvar_test.go index 69b0a76058..ba95a36066 100644 --- a/src/expvar/expvar_test.go +++ b/src/expvar/expvar_test.go @@ -242,12 +242,12 @@ func TestMapCounter(t *testing.T) { // colors.String() should be '{"red":3, "blue":4}', // though the order of red and blue could vary. s := colors.String() - var j interface{} + var j any err := json.Unmarshal([]byte(s), &j) if err != nil { t.Errorf("colors.String() isn't valid JSON: %v", err) } - m, ok := j.(map[string]interface{}) + m, ok := j.(map[string]any) if !ok { t.Error("colors.String() didn't produce a map.") } @@ -427,8 +427,8 @@ func BenchmarkMapAddDifferentSteadyState(b *testing.B) { func TestFunc(t *testing.T) { RemoveAll() - var x interface{} = []string{"a", "b"} - f := Func(func() interface{} { return x }) + var x any = []string{"a", "b"} + f := Func(func() any { return x }) if s, exp := f.String(), `["a","b"]`; s != exp { t.Errorf(`f.String() = %q, want %q`, s, exp) } diff --git a/src/flag/flag.go b/src/flag/flag.go index 86e16e5a61..4e2af450c5 100644 --- a/src/flag/flag.go +++ b/src/flag/flag.go @@ -122,7 +122,7 @@ func (b *boolValue) Set(s string) error { return err } -func (b *boolValue) Get() interface{} { return bool(*b) } +func (b *boolValue) Get() any { return bool(*b) } func (b *boolValue) String() string { return strconv.FormatBool(bool(*b)) } @@ -152,7 +152,7 @@ func (i *intValue) Set(s string) error { return err } -func (i *intValue) Get() interface{} { return int(*i) } +func (i *intValue) Get() any { return int(*i) } func (i *intValue) String() string { return strconv.Itoa(int(*i)) } @@ -173,7 +173,7 @@ func (i *int64Value) Set(s string) error { return err } -func (i *int64Value) Get() interface{} { return int64(*i) } +func (i *int64Value) Get() any { return int64(*i) } func (i *int64Value) String() string { return strconv.FormatInt(int64(*i), 10) } @@ -194,7 +194,7 @@ func (i *uintValue) Set(s string) error { return err } -func (i *uintValue) Get() interface{} { return uint(*i) } +func (i *uintValue) Get() any { return uint(*i) } func (i *uintValue) String() string { return strconv.FormatUint(uint64(*i), 10) } @@ -215,7 +215,7 @@ func (i *uint64Value) Set(s string) error { return err } -func (i *uint64Value) Get() interface{} { return uint64(*i) } +func (i *uint64Value) Get() any { return uint64(*i) } func (i *uint64Value) String() string { return strconv.FormatUint(uint64(*i), 10) } @@ -232,7 +232,7 @@ func (s *stringValue) Set(val string) error { return nil } -func (s *stringValue) Get() interface{} { return string(*s) } +func (s *stringValue) Get() any { return string(*s) } func (s *stringValue) String() string { return string(*s) } @@ -253,7 +253,7 @@ func (f *float64Value) Set(s string) error { return err } -func (f *float64Value) Get() interface{} { return float64(*f) } +func (f *float64Value) Get() any { return float64(*f) } func (f *float64Value) String() string { return strconv.FormatFloat(float64(*f), 'g', -1, 64) } @@ -274,7 +274,7 @@ func (d *durationValue) Set(s string) error { return err } -func (d *durationValue) Get() interface{} { return time.Duration(*d) } +func (d *durationValue) Get() any { return time.Duration(*d) } func (d *durationValue) String() string { return (*time.Duration)(d).String() } @@ -305,7 +305,7 @@ type Value interface { // by this package satisfy the Getter interface, except the type used by Func. type Getter interface { Value - Get() interface{} + Get() any } // ErrorHandling defines how FlagSet.Parse behaves if the parse fails. @@ -895,7 +895,7 @@ func Var(value Value, name string, usage string) { } // sprintf formats the message, prints it to output, and returns it. -func (f *FlagSet) sprintf(format string, a ...interface{}) string { +func (f *FlagSet) sprintf(format string, a ...any) string { msg := fmt.Sprintf(format, a...) fmt.Fprintln(f.Output(), msg) return msg @@ -903,7 +903,7 @@ func (f *FlagSet) sprintf(format string, a ...interface{}) string { // failf prints to standard error a formatted error and usage message and // returns the error. -func (f *FlagSet) failf(format string, a ...interface{}) error { +func (f *FlagSet) failf(format string, a ...any) error { msg := f.sprintf(format, a...) f.usage() return errors.New(msg) diff --git a/src/fmt/errors.go b/src/fmt/errors.go index 466a620353..4f4daf19e1 100644 --- a/src/fmt/errors.go +++ b/src/fmt/errors.go @@ -14,7 +14,7 @@ import "errors" // invalid to include more than one %w verb or to supply it with an operand // that does not implement the error interface. The %w verb is otherwise // a synonym for %v. -func Errorf(format string, a ...interface{}) error { +func Errorf(format string, a ...any) error { p := newPrinter() p.wrapErrs = true p.doPrintf(format, a) diff --git a/src/fmt/fmt_test.go b/src/fmt/fmt_test.go index 87fb323809..a4c65b8f5e 100644 --- a/src/fmt/fmt_test.go +++ b/src/fmt/fmt_test.go @@ -40,7 +40,7 @@ type ( ) func TestFmtInterface(t *testing.T) { - var i1 interface{} + var i1 any i1 = "abc" s := Sprintf("%s", i1) if s != "abc" { @@ -56,7 +56,7 @@ var ( intVar = 0 array = [5]int{1, 2, 3, 4, 5} - iarray = [4]interface{}{1, "hello", 2.5, nil} + iarray = [4]any{1, "hello", 2.5, nil} slice = array[:] islice = iarray[:] ) @@ -100,7 +100,7 @@ type S struct { } type SI struct { - I interface{} + I any } // P is a type with a String method with pointer receiver for testing %p. @@ -141,7 +141,7 @@ func (sf writeStringFormatter) Format(f State, c rune) { var fmtTests = []struct { fmt string - val interface{} + val any out string }{ {"%d", 12345, "12345"}, @@ -993,14 +993,14 @@ var fmtTests = []struct { // float and complex formatting should not change the padding width // for other elements. See issue 14642. - {"%06v", []interface{}{+10.0, 10}, "[000010 000010]"}, - {"%06v", []interface{}{-10.0, 10}, "[-00010 000010]"}, - {"%06v", []interface{}{+10.0 + 10i, 10}, "[(000010+00010i) 000010]"}, - {"%06v", []interface{}{-10.0 + 10i, 10}, "[(-00010+00010i) 000010]"}, + {"%06v", []any{+10.0, 10}, "[000010 000010]"}, + {"%06v", []any{-10.0, 10}, "[-00010 000010]"}, + {"%06v", []any{+10.0 + 10i, 10}, "[(000010+00010i) 000010]"}, + {"%06v", []any{-10.0 + 10i, 10}, "[(-00010+00010i) 000010]"}, // integer formatting should not alter padding for other elements. - {"%03.6v", []interface{}{1, 2.0, "x"}, "[000001 002 00x]"}, - {"%03.0v", []interface{}{0, 2.0, "x"}, "[ 002 000]"}, + {"%03.6v", []any{1, 2.0, "x"}, "[000001 002 00x]"}, + {"%03.0v", []any{0, 2.0, "x"}, "[ 002 000]"}, // Complex fmt used to leave the plus flag set for future entries in the array // causing +2+0i and +3+0i instead of 2+0i and 3+0i. @@ -1060,7 +1060,7 @@ var fmtTests = []struct { // Tests to check that not supported verbs generate an error string. {"%☠", nil, "%!☠()"}, - {"%☠", interface{}(nil), "%!☠()"}, + {"%☠", any(nil), "%!☠()"}, {"%☠", int(0), "%!☠(int=0)"}, {"%☠", uint(0), "%!☠(uint=0)"}, {"%☠", []byte{0, 1}, "[%!☠(uint8=0) %!☠(uint8=1)]"}, @@ -1077,8 +1077,8 @@ var fmtTests = []struct { {"%☠", func() {}, "%!☠(func()=0xPTR)"}, {"%☠", reflect.ValueOf(renamedInt(0)), "%!☠(fmt_test.renamedInt=0)"}, {"%☠", SI{renamedInt(0)}, "{%!☠(fmt_test.renamedInt=0)}"}, - {"%☠", &[]interface{}{I(1), G(2)}, "&[%!☠(fmt_test.I=1) %!☠(fmt_test.G=2)]"}, - {"%☠", SI{&[]interface{}{I(1), G(2)}}, "{%!☠(*[]interface {}=&[1 2])}"}, + {"%☠", &[]any{I(1), G(2)}, "&[%!☠(fmt_test.I=1) %!☠(fmt_test.G=2)]"}, + {"%☠", SI{&[]any{I(1), G(2)}}, "{%!☠(*[]interface {}=&[1 2])}"}, {"%☠", reflect.Value{}, ""}, {"%☠", map[float64]int{NaN: 1}, "map[%!☠(float64=NaN):%!☠(int=1)]"}, } @@ -1180,7 +1180,7 @@ func TestComplexFormatting(t *testing.T) { } } -type SE []interface{} // slice of empty; notational compactness. +type SE []any // slice of empty; notational compactness. var reorderTests = []struct { fmt string @@ -1267,7 +1267,7 @@ func BenchmarkSprintfTruncateString(b *testing.B) { } func BenchmarkSprintfTruncateBytes(b *testing.B) { - var bytes interface{} = []byte("日本語日本語日本語日本語") + var bytes any = []byte("日本語日本語日本語日本語") b.RunParallel(func(pb *testing.PB) { for pb.Next() { Sprintf("%.3s", bytes) @@ -1375,7 +1375,7 @@ func BenchmarkSprintfStringer(b *testing.B) { } func BenchmarkSprintfStructure(b *testing.B) { - s := &[]interface{}{SI{12345}, map[int]string{0: "hello"}} + s := &[]any{SI{12345}, map[int]string{0: "hello"}} b.RunParallel(func(pb *testing.PB) { for pb.Next() { Sprintf("%#v", s) @@ -1411,7 +1411,7 @@ func BenchmarkFprintfBytes(b *testing.B) { } func BenchmarkFprintIntNoAlloc(b *testing.B) { - var x interface{} = 123456 + var x any = 123456 var buf bytes.Buffer for i := 0; i < b.N; i++ { buf.Reset() @@ -1641,11 +1641,11 @@ func TestFormatterPrintln(t *testing.T) { } } -func args(a ...interface{}) []interface{} { return a } +func args(a ...any) []any { return a } var startests = []struct { fmt string - in []interface{} + in []any out string }{ {"%*d", args(4, 42), " 42"}, @@ -1687,7 +1687,7 @@ func TestWidthAndPrecision(t *testing.T) { // PanicS is a type that panics in String. type PanicS struct { - message interface{} + message any } // Value receiver. @@ -1697,7 +1697,7 @@ func (p PanicS) String() string { // PanicGo is a type that panics in GoString. type PanicGo struct { - message interface{} + message any } // Value receiver. @@ -1707,7 +1707,7 @@ func (p PanicGo) GoString() string { // PanicF is a type that panics in Format. type PanicF struct { - message interface{} + message any } // Value receiver. @@ -1717,7 +1717,7 @@ func (p PanicF) Format(f State, c rune) { var panictests = []struct { fmt string - in interface{} + in any out string }{ // String @@ -1729,7 +1729,7 @@ var panictests = []struct { {"%#v", PanicGo{io.ErrUnexpectedEOF}, "%!v(PANIC=GoString method: unexpected EOF)"}, {"%#v", PanicGo{3}, "%!v(PANIC=GoString method: 3)"}, // Issue 18282. catchPanic should not clear fmtFlags permanently. - {"%#v", []interface{}{PanicGo{3}, PanicGo{3}}, "[]interface {}{%!v(PANIC=GoString method: 3), %!v(PANIC=GoString method: 3)}"}, + {"%#v", []any{PanicGo{3}, PanicGo{3}}, "[]interface {}{%!v(PANIC=GoString method: 3), %!v(PANIC=GoString method: 3)}"}, // Format {"%s", (*PanicF)(nil), ""}, // nil pointer special case {"%s", PanicF{io.ErrUnexpectedEOF}, "%!s(PANIC=Format method: unexpected EOF)"}, @@ -1805,7 +1805,7 @@ func TestNilDoesNotBecomeTyped(t *testing.T) { var formatterFlagTests = []struct { in string - val interface{} + val any out string }{ // scalar values with the (unused by fmt) 'a' verb. diff --git a/src/fmt/print.go b/src/fmt/print.go index 698ab557a4..1c37c3cb7b 100644 --- a/src/fmt/print.go +++ b/src/fmt/print.go @@ -106,7 +106,7 @@ type pp struct { buf buffer // arg holds the current item, as an interface{}. - arg interface{} + arg any // value is used instead of arg for reflect values. value reflect.Value @@ -129,7 +129,7 @@ type pp struct { } var ppFree = sync.Pool{ - New: func() interface{} { return new(pp) }, + New: func() any { return new(pp) }, } // newPrinter allocates a new pp struct or grabs a cached one. @@ -199,7 +199,7 @@ func (p *pp) WriteString(s string) (ret int, err error) { // Fprintf formats according to a format specifier and writes to w. // It returns the number of bytes written and any write error encountered. -func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { +func Fprintf(w io.Writer, format string, a ...any) (n int, err error) { p := newPrinter() p.doPrintf(format, a) n, err = w.Write(p.buf) @@ -209,12 +209,12 @@ func Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) { // Printf formats according to a format specifier and writes to standard output. // It returns the number of bytes written and any write error encountered. -func Printf(format string, a ...interface{}) (n int, err error) { +func Printf(format string, a ...any) (n int, err error) { return Fprintf(os.Stdout, format, a...) } // Sprintf formats according to a format specifier and returns the resulting string. -func Sprintf(format string, a ...interface{}) string { +func Sprintf(format string, a ...any) string { p := newPrinter() p.doPrintf(format, a) s := string(p.buf) @@ -227,7 +227,7 @@ func Sprintf(format string, a ...interface{}) string { // Fprint formats using the default formats for its operands and writes to w. // Spaces are added between operands when neither is a string. // It returns the number of bytes written and any write error encountered. -func Fprint(w io.Writer, a ...interface{}) (n int, err error) { +func Fprint(w io.Writer, a ...any) (n int, err error) { p := newPrinter() p.doPrint(a) n, err = w.Write(p.buf) @@ -238,13 +238,13 @@ func Fprint(w io.Writer, a ...interface{}) (n int, err error) { // Print formats using the default formats for its operands and writes to standard output. // Spaces are added between operands when neither is a string. // It returns the number of bytes written and any write error encountered. -func Print(a ...interface{}) (n int, err error) { +func Print(a ...any) (n int, err error) { return Fprint(os.Stdout, a...) } // Sprint formats using the default formats for its operands and returns the resulting string. // Spaces are added between operands when neither is a string. -func Sprint(a ...interface{}) string { +func Sprint(a ...any) string { p := newPrinter() p.doPrint(a) s := string(p.buf) @@ -259,7 +259,7 @@ func Sprint(a ...interface{}) string { // Fprintln formats using the default formats for its operands and writes to w. // Spaces are always added between operands and a newline is appended. // It returns the number of bytes written and any write error encountered. -func Fprintln(w io.Writer, a ...interface{}) (n int, err error) { +func Fprintln(w io.Writer, a ...any) (n int, err error) { p := newPrinter() p.doPrintln(a) n, err = w.Write(p.buf) @@ -270,13 +270,13 @@ func Fprintln(w io.Writer, a ...interface{}) (n int, err error) { // Println formats using the default formats for its operands and writes to standard output. // Spaces are always added between operands and a newline is appended. // It returns the number of bytes written and any write error encountered. -func Println(a ...interface{}) (n int, err error) { +func Println(a ...any) (n int, err error) { return Fprintln(os.Stdout, a...) } // Sprintln formats using the default formats for its operands and returns the resulting string. // Spaces are always added between operands and a newline is appended. -func Sprintln(a ...interface{}) string { +func Sprintln(a ...any) string { p := newPrinter() p.doPrintln(a) s := string(p.buf) @@ -533,7 +533,7 @@ func (p *pp) fmtPointer(value reflect.Value, verb rune) { } } -func (p *pp) catchPanic(arg interface{}, verb rune, method string) { +func (p *pp) catchPanic(arg any, verb rune, method string) { if err := recover(); err != nil { // If it's a nil pointer, just say "". The likeliest causes are a // Stringer that fails to guard against nil or a nil pointer for a @@ -631,7 +631,7 @@ func (p *pp) handleMethods(verb rune) (handled bool) { return false } -func (p *pp) printArg(arg interface{}, verb rune) { +func (p *pp) printArg(arg any, verb rune) { p.arg = arg p.value = reflect.Value{} @@ -886,7 +886,7 @@ func (p *pp) printValue(value reflect.Value, verb rune, depth int) { } // intFromArg gets the argNumth element of a. On return, isInt reports whether the argument has integer type. -func intFromArg(a []interface{}, argNum int) (num int, isInt bool, newArgNum int) { +func intFromArg(a []any, argNum int) (num int, isInt bool, newArgNum int) { newArgNum = argNum if argNum < len(a) { num, isInt = a[argNum].(int) // Almost always OK. @@ -971,7 +971,7 @@ func (p *pp) missingArg(verb rune) { p.buf.writeString(missingString) } -func (p *pp) doPrintf(format string, a []interface{}) { +func (p *pp) doPrintf(format string, a []any) { end := len(format) argNum := 0 // we process one argument per non-trivial format afterIndex := false // previous item in format was an index like [3]. @@ -1146,7 +1146,7 @@ formatLoop: } } -func (p *pp) doPrint(a []interface{}) { +func (p *pp) doPrint(a []any) { prevString := false for argNum, arg := range a { isString := arg != nil && reflect.TypeOf(arg).Kind() == reflect.String @@ -1161,7 +1161,7 @@ func (p *pp) doPrint(a []interface{}) { // doPrintln is like doPrint but always adds a space between arguments // and a newline after the last argument. -func (p *pp) doPrintln(a []interface{}) { +func (p *pp) doPrintln(a []any) { for argNum, arg := range a { if argNum > 0 { p.buf.writeByte(' ') diff --git a/src/fmt/scan.go b/src/fmt/scan.go index 18cb608f43..d38610df35 100644 --- a/src/fmt/scan.go +++ b/src/fmt/scan.go @@ -60,13 +60,13 @@ type Scanner interface { // space-separated values into successive arguments. Newlines count // as space. It returns the number of items successfully scanned. // If that is less than the number of arguments, err will report why. -func Scan(a ...interface{}) (n int, err error) { +func Scan(a ...any) (n int, err error) { return Fscan(os.Stdin, a...) } // Scanln is similar to Scan, but stops scanning at a newline and // after the final item there must be a newline or EOF. -func Scanln(a ...interface{}) (n int, err error) { +func Scanln(a ...any) (n int, err error) { return Fscanln(os.Stdin, a...) } @@ -77,7 +77,7 @@ func Scanln(a ...interface{}) (n int, err error) { // Newlines in the input must match newlines in the format. // The one exception: the verb %c always scans the next rune in the // input, even if it is a space (or tab etc.) or newline. -func Scanf(format string, a ...interface{}) (n int, err error) { +func Scanf(format string, a ...any) (n int, err error) { return Fscanf(os.Stdin, format, a...) } @@ -96,13 +96,13 @@ func (r *stringReader) Read(b []byte) (n int, err error) { // values into successive arguments. Newlines count as space. It // returns the number of items successfully scanned. If that is less // than the number of arguments, err will report why. -func Sscan(str string, a ...interface{}) (n int, err error) { +func Sscan(str string, a ...any) (n int, err error) { return Fscan((*stringReader)(&str), a...) } // Sscanln is similar to Sscan, but stops scanning at a newline and // after the final item there must be a newline or EOF. -func Sscanln(str string, a ...interface{}) (n int, err error) { +func Sscanln(str string, a ...any) (n int, err error) { return Fscanln((*stringReader)(&str), a...) } @@ -110,7 +110,7 @@ func Sscanln(str string, a ...interface{}) (n int, err error) { // values into successive arguments as determined by the format. It // returns the number of items successfully parsed. // Newlines in the input must match newlines in the format. -func Sscanf(str string, format string, a ...interface{}) (n int, err error) { +func Sscanf(str string, format string, a ...any) (n int, err error) { return Fscanf((*stringReader)(&str), format, a...) } @@ -118,7 +118,7 @@ func Sscanf(str string, format string, a ...interface{}) (n int, err error) { // values into successive arguments. Newlines count as space. It // returns the number of items successfully scanned. If that is less // than the number of arguments, err will report why. -func Fscan(r io.Reader, a ...interface{}) (n int, err error) { +func Fscan(r io.Reader, a ...any) (n int, err error) { s, old := newScanState(r, true, false) n, err = s.doScan(a) s.free(old) @@ -127,7 +127,7 @@ func Fscan(r io.Reader, a ...interface{}) (n int, err error) { // Fscanln is similar to Fscan, but stops scanning at a newline and // after the final item there must be a newline or EOF. -func Fscanln(r io.Reader, a ...interface{}) (n int, err error) { +func Fscanln(r io.Reader, a ...any) (n int, err error) { s, old := newScanState(r, false, true) n, err = s.doScan(a) s.free(old) @@ -138,7 +138,7 @@ func Fscanln(r io.Reader, a ...interface{}) (n int, err error) { // values into successive arguments as determined by the format. It // returns the number of items successfully parsed. // Newlines in the input must match newlines in the format. -func Fscanf(r io.Reader, format string, a ...interface{}) (n int, err error) { +func Fscanf(r io.Reader, format string, a ...any) (n int, err error) { s, old := newScanState(r, false, false) n, err = s.doScanf(format, a) s.free(old) @@ -376,7 +376,7 @@ func (r *readRune) UnreadRune() error { } var ssFree = sync.Pool{ - New: func() interface{} { return new(ss) }, + New: func() any { return new(ss) }, } // newScanState allocates a new ss struct or grab a cached one. @@ -950,7 +950,7 @@ func (s *ss) scanPercent() { } // scanOne scans a single value, deriving the scanner from the type of the argument. -func (s *ss) scanOne(verb rune, arg interface{}) { +func (s *ss) scanOne(verb rune, arg any) { s.buf = s.buf[:0] var err error // If the parameter has its own Scan method, use that. @@ -1067,7 +1067,7 @@ func errorHandler(errp *error) { } // doScan does the real work for scanning without a format string. -func (s *ss) doScan(a []interface{}) (numProcessed int, err error) { +func (s *ss) doScan(a []any) (numProcessed int, err error) { defer errorHandler(&err) for _, arg := range a { s.scanOne('v', arg) @@ -1178,7 +1178,7 @@ func (s *ss) advance(format string) (i int) { // doScanf does the real work when scanning with a format string. // At the moment, it handles only pointers to basic types. -func (s *ss) doScanf(format string, a []interface{}) (numProcessed int, err error) { +func (s *ss) doScanf(format string, a []any) (numProcessed int, err error) { defer errorHandler(&err) end := len(format) - 1 // We process one item per non-trivial format diff --git a/src/fmt/scan_test.go b/src/fmt/scan_test.go index 6b71b792ed..da0dfd19a2 100644 --- a/src/fmt/scan_test.go +++ b/src/fmt/scan_test.go @@ -21,22 +21,22 @@ import ( type ScanTest struct { text string - in interface{} - out interface{} + in any + out any } type ScanfTest struct { format string text string - in interface{} - out interface{} + in any + out any } type ScanfMultiTest struct { format string text string - in []interface{} - out []interface{} + in []any + out []any err string } @@ -444,7 +444,7 @@ var z IntString var r1, r2, r3 rune var multiTests = []ScanfMultiTest{ - {"", "", []interface{}{}, []interface{}{}, ""}, + {"", "", []any{}, []any{}, ""}, {"%d", "23", args(&i), args(23), ""}, {"%2s%3s", "22333", args(&s, &t), args("22", "333"), ""}, {"%2d%3d", "44555", args(&i, &j), args(44, 555), ""}, @@ -498,7 +498,7 @@ var readers = []struct { }}, } -func testScan(t *testing.T, f func(string) io.Reader, scan func(r io.Reader, a ...interface{}) (int, error)) { +func testScan(t *testing.T, f func(string) io.Reader, scan func(r io.Reader, a ...any) (int, error)) { for _, test := range scanTests { r := f(test.text) n, err := scan(r, test.in) @@ -637,7 +637,7 @@ func TestInf(t *testing.T) { } func testScanfMulti(t *testing.T, f func(string) io.Reader) { - sliceType := reflect.TypeOf(make([]interface{}, 1)) + sliceType := reflect.TypeOf(make([]any, 1)) for _, test := range multiTests { r := f(test.text) n, err := Fscanf(r, test.format, test.in...) @@ -836,7 +836,7 @@ func TestEOFAtEndOfInput(t *testing.T) { var eofTests = []struct { format string - v interface{} + v any }{ {"%s", &stringVal}, {"%q", &stringVal}, diff --git a/src/go/ast/print.go b/src/go/ast/print.go index b58683075c..85e6943928 100644 --- a/src/go/ast/print.go +++ b/src/go/ast/print.go @@ -36,17 +36,17 @@ func NotNilFilter(_ string, v reflect.Value) bool { // struct fields for which f(fieldname, fieldvalue) is true are // printed; all others are filtered from the output. Unexported // struct fields are never printed. -func Fprint(w io.Writer, fset *token.FileSet, x interface{}, f FieldFilter) error { +func Fprint(w io.Writer, fset *token.FileSet, x any, f FieldFilter) error { return fprint(w, fset, x, f) } -func fprint(w io.Writer, fset *token.FileSet, x interface{}, f FieldFilter) (err error) { +func fprint(w io.Writer, fset *token.FileSet, x any, f FieldFilter) (err error) { // setup printer p := printer{ output: w, fset: fset, filter: f, - ptrmap: make(map[interface{}]int), + ptrmap: make(map[any]int), last: '\n', // force printing of line number on first line } @@ -70,7 +70,7 @@ func fprint(w io.Writer, fset *token.FileSet, x interface{}, f FieldFilter) (err // Print prints x to standard output, skipping nil fields. // Print(fset, x) is the same as Fprint(os.Stdout, fset, x, NotNilFilter). -func Print(fset *token.FileSet, x interface{}) error { +func Print(fset *token.FileSet, x any) error { return Fprint(os.Stdout, fset, x, NotNilFilter) } @@ -78,10 +78,10 @@ type printer struct { output io.Writer fset *token.FileSet filter FieldFilter - ptrmap map[interface{}]int // *T -> line number - indent int // current indentation level - last byte // the last byte processed by Write - line int // current line number + ptrmap map[any]int // *T -> line number + indent int // current indentation level + last byte // the last byte processed by Write + line int // current line number } var indent = []byte(". ") @@ -125,7 +125,7 @@ type localError struct { } // printf is a convenience wrapper that takes care of print errors. -func (p *printer) printf(format string, args ...interface{}) { +func (p *printer) printf(format string, args ...any) { if _, err := fmt.Fprintf(p, format, args...); err != nil { panic(localError{err}) } diff --git a/src/go/ast/print_test.go b/src/go/ast/print_test.go index 210f164301..6691ccd63a 100644 --- a/src/go/ast/print_test.go +++ b/src/go/ast/print_test.go @@ -11,7 +11,7 @@ import ( ) var tests = []struct { - x interface{} // x is printed as s + x any // x is printed as s s string }{ // basic types diff --git a/src/go/ast/resolve.go b/src/go/ast/resolve.go index c1830b5e4d..126a27b18c 100644 --- a/src/go/ast/resolve.go +++ b/src/go/ast/resolve.go @@ -22,7 +22,7 @@ func (p *pkgBuilder) error(pos token.Pos, msg string) { p.errors.Add(p.fset.Position(pos), msg) } -func (p *pkgBuilder) errorf(pos token.Pos, format string, args ...interface{}) { +func (p *pkgBuilder) errorf(pos token.Pos, format string, args ...any) { p.error(pos, fmt.Sprintf(format, args...)) } diff --git a/src/go/ast/scope.go b/src/go/ast/scope.go index a400c7152a..d24a5f0e00 100644 --- a/src/go/ast/scope.go +++ b/src/go/ast/scope.go @@ -75,10 +75,10 @@ func (s *Scope) String() string { // type Object struct { Kind ObjKind - Name string // declared name - Decl interface{} // corresponding Field, XxxSpec, FuncDecl, LabeledStmt, AssignStmt, Scope; or nil - Data interface{} // object-specific data; or nil - Type interface{} // placeholder for type information; may be nil + Name string // declared name + Decl any // corresponding Field, XxxSpec, FuncDecl, LabeledStmt, AssignStmt, Scope; or nil + Data any // object-specific data; or nil + Type any // placeholder for type information; may be nil } // NewObj creates a new object of a given kind and name. diff --git a/src/go/constant/value.go b/src/go/constant/value.go index 014e873100..dee3bce9ee 100644 --- a/src/go/constant/value.go +++ b/src/go/constant/value.go @@ -579,7 +579,7 @@ func Float64Val(x Value) (float64, bool) { // Float *big.Float or *big.Rat // everything else nil // -func Val(x Value) interface{} { +func Val(x Value) any { switch x := x.(type) { case boolVal: return bool(x) @@ -610,7 +610,7 @@ func Val(x Value) interface{} { // *big.Rat Float // anything else Unknown // -func Make(x interface{}) Value { +func Make(x any) Value { switch x := x.(type) { case bool: return boolVal(x) diff --git a/src/go/constant/value_test.go b/src/go/constant/value_test.go index ac179b3d8c..e41315ee27 100644 --- a/src/go/constant/value_test.go +++ b/src/go/constant/value_test.go @@ -659,10 +659,10 @@ func TestMakeFloat64(t *testing.T) { type makeTestCase struct { kind Kind - arg, want interface{} + arg, want any } -func dup(k Kind, x interface{}) makeTestCase { return makeTestCase{k, x, x} } +func dup(k Kind, x any) makeTestCase { return makeTestCase{k, x, x} } func TestMake(t *testing.T) { for _, test := range []makeTestCase{ diff --git a/src/go/doc/doc.go b/src/go/doc/doc.go index 79d38998e7..5ab854d084 100644 --- a/src/go/doc/doc.go +++ b/src/go/doc/doc.go @@ -157,7 +157,7 @@ func New(pkg *ast.Package, importPath string, mode Mode) *Package { // NewFromFiles takes ownership of the AST files and may edit them, // unless the PreserveAST Mode bit is on. // -func NewFromFiles(fset *token.FileSet, files []*ast.File, importPath string, opts ...interface{}) (*Package, error) { +func NewFromFiles(fset *token.FileSet, files []*ast.File, importPath string, opts ...any) (*Package, error) { // Check for invalid API usage. if fset == nil { panic(fmt.Errorf("doc.NewFromFiles: no token.FileSet provided (fset == nil)")) diff --git a/src/go/doc/doc_test.go b/src/go/doc/doc_test.go index cbdca62aa1..3d17036f01 100644 --- a/src/go/doc/doc_test.go +++ b/src/go/doc/doc_test.go @@ -38,7 +38,7 @@ func readTemplate(filename string) *template.Template { return template.Must(t.ParseFiles(filepath.Join(dataDir, filename))) } -func nodeFmt(node interface{}, fset *token.FileSet) string { +func nodeFmt(node any, fset *token.FileSet) string { var buf bytes.Buffer printer.Fprint(&buf, fset, node) return strings.ReplaceAll(strings.TrimSpace(buf.String()), "\n", "\n\t") diff --git a/src/go/doc/testdata/benchmark.go b/src/go/doc/testdata/benchmark.go index 1d581f057e..d27bf116aa 100644 --- a/src/go/doc/testdata/benchmark.go +++ b/src/go/doc/testdata/benchmark.go @@ -232,7 +232,7 @@ func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks [ runtime.GOMAXPROCS(procs) b := &B{ common: common{ - signal: make(chan interface{}), + signal: make(chan any), }, benchmark: Benchmark, } @@ -285,7 +285,7 @@ func (b *B) trimOutput() { func Benchmark(f func(b *B)) BenchmarkResult { b := &B{ common: common{ - signal: make(chan interface{}), + signal: make(chan any), }, benchmark: InternalBenchmark{"", f}, } diff --git a/src/go/doc/testdata/testing.0.golden b/src/go/doc/testdata/testing.0.golden index 83cf37cd3a..61dac8bb66 100644 --- a/src/go/doc/testdata/testing.0.golden +++ b/src/go/doc/testdata/testing.0.golden @@ -46,10 +46,10 @@ TYPES } // Error is equivalent to Log() followed by Fail(). - func (c *B) Error(args ...interface{}) + func (c *B) Error(args ...any) // Errorf is equivalent to Logf() followed by Fail(). - func (c *B) Errorf(format string, args ...interface{}) + func (c *B) Errorf(format string, args ...any) // Fail marks the function as having failed but continues ... func (c *B) Fail() @@ -61,16 +61,16 @@ TYPES func (c *B) Failed() bool // Fatal is equivalent to Log() followed by FailNow(). - func (c *B) Fatal(args ...interface{}) + func (c *B) Fatal(args ...any) // Fatalf is equivalent to Logf() followed by FailNow(). - func (c *B) Fatalf(format string, args ...interface{}) + func (c *B) Fatalf(format string, args ...any) // Log formats its arguments using default formatting, analogous ... - func (c *B) Log(args ...interface{}) + func (c *B) Log(args ...any) // Logf formats its arguments according to the format, analogous ... - func (c *B) Logf(format string, args ...interface{}) + func (c *B) Logf(format string, args ...any) // ResetTimer sets the elapsed benchmark time to zero. It does not ... func (b *B) ResetTimer() @@ -125,10 +125,10 @@ TYPES } // Error is equivalent to Log() followed by Fail(). - func (c *T) Error(args ...interface{}) + func (c *T) Error(args ...any) // Errorf is equivalent to Logf() followed by Fail(). - func (c *T) Errorf(format string, args ...interface{}) + func (c *T) Errorf(format string, args ...any) // Fail marks the function as having failed but continues ... func (c *T) Fail() @@ -140,16 +140,16 @@ TYPES func (c *T) Failed() bool // Fatal is equivalent to Log() followed by FailNow(). - func (c *T) Fatal(args ...interface{}) + func (c *T) Fatal(args ...any) // Fatalf is equivalent to Logf() followed by FailNow(). - func (c *T) Fatalf(format string, args ...interface{}) + func (c *T) Fatalf(format string, args ...any) // Log formats its arguments using default formatting, analogous ... - func (c *T) Log(args ...interface{}) + func (c *T) Log(args ...any) // Logf formats its arguments according to the format, analogous ... - func (c *T) Logf(format string, args ...interface{}) + func (c *T) Logf(format string, args ...any) // Parallel signals that this test is to be run in parallel with ... func (t *T) Parallel() diff --git a/src/go/doc/testdata/testing.1.golden b/src/go/doc/testdata/testing.1.golden index b9d14517a9..1655af11a8 100644 --- a/src/go/doc/testdata/testing.1.golden +++ b/src/go/doc/testdata/testing.1.golden @@ -119,10 +119,10 @@ TYPES } // Error is equivalent to Log() followed by Fail(). - func (c *B) Error(args ...interface{}) + func (c *B) Error(args ...any) // Errorf is equivalent to Logf() followed by Fail(). - func (c *B) Errorf(format string, args ...interface{}) + func (c *B) Errorf(format string, args ...any) // Fail marks the function as having failed but continues ... func (c *B) Fail() @@ -134,16 +134,16 @@ TYPES func (c *B) Failed() bool // Fatal is equivalent to Log() followed by FailNow(). - func (c *B) Fatal(args ...interface{}) + func (c *B) Fatal(args ...any) // Fatalf is equivalent to Logf() followed by FailNow(). - func (c *B) Fatalf(format string, args ...interface{}) + func (c *B) Fatalf(format string, args ...any) // Log formats its arguments using default formatting, analogous ... - func (c *B) Log(args ...interface{}) + func (c *B) Log(args ...any) // Logf formats its arguments according to the format, analogous ... - func (c *B) Logf(format string, args ...interface{}) + func (c *B) Logf(format string, args ...any) // ResetTimer sets the elapsed benchmark time to zero. It does not ... func (b *B) ResetTimer() @@ -221,10 +221,10 @@ TYPES } // Error is equivalent to Log() followed by Fail(). - func (c *T) Error(args ...interface{}) + func (c *T) Error(args ...any) // Errorf is equivalent to Logf() followed by Fail(). - func (c *T) Errorf(format string, args ...interface{}) + func (c *T) Errorf(format string, args ...any) // Fail marks the function as having failed but continues ... func (c *T) Fail() @@ -236,16 +236,16 @@ TYPES func (c *T) Failed() bool // Fatal is equivalent to Log() followed by FailNow(). - func (c *T) Fatal(args ...interface{}) + func (c *T) Fatal(args ...any) // Fatalf is equivalent to Logf() followed by FailNow(). - func (c *T) Fatalf(format string, args ...interface{}) + func (c *T) Fatalf(format string, args ...any) // Log formats its arguments using default formatting, analogous ... - func (c *T) Log(args ...interface{}) + func (c *T) Log(args ...any) // Logf formats its arguments according to the format, analogous ... - func (c *T) Logf(format string, args ...interface{}) + func (c *T) Logf(format string, args ...any) // Parallel signals that this test is to be run in parallel with ... func (t *T) Parallel() @@ -262,15 +262,15 @@ TYPES failed bool // Test or benchmark has failed. start time.Time // Time test or benchmark started duration time.Duration - self interface{} // To be sent on signal channel when done. - signal chan interface{} // Output for serial tests. + self any // To be sent on signal channel when done. + signal chan any // Output for serial tests. } // Error is equivalent to Log() followed by Fail(). - func (c *common) Error(args ...interface{}) + func (c *common) Error(args ...any) // Errorf is equivalent to Logf() followed by Fail(). - func (c *common) Errorf(format string, args ...interface{}) + func (c *common) Errorf(format string, args ...any) // Fail marks the function as having failed but continues ... func (c *common) Fail() @@ -282,16 +282,16 @@ TYPES func (c *common) Failed() bool // Fatal is equivalent to Log() followed by FailNow(). - func (c *common) Fatal(args ...interface{}) + func (c *common) Fatal(args ...any) // Fatalf is equivalent to Logf() followed by FailNow(). - func (c *common) Fatalf(format string, args ...interface{}) + func (c *common) Fatalf(format string, args ...any) // Log formats its arguments using default formatting, analogous ... - func (c *common) Log(args ...interface{}) + func (c *common) Log(args ...any) // Logf formats its arguments according to the format, analogous ... - func (c *common) Logf(format string, args ...interface{}) + func (c *common) Logf(format string, args ...any) // log generates the output. It's always at the same stack depth. func (c *common) log(s string) diff --git a/src/go/doc/testdata/testing.2.golden b/src/go/doc/testdata/testing.2.golden index 83cf37cd3a..61dac8bb66 100644 --- a/src/go/doc/testdata/testing.2.golden +++ b/src/go/doc/testdata/testing.2.golden @@ -46,10 +46,10 @@ TYPES } // Error is equivalent to Log() followed by Fail(). - func (c *B) Error(args ...interface{}) + func (c *B) Error(args ...any) // Errorf is equivalent to Logf() followed by Fail(). - func (c *B) Errorf(format string, args ...interface{}) + func (c *B) Errorf(format string, args ...any) // Fail marks the function as having failed but continues ... func (c *B) Fail() @@ -61,16 +61,16 @@ TYPES func (c *B) Failed() bool // Fatal is equivalent to Log() followed by FailNow(). - func (c *B) Fatal(args ...interface{}) + func (c *B) Fatal(args ...any) // Fatalf is equivalent to Logf() followed by FailNow(). - func (c *B) Fatalf(format string, args ...interface{}) + func (c *B) Fatalf(format string, args ...any) // Log formats its arguments using default formatting, analogous ... - func (c *B) Log(args ...interface{}) + func (c *B) Log(args ...any) // Logf formats its arguments according to the format, analogous ... - func (c *B) Logf(format string, args ...interface{}) + func (c *B) Logf(format string, args ...any) // ResetTimer sets the elapsed benchmark time to zero. It does not ... func (b *B) ResetTimer() @@ -125,10 +125,10 @@ TYPES } // Error is equivalent to Log() followed by Fail(). - func (c *T) Error(args ...interface{}) + func (c *T) Error(args ...any) // Errorf is equivalent to Logf() followed by Fail(). - func (c *T) Errorf(format string, args ...interface{}) + func (c *T) Errorf(format string, args ...any) // Fail marks the function as having failed but continues ... func (c *T) Fail() @@ -140,16 +140,16 @@ TYPES func (c *T) Failed() bool // Fatal is equivalent to Log() followed by FailNow(). - func (c *T) Fatal(args ...interface{}) + func (c *T) Fatal(args ...any) // Fatalf is equivalent to Logf() followed by FailNow(). - func (c *T) Fatalf(format string, args ...interface{}) + func (c *T) Fatalf(format string, args ...any) // Log formats its arguments using default formatting, analogous ... - func (c *T) Log(args ...interface{}) + func (c *T) Log(args ...any) // Logf formats its arguments according to the format, analogous ... - func (c *T) Logf(format string, args ...interface{}) + func (c *T) Logf(format string, args ...any) // Parallel signals that this test is to be run in parallel with ... func (t *T) Parallel() diff --git a/src/go/doc/testdata/testing.go b/src/go/doc/testdata/testing.go index 52810f7a56..80238df283 100644 --- a/src/go/doc/testdata/testing.go +++ b/src/go/doc/testdata/testing.go @@ -77,8 +77,8 @@ type common struct { failed bool // Test or benchmark has failed. start time.Time // Time test or benchmark started duration time.Duration - self interface{} // To be sent on signal channel when done. - signal chan interface{} // Output for serial tests. + self any // To be sent on signal channel when done. + signal chan any // Output for serial tests. } // Short reports whether the -test.short flag is set. @@ -167,32 +167,32 @@ func (c *common) log(s string) { // Log formats its arguments using default formatting, analogous to Println(), // and records the text in the error log. -func (c *common) Log(args ...interface{}) { c.log(fmt.Sprintln(args...)) } +func (c *common) Log(args ...any) { c.log(fmt.Sprintln(args...)) } // Logf formats its arguments according to the format, analogous to Printf(), // and records the text in the error log. -func (c *common) Logf(format string, args ...interface{}) { c.log(fmt.Sprintf(format, args...)) } +func (c *common) Logf(format string, args ...any) { c.log(fmt.Sprintf(format, args...)) } // Error is equivalent to Log() followed by Fail(). -func (c *common) Error(args ...interface{}) { +func (c *common) Error(args ...any) { c.log(fmt.Sprintln(args...)) c.Fail() } // Errorf is equivalent to Logf() followed by Fail(). -func (c *common) Errorf(format string, args ...interface{}) { +func (c *common) Errorf(format string, args ...any) { c.log(fmt.Sprintf(format, args...)) c.Fail() } // Fatal is equivalent to Log() followed by FailNow(). -func (c *common) Fatal(args ...interface{}) { +func (c *common) Fatal(args ...any) { c.log(fmt.Sprintln(args...)) c.FailNow() } // Fatalf is equivalent to Logf() followed by FailNow(). -func (c *common) Fatalf(format string, args ...interface{}) { +func (c *common) Fatalf(format string, args ...any) { c.log(fmt.Sprintf(format, args...)) c.FailNow() } @@ -269,7 +269,7 @@ func RunTests(matchString func(pat, str string) (bool, error), tests []InternalT // If all tests pump to the same channel, a bug can occur where a test // kicks off a goroutine that Fails, yet the test still delivers a completion signal, // which skews the counting. - var collector = make(chan interface{}) + var collector = make(chan any) numParallel := 0 startParallel := make(chan bool) @@ -289,7 +289,7 @@ func RunTests(matchString func(pat, str string) (bool, error), tests []InternalT } t := &T{ common: common{ - signal: make(chan interface{}), + signal: make(chan any), }, name: testName, startParallel: startParallel, diff --git a/src/go/format/format.go b/src/go/format/format.go index a603d9630e..ea8dd20823 100644 --- a/src/go/format/format.go +++ b/src/go/format/format.go @@ -51,7 +51,7 @@ const parserMode = parser.ParseComments // The function may return early (before the entire result is written) // and return a formatting error, for instance due to an incorrect AST. // -func Node(dst io.Writer, fset *token.FileSet, node interface{}) error { +func Node(dst io.Writer, fset *token.FileSet, node any) error { // Determine if we have a complete source file (file != nil). var file *ast.File var cnode *printer.CommentedNode diff --git a/src/go/internal/gccgoimporter/parser.go b/src/go/internal/gccgoimporter/parser.go index 267c9953e4..48335fa6d8 100644 --- a/src/go/internal/gccgoimporter/parser.go +++ b/src/go/internal/gccgoimporter/parser.go @@ -80,7 +80,7 @@ func (e importError) Error() string { return fmt.Sprintf("import error %s (byte offset = %d): %s", e.pos, e.pos.Offset, e.err) } -func (p *parser) error(err interface{}) { +func (p *parser) error(err any) { if s, ok := err.(string); ok { err = errors.New(s) } @@ -88,7 +88,7 @@ func (p *parser) error(err interface{}) { panic(importError{p.scanner.Pos(), err.(error)}) } -func (p *parser) errorf(format string, args ...interface{}) { +func (p *parser) errorf(format string, args ...any) { p.error(fmt.Errorf(format, args...)) } @@ -474,7 +474,7 @@ func (p *parser) reserve(n int) { // used to resolve named types, or it can be a *types.Pointer, // used to resolve pointers to named types in case they are referenced // by embedded fields. -func (p *parser) update(t types.Type, nlist []interface{}) { +func (p *parser) update(t types.Type, nlist []any) { if t == reserved { p.errorf("internal error: update(%v) invoked on reserved", nlist) } @@ -509,7 +509,7 @@ func (p *parser) update(t types.Type, nlist []interface{}) { // NamedType = TypeName [ "=" ] Type { Method } . // TypeName = ExportedName . // Method = "func" "(" Param ")" Name ParamList ResultList [InlineBody] ";" . -func (p *parser) parseNamedType(nlist []interface{}) types.Type { +func (p *parser) parseNamedType(nlist []any) types.Type { pkg, name := p.parseExportedName() scope := pkg.Scope() obj := scope.Lookup(name) @@ -626,7 +626,7 @@ func (p *parser) parseInt() int { } // ArrayOrSliceType = "[" [ int ] "]" Type . -func (p *parser) parseArrayOrSliceType(pkg *types.Package, nlist []interface{}) types.Type { +func (p *parser) parseArrayOrSliceType(pkg *types.Package, nlist []any) types.Type { p.expect('[') if p.tok == ']' { p.next() @@ -649,7 +649,7 @@ func (p *parser) parseArrayOrSliceType(pkg *types.Package, nlist []interface{}) } // MapType = "map" "[" Type "]" Type . -func (p *parser) parseMapType(pkg *types.Package, nlist []interface{}) types.Type { +func (p *parser) parseMapType(pkg *types.Package, nlist []any) types.Type { p.expectKeyword("map") t := new(types.Map) @@ -665,7 +665,7 @@ func (p *parser) parseMapType(pkg *types.Package, nlist []interface{}) types.Typ } // ChanType = "chan" ["<-" | "-<"] Type . -func (p *parser) parseChanType(pkg *types.Package, nlist []interface{}) types.Type { +func (p *parser) parseChanType(pkg *types.Package, nlist []any) types.Type { p.expectKeyword("chan") t := new(types.Chan) @@ -692,7 +692,7 @@ func (p *parser) parseChanType(pkg *types.Package, nlist []interface{}) types.Ty } // StructType = "struct" "{" { Field } "}" . -func (p *parser) parseStructType(pkg *types.Package, nlist []interface{}) types.Type { +func (p *parser) parseStructType(pkg *types.Package, nlist []any) types.Type { p.expectKeyword("struct") t := new(types.Struct) @@ -759,7 +759,7 @@ func (p *parser) parseResultList(pkg *types.Package) *types.Tuple { } // FunctionType = ParamList ResultList . -func (p *parser) parseFunctionType(pkg *types.Package, nlist []interface{}) *types.Signature { +func (p *parser) parseFunctionType(pkg *types.Package, nlist []any) *types.Signature { t := new(types.Signature) p.update(t, nlist) @@ -799,7 +799,7 @@ func (p *parser) parseFunc(pkg *types.Package) *types.Func { } // InterfaceType = "interface" "{" { ("?" Type | Func) ";" } "}" . -func (p *parser) parseInterfaceType(pkg *types.Package, nlist []interface{}) types.Type { +func (p *parser) parseInterfaceType(pkg *types.Package, nlist []any) types.Type { p.expectKeyword("interface") t := new(types.Interface) @@ -828,7 +828,7 @@ func (p *parser) parseInterfaceType(pkg *types.Package, nlist []interface{}) typ } // PointerType = "*" ("any" | Type) . -func (p *parser) parsePointerType(pkg *types.Package, nlist []interface{}) types.Type { +func (p *parser) parsePointerType(pkg *types.Package, nlist []any) types.Type { p.expect('*') if p.tok == scanner.Ident { p.expectKeyword("any") @@ -846,7 +846,7 @@ func (p *parser) parsePointerType(pkg *types.Package, nlist []interface{}) types } // TypeSpec = NamedType | MapType | ChanType | StructType | InterfaceType | PointerType | ArrayOrSliceType | FunctionType . -func (p *parser) parseTypeSpec(pkg *types.Package, nlist []interface{}) types.Type { +func (p *parser) parseTypeSpec(pkg *types.Package, nlist []any) types.Type { switch p.tok { case scanner.String: return p.parseNamedType(nlist) @@ -935,14 +935,14 @@ func lookupBuiltinType(typ int) types.Type { // // parseType updates the type map to t for all type numbers n. // -func (p *parser) parseType(pkg *types.Package, n ...interface{}) types.Type { +func (p *parser) parseType(pkg *types.Package, n ...any) types.Type { p.expect('<') t, _ := p.parseTypeAfterAngle(pkg, n...) return t } // (*parser).Type after reading the "<". -func (p *parser) parseTypeAfterAngle(pkg *types.Package, n ...interface{}) (t types.Type, n1 int) { +func (p *parser) parseTypeAfterAngle(pkg *types.Package, n ...any) (t types.Type, n1 int) { p.expectKeyword("type") n1 = 0 @@ -985,7 +985,7 @@ func (p *parser) parseTypeAfterAngle(pkg *types.Package, n ...interface{}) (t ty // parseTypeExtended is identical to parseType, but if the type in // question is a saved type, returns the index as well as the type // pointer (index returned is zero if we parsed a builtin). -func (p *parser) parseTypeExtended(pkg *types.Package, n ...interface{}) (t types.Type, n1 int) { +func (p *parser) parseTypeExtended(pkg *types.Package, n ...any) (t types.Type, n1 int) { p.expect('<') t, n1 = p.parseTypeAfterAngle(pkg, n...) return @@ -1072,7 +1072,7 @@ func (p *parser) parseTypes(pkg *types.Package) { } // parseSavedType parses one saved type definition. -func (p *parser) parseSavedType(pkg *types.Package, i int, nlist []interface{}) { +func (p *parser) parseSavedType(pkg *types.Package, i int, nlist []any) { defer func(s *scanner.Scanner, tok rune, lit string) { p.scanner = s p.tok = tok diff --git a/src/go/internal/gcimporter/gcimporter_test.go b/src/go/internal/gcimporter/gcimporter_test.go index c0f4e3934b..15a7b176bb 100644 --- a/src/go/internal/gcimporter/gcimporter_test.go +++ b/src/go/internal/gcimporter/gcimporter_test.go @@ -390,7 +390,7 @@ var importedObjectTests = []struct { {"go/internal/gcimporter.FindPkg", "func FindPkg(path string, srcDir string) (filename string, id string)"}, // interfaces - {"context.Context", "type Context interface{Deadline() (deadline time.Time, ok bool); Done() <-chan struct{}; Err() error; Value(key interface{}) interface{}}"}, + {"context.Context", "type Context interface{Deadline() (deadline time.Time, ok bool); Done() <-chan struct{}; Err() error; Value(key any) any}"}, {"crypto.Decrypter", "type Decrypter interface{Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error); Public() PublicKey}"}, {"encoding.BinaryMarshaler", "type BinaryMarshaler interface{MarshalBinary() (data []byte, err error)}"}, {"io.Reader", "type Reader interface{Read(p []byte) (n int, err error)}"}, diff --git a/src/go/internal/gcimporter/support.go b/src/go/internal/gcimporter/support.go index 965e5d8838..61d1b46a68 100644 --- a/src/go/internal/gcimporter/support.go +++ b/src/go/internal/gcimporter/support.go @@ -13,7 +13,7 @@ import ( "sync" ) -func errorf(format string, args ...interface{}) { +func errorf(format string, args ...any) { panic(fmt.Sprintf(format, args...)) } diff --git a/src/go/internal/gcimporter/testdata/exports.go b/src/go/internal/gcimporter/testdata/exports.go index 91598c03e3..3d5a8c9e39 100644 --- a/src/go/internal/gcimporter/testdata/exports.go +++ b/src/go/internal/gcimporter/testdata/exports.go @@ -50,7 +50,7 @@ type ( _ *T10 } T11 map[int]string - T12 interface{} + T12 any T13 interface { m1() m2(int) float32 @@ -65,7 +65,7 @@ type ( T17 func(x int) T18 func() float32 T19 func() (x float32) - T20 func(...interface{}) + T20 func(...any) T21 struct{ next *T21 } T22 struct{ link *T23 } T23 struct{ link *T22 } @@ -86,6 +86,6 @@ func F1() {} func F2(x int) {} func F3() int { return 0 } func F4() float32 { return 0 } -func F5(a, b, c int, u, v, w struct{ x, y T1 }, more ...interface{}) (p, q, r chan<- T10) +func F5(a, b, c int, u, v, w struct{ x, y T1 }, more ...any) (p, q, r chan<- T10) func (p *T1) M1() diff --git a/src/go/parser/error_test.go b/src/go/parser/error_test.go index a45c897da3..bedfc265b5 100644 --- a/src/go/parser/error_test.go +++ b/src/go/parser/error_test.go @@ -154,7 +154,7 @@ func compareErrors(t *testing.T, fset *token.FileSet, expected map[token.Pos]str } } -func checkErrors(t *testing.T, filename string, input interface{}, mode Mode, expectErrors bool) { +func checkErrors(t *testing.T, filename string, input any, mode Mode, expectErrors bool) { t.Helper() src, err := readSource(filename, input) if err != nil { diff --git a/src/go/parser/interface.go b/src/go/parser/interface.go index 85486d2f4b..e4f8c281ea 100644 --- a/src/go/parser/interface.go +++ b/src/go/parser/interface.go @@ -22,7 +22,7 @@ import ( // otherwise it returns an error. If src == nil, readSource returns // the result of reading the file specified by filename. // -func readSource(filename string, src interface{}) ([]byte, error) { +func readSource(filename string, src any) ([]byte, error) { if src != nil { switch s := src.(type) { case string: @@ -82,7 +82,7 @@ const ( // representing the fragments of erroneous source code). Multiple errors // are returned via a scanner.ErrorList which is sorted by source position. // -func ParseFile(fset *token.FileSet, filename string, src interface{}, mode Mode) (f *ast.File, err error) { +func ParseFile(fset *token.FileSet, filename string, src any, mode Mode) (f *ast.File, err error) { if fset == nil { panic("parser.ParseFile: no token.FileSet provided (fset == nil)") } @@ -188,7 +188,7 @@ func ParseDir(fset *token.FileSet, path string, filter func(fs.FileInfo) bool, m // representing the fragments of erroneous source code). Multiple errors // are returned via a scanner.ErrorList which is sorted by source position. // -func ParseExprFrom(fset *token.FileSet, filename string, src interface{}, mode Mode) (expr ast.Expr, err error) { +func ParseExprFrom(fset *token.FileSet, filename string, src any, mode Mode) (expr ast.Expr, err error) { if fset == nil { panic("parser.ParseExprFrom: no token.FileSet provided (fset == nil)") } diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go index 7c1a8be2fa..e456e2930e 100644 --- a/src/go/parser/parser.go +++ b/src/go/parser/parser.go @@ -82,7 +82,7 @@ func (p *parser) allowTypeSets() bool { return p.mode&typeparams.DisallowTypeSet // ---------------------------------------------------------------------------- // Parsing support -func (p *parser) printTrace(a ...interface{}) { +func (p *parser) printTrace(a ...any) { const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " const n = len(dots) pos := p.file.Position(p.pos) diff --git a/src/go/parser/resolver.go b/src/go/parser/resolver.go index 54732a7fd6..910ca0689c 100644 --- a/src/go/parser/resolver.go +++ b/src/go/parser/resolver.go @@ -67,11 +67,11 @@ type resolver struct { targetStack [][]*ast.Ident // stack of unresolved labels } -func (r *resolver) dump(format string, args ...interface{}) { +func (r *resolver) dump(format string, args ...any) { fmt.Println(">>> " + r.sprintf(format, args...)) } -func (r *resolver) sprintf(format string, args ...interface{}) string { +func (r *resolver) sprintf(format string, args ...any) string { for i, arg := range args { switch arg := arg.(type) { case token.Pos: @@ -115,7 +115,7 @@ func (r *resolver) closeLabelScope() { r.labelScope = r.labelScope.Outer } -func (r *resolver) declare(decl, data interface{}, scope *ast.Scope, kind ast.ObjKind, idents ...*ast.Ident) { +func (r *resolver) declare(decl, data any, scope *ast.Scope, kind ast.ObjKind, idents ...*ast.Ident) { for _, ident := range idents { assert(ident.Obj == nil, "identifier already declared or resolved") obj := ast.NewObj(kind, ident.Name) diff --git a/src/go/printer/printer.go b/src/go/printer/printer.go index 2f41e7bf72..e4679b0021 100644 --- a/src/go/printer/printer.go +++ b/src/go/printer/printer.go @@ -104,7 +104,7 @@ func (p *printer) init(cfg *Config, fset *token.FileSet, nodeSizes map[ast.Node] p.cachedPos = -1 } -func (p *printer) internalError(msg ...interface{}) { +func (p *printer) internalError(msg ...any) { if debug { fmt.Print(p.pos.String() + ": ") fmt.Println(msg...) @@ -878,7 +878,7 @@ func mayCombine(prev token.Token, next byte) (b bool) { // space for best comment placement. Then, any leftover whitespace is // printed, followed by the actual token. // -func (p *printer) print(args ...interface{}) { +func (p *printer) print(args ...any) { for _, arg := range args { // information about the current arg var data string @@ -1075,7 +1075,7 @@ func getLastComment(n ast.Node) *ast.CommentGroup { return nil } -func (p *printer) printNode(node interface{}) error { +func (p *printer) printNode(node any) error { // unpack *CommentedNode, if any var comments []*ast.CommentGroup if cnode, ok := node.(*CommentedNode); ok { @@ -1309,7 +1309,7 @@ type Config struct { } // fprint implements Fprint and takes a nodesSizes map for setting up the printer state. -func (cfg *Config) fprint(output io.Writer, fset *token.FileSet, node interface{}, nodeSizes map[ast.Node]int) (err error) { +func (cfg *Config) fprint(output io.Writer, fset *token.FileSet, node any, nodeSizes map[ast.Node]int) (err error) { // print node var p printer p.init(cfg, fset, nodeSizes) @@ -1365,7 +1365,7 @@ func (cfg *Config) fprint(output io.Writer, fset *token.FileSet, node interface{ // It may be provided as argument to any of the Fprint functions. // type CommentedNode struct { - Node interface{} // *ast.File, or ast.Expr, ast.Decl, ast.Spec, or ast.Stmt + Node any // *ast.File, or ast.Expr, ast.Decl, ast.Spec, or ast.Stmt Comments []*ast.CommentGroup } @@ -1374,7 +1374,7 @@ type CommentedNode struct { // The node type must be *ast.File, *CommentedNode, []ast.Decl, []ast.Stmt, // or assignment-compatible to ast.Expr, ast.Decl, ast.Spec, or ast.Stmt. // -func (cfg *Config) Fprint(output io.Writer, fset *token.FileSet, node interface{}) error { +func (cfg *Config) Fprint(output io.Writer, fset *token.FileSet, node any) error { return cfg.fprint(output, fset, node, make(map[ast.Node]int)) } @@ -1383,6 +1383,6 @@ func (cfg *Config) Fprint(output io.Writer, fset *token.FileSet, node interface{ // Note that gofmt uses tabs for indentation but spaces for alignment; // use format.Node (package go/format) for output that matches gofmt. // -func Fprint(output io.Writer, fset *token.FileSet, node interface{}) error { +func Fprint(output io.Writer, fset *token.FileSet, node any) error { return (&Config{Tabwidth: 8}).Fprint(output, fset, node) } diff --git a/src/go/printer/testdata/parser.go b/src/go/printer/testdata/parser.go index fc2812adee..7e8379739c 100644 --- a/src/go/printer/testdata/parser.go +++ b/src/go/printer/testdata/parser.go @@ -122,7 +122,7 @@ func (p *parser) closeLabelScope() { p.labelScope = p.labelScope.Outer } -func (p *parser) declare(decl interface{}, scope *ast.Scope, kind ast.ObjKind, idents ...*ast.Ident) { +func (p *parser) declare(decl any, scope *ast.Scope, kind ast.ObjKind, idents ...*ast.Ident) { for _, ident := range idents { assert(ident.Obj == nil, "identifier already declared or resolved") if ident.Name != "_" { @@ -200,7 +200,7 @@ func (p *parser) resolve(x ast.Expr) { // ---------------------------------------------------------------------------- // Parsing support -func (p *parser) printTrace(a ...interface{}) { +func (p *parser) printTrace(a ...any) { const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " + ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " const n = uint(len(dots)) diff --git a/src/go/scanner/scanner.go b/src/go/scanner/scanner.go index ca4b5264cf..23d8db9d1c 100644 --- a/src/go/scanner/scanner.go +++ b/src/go/scanner/scanner.go @@ -155,7 +155,7 @@ func (s *Scanner) error(offs int, msg string) { s.ErrorCount++ } -func (s *Scanner) errorf(offs int, format string, args ...interface{}) { +func (s *Scanner) errorf(offs int, format string, args ...any) { s.error(offs, fmt.Sprintf(format, args...)) } diff --git a/src/go/token/serialize.go b/src/go/token/serialize.go index d0ea34517a..ffb69908b9 100644 --- a/src/go/token/serialize.go +++ b/src/go/token/serialize.go @@ -19,7 +19,7 @@ type serializedFileSet struct { } // Read calls decode to deserialize a file set into s; s must not be nil. -func (s *FileSet) Read(decode func(interface{}) error) error { +func (s *FileSet) Read(decode func(any) error) error { var ss serializedFileSet if err := decode(&ss); err != nil { return err @@ -47,7 +47,7 @@ func (s *FileSet) Read(decode func(interface{}) error) error { } // Write calls encode to serialize the file set s. -func (s *FileSet) Write(encode func(interface{}) error) error { +func (s *FileSet) Write(encode func(any) error) error { var ss serializedFileSet s.mutex.Lock() diff --git a/src/go/token/serialize_test.go b/src/go/token/serialize_test.go index 4e925adb6f..4aa0b0da26 100644 --- a/src/go/token/serialize_test.go +++ b/src/go/token/serialize_test.go @@ -70,7 +70,7 @@ func equal(p, q *FileSet) error { func checkSerialize(t *testing.T, p *FileSet) { var buf bytes.Buffer - encode := func(x interface{}) error { + encode := func(x any) error { return gob.NewEncoder(&buf).Encode(x) } if err := p.Write(encode); err != nil { @@ -78,7 +78,7 @@ func checkSerialize(t *testing.T, p *FileSet) { return } q := NewFileSet() - decode := func(x interface{}) error { + decode := func(x any) error { return gob.NewDecoder(&buf).Decode(x) } if err := q.Read(decode); err != nil { diff --git a/src/go/types/check.go b/src/go/types/check.go index d967c0bd25..2dd38e2e1e 100644 --- a/src/go/types/check.go +++ b/src/go/types/check.go @@ -90,7 +90,7 @@ type action struct { // If debug is set, describef sets a printf-formatted description for action a. // Otherwise, it is a no-op. -func (a *action) describef(pos positioner, format string, args ...interface{}) { +func (a *action) describef(pos positioner, format string, args ...any) { if debug { a.desc = &actionDesc{pos, format, args} } @@ -101,7 +101,7 @@ func (a *action) describef(pos positioner, format string, args ...interface{}) { type actionDesc struct { pos positioner format string - args []interface{} + args []any } // A Checker maintains the state of the type checker. diff --git a/src/go/types/conversions.go b/src/go/types/conversions.go index fb3771635d..a5b359e539 100644 --- a/src/go/types/conversions.go +++ b/src/go/types/conversions.go @@ -203,7 +203,7 @@ func (x *operand) convertibleTo(check *Checker, T Type, cause *string) bool { return false } - errorf := func(format string, args ...interface{}) { + errorf := func(format string, args ...any) { if check != nil && cause != nil { msg := check.sprintf(format, args...) if *cause != "" { diff --git a/src/go/types/errors.go b/src/go/types/errors.go index 92002add13..81c62a82f0 100644 --- a/src/go/types/errors.go +++ b/src/go/types/errors.go @@ -62,11 +62,11 @@ func (check *Checker) markImports(pkg *Package) { } } -func (check *Checker) sprintf(format string, args ...interface{}) string { +func (check *Checker) sprintf(format string, args ...any) string { return sprintf(check.fset, check.qualifier, false, format, args...) } -func sprintf(fset *token.FileSet, qf Qualifier, debug bool, format string, args ...interface{}) string { +func sprintf(fset *token.FileSet, qf Qualifier, debug bool, format string, args ...any) string { for i, arg := range args { switch a := arg.(type) { case nil: @@ -91,7 +91,7 @@ func sprintf(fset *token.FileSet, qf Qualifier, debug bool, format string, args return fmt.Sprintf(format, args...) } -func (check *Checker) trace(pos token.Pos, format string, args ...interface{}) { +func (check *Checker) trace(pos token.Pos, format string, args ...any) { fmt.Printf("%s:\t%s%s\n", check.fset.Position(pos), strings.Repeat(". ", check.indent), @@ -100,7 +100,7 @@ func (check *Checker) trace(pos token.Pos, format string, args ...interface{}) { } // dump is only needed for debugging -func (check *Checker) dump(format string, args ...interface{}) { +func (check *Checker) dump(format string, args ...any) { fmt.Println(sprintf(check.fset, check.qualifier, true, format, args...)) } @@ -170,7 +170,7 @@ func (check *Checker) newError(at positioner, code errorCode, soft bool, msg str } // newErrorf creates a new Error, but does not handle it. -func (check *Checker) newErrorf(at positioner, code errorCode, soft bool, format string, args ...interface{}) error { +func (check *Checker) newErrorf(at positioner, code errorCode, soft bool, format string, args ...any) error { msg := check.sprintf(format, args...) return check.newError(at, code, soft, msg) } @@ -179,23 +179,23 @@ func (check *Checker) error(at positioner, code errorCode, msg string) { check.err(check.newError(at, code, false, msg)) } -func (check *Checker) errorf(at positioner, code errorCode, format string, args ...interface{}) { +func (check *Checker) errorf(at positioner, code errorCode, format string, args ...any) { check.error(at, code, check.sprintf(format, args...)) } -func (check *Checker) softErrorf(at positioner, code errorCode, format string, args ...interface{}) { +func (check *Checker) softErrorf(at positioner, code errorCode, format string, args ...any) { check.err(check.newErrorf(at, code, true, format, args...)) } -func (check *Checker) invalidAST(at positioner, format string, args ...interface{}) { +func (check *Checker) invalidAST(at positioner, format string, args ...any) { check.errorf(at, 0, "invalid AST: "+format, args...) } -func (check *Checker) invalidArg(at positioner, code errorCode, format string, args ...interface{}) { +func (check *Checker) invalidArg(at positioner, code errorCode, format string, args ...any) { check.errorf(at, code, "invalid argument: "+format, args...) } -func (check *Checker) invalidOp(at positioner, code errorCode, format string, args ...interface{}) { +func (check *Checker) invalidOp(at positioner, code errorCode, format string, args ...any) { check.errorf(at, code, "invalid operation: "+format, args...) } diff --git a/src/go/types/eval_test.go b/src/go/types/eval_test.go index 345bd14305..b0745c16d9 100644 --- a/src/go/types/eval_test.go +++ b/src/go/types/eval_test.go @@ -111,7 +111,7 @@ func TestEvalPos(t *testing.T) { x = a + len(s) return float64(x) /* true => true, untyped bool */ - /* fmt.Println => , func(a ...interface{}) (n int, err error) */ + /* fmt.Println => , func(a ...any) (n int, err error) */ /* c => 3, untyped float */ /* T => , p.T */ /* a => , int */ @@ -218,7 +218,7 @@ type T []int type S struct{ X int } func f(a int, s string) S { - /* fmt.Println => func fmt.Println(a ...interface{}) (n int, err error) */ + /* fmt.Println => func fmt.Println(a ...any) (n int, err error) */ /* fmt.Stringer.String => func (fmt.Stringer).String() string */ fmt.Println("calling f") diff --git a/src/go/types/expr.go b/src/go/types/expr.go index dd18abaf13..452e9ab598 100644 --- a/src/go/types/expr.go +++ b/src/go/types/expr.go @@ -1354,7 +1354,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind { check.error(e, _InvalidTypeCycle, "illegal cycle in type declaration") goto Error } - visited := make(map[interface{}][]Type, len(e.Elts)) + visited := make(map[any][]Type, len(e.Elts)) for _, e := range e.Elts { kv, _ := e.(*ast.KeyValueExpr) if kv == nil { @@ -1542,7 +1542,7 @@ Error: return statement // avoid follow-up errors } -func keyVal(x constant.Value) interface{} { +func keyVal(x constant.Value) any { switch x.Kind() { case constant.Bool: return constant.BoolVal(x) diff --git a/src/go/types/gotype.go b/src/go/types/gotype.go index 1126b73810..5d27bb7a07 100644 --- a/src/go/types/gotype.go +++ b/src/go/types/gotype.go @@ -179,7 +179,7 @@ func report(err error) { } // parse may be called concurrently -func parse(filename string, src interface{}) (*ast.File, error) { +func parse(filename string, src any) (*ast.File, error) { if *verbose { fmt.Println(filename) } diff --git a/src/go/types/hilbert_test.go b/src/go/types/hilbert_test.go index 77954d2f8b..7d0f58ea40 100644 --- a/src/go/types/hilbert_test.go +++ b/src/go/types/hilbert_test.go @@ -84,7 +84,7 @@ type gen struct { bytes.Buffer } -func (g *gen) p(format string, args ...interface{}) { +func (g *gen) p(format string, args ...any) { fmt.Fprintf(&g.Buffer, format, args...) } diff --git a/src/go/types/initorder.go b/src/go/types/initorder.go index 27595ae233..1118b58f7b 100644 --- a/src/go/types/initorder.go +++ b/src/go/types/initorder.go @@ -304,11 +304,11 @@ func (a nodeQueue) Less(i, j int) bool { return x.ndeps < y.ndeps || x.ndeps == y.ndeps && x.obj.order() < y.obj.order() } -func (a *nodeQueue) Push(x interface{}) { +func (a *nodeQueue) Push(x any) { panic("unreachable") } -func (a *nodeQueue) Pop() interface{} { +func (a *nodeQueue) Pop() any { n := len(*a) x := (*a)[n-1] x.index = -1 // for safety diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go index e91d08cc5e..e8748975c9 100644 --- a/src/go/types/instantiate.go +++ b/src/go/types/instantiate.go @@ -164,7 +164,7 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { return nil } - errorf := func(format string, args ...interface{}) error { + errorf := func(format string, args ...any) error { return errors.New(sprintf(nil, qf, false, format, args...)) } diff --git a/src/go/types/operand.go b/src/go/types/operand.go index c35b1650be..06ecbf1410 100644 --- a/src/go/types/operand.go +++ b/src/go/types/operand.go @@ -337,7 +337,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er return false, _IncompatibleAssign } - errorf := func(format string, args ...interface{}) { + errorf := func(format string, args ...any) { if check != nil && reason != nil { msg := check.sprintf(format, args...) if *reason != "" { diff --git a/src/go/types/sizeof_test.go b/src/go/types/sizeof_test.go index 5b7ee8bb78..69571d1159 100644 --- a/src/go/types/sizeof_test.go +++ b/src/go/types/sizeof_test.go @@ -14,9 +14,9 @@ func TestSizeof(t *testing.T) { const _64bit = ^uint(0)>>32 != 0 var tests = []struct { - val interface{} // type as a value - _32bit uintptr // size on 32bit platforms - _64bit uintptr // size on 64bit platforms + val any // type as a value + _32bit uintptr // size on 32bit platforms + _64bit uintptr // size on 64bit platforms }{ // Types {Basic{}, 16, 32}, diff --git a/src/go/types/stdlib_test.go b/src/go/types/stdlib_test.go index 687b80540a..5e5e09562a 100644 --- a/src/go/types/stdlib_test.go +++ b/src/go/types/stdlib_test.go @@ -296,7 +296,7 @@ func pkgFilenames(dir string) ([]string, error) { return filenames, nil } -func walkPkgDirs(dir string, pkgh func(dir string, filenames []string), errh func(args ...interface{})) time.Duration { +func walkPkgDirs(dir string, pkgh func(dir string, filenames []string), errh func(args ...any)) time.Duration { w := walker{time.Now(), 10 * time.Millisecond, pkgh, errh} w.walk(dir) return time.Since(w.start) @@ -306,7 +306,7 @@ type walker struct { start time.Time dmax time.Duration pkgh func(dir string, filenames []string) - errh func(args ...interface{}) + errh func(args ...any) } func (w *walker) walk(dir string) { diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go index 06c9d3175d..8621d2800a 100644 --- a/src/go/types/stmt.go +++ b/src/go/types/stmt.go @@ -193,7 +193,7 @@ func (check *Checker) suspendedCall(keyword string, call *ast.CallExpr) { } // goVal returns the Go value for val, or nil. -func goVal(val constant.Value) interface{} { +func goVal(val constant.Value) any { // val should exist, but be conservative and check if val == nil { return nil @@ -227,7 +227,7 @@ func goVal(val constant.Value) interface{} { // types we need to also check the value's types (e.g., byte(1) vs myByte(1)) // when the switch expression is of interface type. type ( - valueMap map[interface{}][]valueType // underlying Go value -> valueType + valueMap map[any][]valueType // underlying Go value -> valueType valueType struct { pos token.Pos typ Type diff --git a/src/go/types/subst.go b/src/go/types/subst.go index 04eb3a6215..169540365b 100644 --- a/src/go/types/subst.go +++ b/src/go/types/subst.go @@ -156,13 +156,13 @@ func (subst *subster) typ(typ Type) Type { case *Named: // dump is for debugging - dump := func(string, ...interface{}) {} + dump := func(string, ...any) {} if subst.check != nil && trace { subst.check.indent++ defer func() { subst.check.indent-- }() - dump = func(format string, args ...interface{}) { + dump = func(format string, args ...any) { subst.check.trace(subst.pos, format, args...) } } diff --git a/src/html/template/content.go b/src/html/template/content.go index 232ba199f3..b104267177 100644 --- a/src/html/template/content.go +++ b/src/html/template/content.go @@ -112,7 +112,7 @@ const ( // indirect returns the value, after dereferencing as many times // as necessary to reach the base type (or nil). -func indirect(a interface{}) interface{} { +func indirect(a any) any { if a == nil { return nil } @@ -135,7 +135,7 @@ var ( // indirectToStringerOrError returns the value, after dereferencing as many times // as necessary to reach the base type (or nil) or an implementation of fmt.Stringer // or error, -func indirectToStringerOrError(a interface{}) interface{} { +func indirectToStringerOrError(a any) any { if a == nil { return nil } @@ -148,7 +148,7 @@ func indirectToStringerOrError(a interface{}) interface{} { // stringify converts its arguments to a string and the type of the content. // All pointers are dereferenced, as in the text/template package. -func stringify(args ...interface{}) (string, contentType) { +func stringify(args ...any) (string, contentType) { if len(args) == 1 { switch s := indirect(args[0]).(type) { case string: diff --git a/src/html/template/content_test.go b/src/html/template/content_test.go index b7a39d4814..497264ea32 100644 --- a/src/html/template/content_test.go +++ b/src/html/template/content_test.go @@ -12,7 +12,7 @@ import ( ) func TestTypedContent(t *testing.T) { - data := []interface{}{ + data := []any{ ` "foo%" O'Reilly &bar;`, CSS(`a[href =~ "//example.com"]#foo`), HTML(`Hello, World &tc!`), @@ -449,7 +449,7 @@ func TestEscapingNilNonemptyInterfaces(t *testing.T) { // A non-empty interface should print like an empty interface. want := new(bytes.Buffer) - data := struct{ E interface{} }{} + data := struct{ E any }{} tmpl.Execute(want, data) if !bytes.Equal(want.Bytes(), got.Bytes()) { diff --git a/src/html/template/css.go b/src/html/template/css.go index eb92fc92b5..890a0c6b22 100644 --- a/src/html/template/css.go +++ b/src/html/template/css.go @@ -155,7 +155,7 @@ func isCSSSpace(b byte) bool { } // cssEscaper escapes HTML and CSS special characters using \+ escapes. -func cssEscaper(args ...interface{}) string { +func cssEscaper(args ...any) string { s, _ := stringify(args...) var b strings.Builder r, w, written := rune(0), 0, 0 @@ -218,7 +218,7 @@ var mozBindingBytes = []byte("mozbinding") // (inherit, blue), and colors (#888). // It filters out unsafe values, such as those that affect token boundaries, // and anything that might execute scripts. -func cssValueFilter(args ...interface{}) string { +func cssValueFilter(args ...any) string { s, t := stringify(args...) if t == contentTypeCSS { return s diff --git a/src/html/template/error.go b/src/html/template/error.go index 0e527063ea..6bb5a2027f 100644 --- a/src/html/template/error.go +++ b/src/html/template/error.go @@ -228,6 +228,6 @@ func (e *Error) Error() string { // errorf creates an error given a format string f and args. // The template Name still needs to be supplied. -func errorf(k ErrorCode, node parse.Node, line int, f string, args ...interface{}) *Error { +func errorf(k ErrorCode, node parse.Node, line int, f string, args ...any) *Error { return &Error{k, node, "", line, fmt.Sprintf(f, args...)} } diff --git a/src/html/template/escape.go b/src/html/template/escape.go index 6dea79c7b5..2b11526f52 100644 --- a/src/html/template/escape.go +++ b/src/html/template/escape.go @@ -45,7 +45,7 @@ func escapeTemplate(tmpl *Template, node parse.Node, name string) error { // evalArgs formats the list of arguments into a string. It is equivalent to // fmt.Sprint(args...), except that it deferences all pointers. -func evalArgs(args ...interface{}) string { +func evalArgs(args ...any) string { // Optimization for simple common case of a single string argument. if len(args) == 1 { if s, ok := args[0].(string); ok { @@ -934,7 +934,7 @@ func HTMLEscapeString(s string) string { // HTMLEscaper returns the escaped HTML equivalent of the textual // representation of its arguments. -func HTMLEscaper(args ...interface{}) string { +func HTMLEscaper(args ...any) string { return template.HTMLEscaper(args...) } @@ -950,12 +950,12 @@ func JSEscapeString(s string) string { // JSEscaper returns the escaped JavaScript equivalent of the textual // representation of its arguments. -func JSEscaper(args ...interface{}) string { +func JSEscaper(args ...any) string { return template.JSEscaper(args...) } // URLQueryEscaper returns the escaped value of the textual representation of // its arguments in a form suitable for embedding in a URL query. -func URLQueryEscaper(args ...interface{}) string { +func URLQueryEscaper(args ...any) string { return template.URLQueryEscaper(args...) } diff --git a/src/html/template/escape_test.go b/src/html/template/escape_test.go index 3b0aa8c846..58f3f271b7 100644 --- a/src/html/template/escape_test.go +++ b/src/html/template/escape_test.go @@ -35,8 +35,8 @@ func TestEscape(t *testing.T) { A, E []string B, M json.Marshaler N int - U interface{} // untyped nil - Z *int // typed nil + U any // untyped nil + Z *int // typed nil W HTML }{ F: false, @@ -858,7 +858,7 @@ func TestEscapeSet(t *testing.T) { // pred is a template function that returns the predecessor of a // natural number for testing recursive templates. - fns := FuncMap{"pred": func(a ...interface{}) (interface{}, error) { + fns := FuncMap{"pred": func(a ...any) (any, error) { if len(a) == 1 { if i, _ := a[0].(int); i > 0 { return i - 1, nil @@ -1788,7 +1788,7 @@ func TestEscapeSetErrorsNotIgnorable(t *testing.T) { } func TestRedundantFuncs(t *testing.T) { - inputs := []interface{}{ + inputs := []any{ "\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f" + "\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f" + ` !"#$%&'()*+,-./` + @@ -1808,9 +1808,9 @@ func TestRedundantFuncs(t *testing.T) { } for n0, m := range redundantFuncs { - f0 := funcMap[n0].(func(...interface{}) string) + f0 := funcMap[n0].(func(...any) string) for n1 := range m { - f1 := funcMap[n1].(func(...interface{}) string) + f1 := funcMap[n1].(func(...any) string) for _, input := range inputs { want := f0(input) if got := f1(want); want != got { diff --git a/src/html/template/example_test.go b/src/html/template/example_test.go index 6cf936f270..605b25f41d 100644 --- a/src/html/template/example_test.go +++ b/src/html/template/example_test.go @@ -98,7 +98,7 @@ func Example_autoescaping() { func Example_escape() { const s = `"Fran & Freddie's Diner" ` - v := []interface{}{`"Fran & Freddie's Diner"`, ' ', ``} + v := []any{`"Fran & Freddie's Diner"`, ' ', ``} fmt.Println(template.HTMLEscapeString(s)) template.HTMLEscape(os.Stdout, []byte(s)) diff --git a/src/html/template/exec_test.go b/src/html/template/exec_test.go index 523340bac9..6cf710efab 100644 --- a/src/html/template/exec_test.go +++ b/src/html/template/exec_test.go @@ -49,7 +49,7 @@ type T struct { MSI map[string]int MSIone map[string]int // one element, for deterministic output MSIEmpty map[string]int - MXI map[interface{}]int + MXI map[any]int MII map[int]int MI32S map[int32]string MI64S map[int64]string @@ -59,11 +59,11 @@ type T struct { MUI8S map[uint8]string SMSI []map[string]int // Empty interfaces; used to see if we can dig inside one. - Empty0 interface{} // nil - Empty1 interface{} - Empty2 interface{} - Empty3 interface{} - Empty4 interface{} + Empty0 any // nil + Empty1 any + Empty2 any + Empty3 any + Empty4 any // Non-empty interfaces. NonEmptyInterface I NonEmptyInterfacePtS *I @@ -141,7 +141,7 @@ var tVal = &T{ SB: []bool{true, false}, MSI: map[string]int{"one": 1, "two": 2, "three": 3}, MSIone: map[string]int{"one": 1}, - MXI: map[interface{}]int{"one": 1}, + MXI: map[any]int{"one": 1}, MII: map[int]int{1: 1}, MI32S: map[int32]string{1: "one", 2: "two"}, MI64S: map[int64]string{2: "i642", 3: "i643"}, @@ -212,7 +212,7 @@ func (t *T) Method2(a uint16, b string) string { return fmt.Sprintf("Method2: %d %s", a, b) } -func (t *T) Method3(v interface{}) string { +func (t *T) Method3(v any) string { return fmt.Sprintf("Method3: %v", v) } @@ -252,7 +252,7 @@ func (u *U) TrueFalse(b bool) string { return "" } -func typeOf(arg interface{}) string { +func typeOf(arg any) string { return fmt.Sprintf("%T", arg) } @@ -260,7 +260,7 @@ type execTest struct { name string input string output string - data interface{} + data any ok bool } @@ -393,7 +393,7 @@ var execTests = []execTest{ {".VariadicFuncInt", "{{call .VariadicFuncInt 33 `he` `llo`}}", "33=<he+llo>", tVal, true}, {"if .BinaryFunc call", "{{ if .BinaryFunc}}{{call .BinaryFunc `1` `2`}}{{end}}", "[1=2]", tVal, true}, {"if not .BinaryFunc call", "{{ if not .BinaryFunc}}{{call .BinaryFunc `1` `2`}}{{else}}No{{end}}", "No", tVal, true}, - {"Interface Call", `{{stringer .S}}`, "foozle", map[string]interface{}{"S": bytes.NewBufferString("foozle")}, true}, + {"Interface Call", `{{stringer .S}}`, "foozle", map[string]any{"S": bytes.NewBufferString("foozle")}, true}, {".ErrFunc", "{{call .ErrFunc}}", "bla", tVal, true}, {"call nil", "{{call nil}}", "", tVal, false}, @@ -740,7 +740,7 @@ func add(args ...int) int { return sum } -func echo(arg interface{}) interface{} { +func echo(arg any) any { return arg } @@ -759,7 +759,7 @@ func stringer(s fmt.Stringer) string { return s.String() } -func mapOfThree() interface{} { +func mapOfThree() any { return map[string]int{"three": 3} } @@ -1438,7 +1438,7 @@ func TestBlock(t *testing.T) { func TestEvalFieldErrors(t *testing.T) { tests := []struct { name, src string - value interface{} + value any want string }{ { @@ -1581,7 +1581,7 @@ func TestInterfaceValues(t *testing.T) { for _, tt := range tests { tmpl := Must(New("tmpl").Parse(tt.text)) var buf bytes.Buffer - err := tmpl.Execute(&buf, map[string]interface{}{ + err := tmpl.Execute(&buf, map[string]any{ "PlusOne": func(n int) int { return n + 1 }, @@ -1610,7 +1610,7 @@ func TestInterfaceValues(t *testing.T) { // Check that panics during calls are recovered and returned as errors. func TestExecutePanicDuringCall(t *testing.T) { - funcs := map[string]interface{}{ + funcs := map[string]any{ "doPanic": func() string { panic("custom panic string") }, @@ -1618,7 +1618,7 @@ func TestExecutePanicDuringCall(t *testing.T) { tests := []struct { name string input string - data interface{} + data any wantErr string }{ { @@ -1816,7 +1816,7 @@ func TestRecursiveExecuteViaMethod(t *testing.T) { func TestTemplateFuncsAfterClone(t *testing.T) { s := `{{ f . }}` want := "test" - orig := New("orig").Funcs(map[string]interface{}{ + orig := New("orig").Funcs(map[string]any{ "f": func(in string) string { return in }, diff --git a/src/html/template/html.go b/src/html/template/html.go index 356b8298ae..19bd0ccb20 100644 --- a/src/html/template/html.go +++ b/src/html/template/html.go @@ -12,7 +12,7 @@ import ( ) // htmlNospaceEscaper escapes for inclusion in unquoted attribute values. -func htmlNospaceEscaper(args ...interface{}) string { +func htmlNospaceEscaper(args ...any) string { s, t := stringify(args...) if t == contentTypeHTML { return htmlReplacer(stripTags(s), htmlNospaceNormReplacementTable, false) @@ -21,7 +21,7 @@ func htmlNospaceEscaper(args ...interface{}) string { } // attrEscaper escapes for inclusion in quoted attribute values. -func attrEscaper(args ...interface{}) string { +func attrEscaper(args ...any) string { s, t := stringify(args...) if t == contentTypeHTML { return htmlReplacer(stripTags(s), htmlNormReplacementTable, true) @@ -30,7 +30,7 @@ func attrEscaper(args ...interface{}) string { } // rcdataEscaper escapes for inclusion in an RCDATA element body. -func rcdataEscaper(args ...interface{}) string { +func rcdataEscaper(args ...any) string { s, t := stringify(args...) if t == contentTypeHTML { return htmlReplacer(s, htmlNormReplacementTable, true) @@ -39,7 +39,7 @@ func rcdataEscaper(args ...interface{}) string { } // htmlEscaper escapes for inclusion in HTML text. -func htmlEscaper(args ...interface{}) string { +func htmlEscaper(args ...any) string { s, t := stringify(args...) if t == contentTypeHTML { return s @@ -225,7 +225,7 @@ func stripTags(html string) string { // htmlNameFilter accepts valid parts of an HTML attribute or tag name or // a known-safe HTML attribute. -func htmlNameFilter(args ...interface{}) string { +func htmlNameFilter(args ...any) string { s, t := stringify(args...) if t == contentTypeHTMLAttr { return s @@ -260,6 +260,6 @@ func htmlNameFilter(args ...interface{}) string { // content interpolated into comments. // This approach is equally valid whether or not static comment content is // removed from the template. -func commentEscaper(args ...interface{}) string { +func commentEscaper(args ...any) string { return "" } diff --git a/src/html/template/js.go b/src/html/template/js.go index 7e919c48e6..50523d00f1 100644 --- a/src/html/template/js.go +++ b/src/html/template/js.go @@ -122,7 +122,7 @@ var jsonMarshalType = reflect.TypeOf((*json.Marshaler)(nil)).Elem() // indirectToJSONMarshaler returns the value, after dereferencing as many times // as necessary to reach the base type (or nil) or an implementation of json.Marshal. -func indirectToJSONMarshaler(a interface{}) interface{} { +func indirectToJSONMarshaler(a any) any { // text/template now supports passing untyped nil as a func call // argument, so we must support it. Otherwise we'd panic below, as one // cannot call the Type or Interface methods on an invalid @@ -140,8 +140,8 @@ func indirectToJSONMarshaler(a interface{}) interface{} { // jsValEscaper escapes its inputs to a JS Expression (section 11.14) that has // neither side-effects nor free variables outside (NaN, Infinity). -func jsValEscaper(args ...interface{}) string { - var a interface{} +func jsValEscaper(args ...any) string { + var a any if len(args) == 1 { a = indirectToJSONMarshaler(args[0]) switch t := a.(type) { @@ -224,7 +224,7 @@ func jsValEscaper(args ...interface{}) string { // jsStrEscaper produces a string that can be included between quotes in // JavaScript source, in JavaScript embedded in an HTML5 ", "-->"}, `["\u003c!--","\u003c/script\u003e","--\u003e"]`}, {"", `"--\u003e"`}, @@ -158,7 +158,7 @@ func TestJSValEscaper(t *testing.T) { } // Make sure that escaping corner cases are not broken // by nesting. - a := []interface{}{test.x} + a := []any{test.x} want := "[" + strings.TrimSpace(test.js) + "]" if js := jsValEscaper(a); js != want { t.Errorf("%+v: want\n\t%q\ngot\n\t%q", a, want, js) @@ -168,7 +168,7 @@ func TestJSValEscaper(t *testing.T) { func TestJSStrEscaper(t *testing.T) { tests := []struct { - x interface{} + x any esc string }{ {"", ``}, @@ -223,7 +223,7 @@ func TestJSStrEscaper(t *testing.T) { func TestJSRegexpEscaper(t *testing.T) { tests := []struct { - x interface{} + x any esc string }{ {"", `(?:)`}, @@ -278,7 +278,7 @@ func TestEscapersOnLower7AndSelectHighCodepoints(t *testing.T) { tests := []struct { name string - escaper func(...interface{}) string + escaper func(...any) string escaped string }{ { diff --git a/src/html/template/template.go b/src/html/template/template.go index 69312d36fd..7eba716f1b 100644 --- a/src/html/template/template.go +++ b/src/html/template/template.go @@ -117,7 +117,7 @@ func (t *Template) escape() error { // the output writer. // A template may be executed safely in parallel, although if parallel // executions share a Writer the output may be interleaved. -func (t *Template) Execute(wr io.Writer, data interface{}) error { +func (t *Template) Execute(wr io.Writer, data any) error { if err := t.escape(); err != nil { return err } @@ -131,7 +131,7 @@ func (t *Template) Execute(wr io.Writer, data interface{}) error { // the output writer. // A template may be executed safely in parallel, although if parallel // executions share a Writer the output may be interleaved. -func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error { +func (t *Template) ExecuteTemplate(wr io.Writer, name string, data any) error { tmpl, err := t.lookupAndEscapeTemplate(name) if err != nil { return err @@ -335,7 +335,7 @@ func (t *Template) Name() string { // terminates and Execute returns that error. FuncMap has the same base type // as FuncMap in "text/template", copied here so clients need not import // "text/template". -type FuncMap map[string]interface{} +type FuncMap map[string]any // Funcs adds the elements of the argument map to the template's function map. // It must be called before the template is parsed. @@ -486,7 +486,7 @@ func parseGlob(t *Template, pattern string) (*Template, error) { // IsTrue reports whether the value is 'true', in the sense of not the zero of its type, // and whether the value has a meaningful truth value. This is the definition of // truth used by if and other such actions. -func IsTrue(val interface{}) (truth, ok bool) { +func IsTrue(val any) (truth, ok bool) { return template.IsTrue(val) } diff --git a/src/html/template/template_test.go b/src/html/template/template_test.go index 1f2c888bbe..99a1091c77 100644 --- a/src/html/template/template_test.go +++ b/src/html/template/template_test.go @@ -206,7 +206,7 @@ func (c *testCase) mustNotParse(t *Template, text string) { } } -func (c *testCase) mustExecute(t *Template, val interface{}, want string) { +func (c *testCase) mustExecute(t *Template, val any, want string) { var buf bytes.Buffer err := t.Execute(&buf, val) if err != nil { diff --git a/src/html/template/url.go b/src/html/template/url.go index 4b39fddf07..93905586a2 100644 --- a/src/html/template/url.go +++ b/src/html/template/url.go @@ -32,7 +32,7 @@ import ( // To allow URLs containing other schemes to bypass this filter, developers must // explicitly indicate that such a URL is expected and safe by encapsulating it // in a template.URL value. -func urlFilter(args ...interface{}) string { +func urlFilter(args ...any) string { s, t := stringify(args...) if t == contentTypeURL { return s @@ -56,7 +56,7 @@ func isSafeURL(s string) bool { // urlEscaper produces an output that can be embedded in a URL query. // The output can be embedded in an HTML attribute without further escaping. -func urlEscaper(args ...interface{}) string { +func urlEscaper(args ...any) string { return urlProcessor(false, args...) } @@ -65,13 +65,13 @@ func urlEscaper(args ...interface{}) string { // The normalizer does not encode all HTML specials. Specifically, it does not // encode '&' so correct embedding in an HTML attribute requires escaping of // '&' to '&'. -func urlNormalizer(args ...interface{}) string { +func urlNormalizer(args ...any) string { return urlProcessor(true, args...) } // urlProcessor normalizes (when norm is true) or escapes its input to produce // a valid hierarchical or opaque URL part. -func urlProcessor(norm bool, args ...interface{}) string { +func urlProcessor(norm bool, args ...any) string { s, t := stringify(args...) if t == contentTypeURL { norm = true @@ -141,7 +141,7 @@ func processURLOnto(s string, norm bool, b *bytes.Buffer) bool { // Filters and normalizes srcset values which are comma separated // URLs followed by metadata. -func srcsetFilterAndEscaper(args ...interface{}) string { +func srcsetFilterAndEscaper(args ...any) string { s, t := stringify(args...) switch t { case contentTypeSrcset: diff --git a/src/html/template/url_test.go b/src/html/template/url_test.go index 75c354eba8..a04f39cdff 100644 --- a/src/html/template/url_test.go +++ b/src/html/template/url_test.go @@ -48,7 +48,7 @@ func TestURLFilters(t *testing.T) { tests := []struct { name string - escaper func(...interface{}) string + escaper func(...any) string escaped string }{ { diff --git a/src/image/draw/draw_test.go b/src/image/draw/draw_test.go index 77f1c5c2c2..3be93962ad 100644 --- a/src/image/draw/draw_test.go +++ b/src/image/draw/draw_test.go @@ -84,7 +84,7 @@ func convertToSlowestRGBA(m image.Image) *slowestRGBA { } func init() { - var p interface{} = (*slowestRGBA)(nil) + var p any = (*slowestRGBA)(nil) if _, ok := p.(RGBA64Image); ok { panic("slowestRGBA should not be an RGBA64Image") } @@ -173,7 +173,7 @@ func convertToSlowerRGBA(m image.Image) *slowerRGBA { } func init() { - var p interface{} = (*slowerRGBA)(nil) + var p any = (*slowerRGBA)(nil) if _, ok := p.(RGBA64Image); !ok { panic("slowerRGBA should be an RGBA64Image") } diff --git a/src/internal/abi/abi.go b/src/internal/abi/abi.go index b266a7ff78..11acac346f 100644 --- a/src/internal/abi/abi.go +++ b/src/internal/abi/abi.go @@ -114,7 +114,7 @@ func (b *IntArgRegBitmap) Get(i int) bool { // compile-time error. // // Implemented as a compile intrinsic. -func FuncPCABI0(f interface{}) uintptr +func FuncPCABI0(f any) uintptr // FuncPCABIInternal returns the entry PC of the function f. If f is a // direct reference of a function, it must be defined as ABIInternal. @@ -123,4 +123,4 @@ func FuncPCABI0(f interface{}) uintptr // the behavior is undefined. // // Implemented as a compile intrinsic. -func FuncPCABIInternal(f interface{}) uintptr +func FuncPCABIInternal(f any) uintptr diff --git a/src/internal/fmtsort/sort_test.go b/src/internal/fmtsort/sort_test.go index ab063af5ba..11befca6f1 100644 --- a/src/internal/fmtsort/sort_test.go +++ b/src/internal/fmtsort/sort_test.go @@ -38,12 +38,12 @@ var compareTests = [][]reflect.Value{ ct(reflect.TypeOf(chans[0]), chans[0], chans[1], chans[2]), ct(reflect.TypeOf(toy{}), toy{0, 1}, toy{0, 2}, toy{1, -1}, toy{1, 1}), ct(reflect.TypeOf([2]int{}), [2]int{1, 1}, [2]int{1, 2}, [2]int{2, 0}), - ct(reflect.TypeOf(interface{}(interface{}(0))), iFace, 1, 2, 3), + ct(reflect.TypeOf(any(any(0))), iFace, 1, 2, 3), } -var iFace interface{} +var iFace any -func ct(typ reflect.Type, args ...interface{}) []reflect.Value { +func ct(typ reflect.Type, args ...any) []reflect.Value { value := make([]reflect.Value, len(args)) for i, v := range args { x := reflect.ValueOf(v) @@ -84,8 +84,8 @@ func TestCompare(t *testing.T) { } type sortTest struct { - data interface{} // Always a map. - print string // Printed result using our custom printer. + data any // Always a map. + print string // Printed result using our custom printer. } var sortTests = []sortTest{ @@ -135,7 +135,7 @@ var sortTests = []sortTest{ }, } -func sprint(data interface{}) string { +func sprint(data any) string { om := fmtsort.Sort(reflect.ValueOf(data)) if om == nil { return "nil" @@ -244,7 +244,7 @@ func TestInterface(t *testing.T) { // A map containing multiple concrete types should be sorted by type, // then value. However, the relative ordering of types is unspecified, // so test this by checking the presence of sorted subgroups. - m := map[interface{}]string{ + m := map[any]string{ [2]int{1, 0}: "", [2]int{0, 1}: "", true: "", diff --git a/src/internal/fuzz/encoding.go b/src/internal/fuzz/encoding.go index d3f24c3e6c..2bfa02b8c0 100644 --- a/src/internal/fuzz/encoding.go +++ b/src/internal/fuzz/encoding.go @@ -18,7 +18,7 @@ var encVersion1 = "go test fuzz v1" // marshalCorpusFile encodes an arbitrary number of arguments into the file format for the // corpus. -func marshalCorpusFile(vals ...interface{}) []byte { +func marshalCorpusFile(vals ...any) []byte { if len(vals) == 0 { panic("must have at least one value to marshal") } @@ -45,7 +45,7 @@ func marshalCorpusFile(vals ...interface{}) []byte { } // unmarshalCorpusFile decodes corpus bytes into their respective values. -func unmarshalCorpusFile(b []byte) ([]interface{}, error) { +func unmarshalCorpusFile(b []byte) ([]any, error) { if len(b) == 0 { return nil, fmt.Errorf("cannot unmarshal empty string") } @@ -56,7 +56,7 @@ func unmarshalCorpusFile(b []byte) ([]interface{}, error) { if string(lines[0]) != encVersion1 { return nil, fmt.Errorf("unknown encoding version: %s", lines[0]) } - var vals []interface{} + var vals []any for _, line := range lines[1:] { line = bytes.TrimSpace(line) if len(line) == 0 { @@ -71,7 +71,7 @@ func unmarshalCorpusFile(b []byte) ([]interface{}, error) { return vals, nil } -func parseCorpusValue(line []byte) (interface{}, error) { +func parseCorpusValue(line []byte) (any, error) { fs := token.NewFileSet() expr, err := parser.ParseExprFrom(fs, "(test)", line, 0) if err != nil { @@ -197,7 +197,7 @@ func parseCorpusValue(line []byte) (interface{}, error) { } // parseInt returns an integer of value val and type typ. -func parseInt(val, typ string) (interface{}, error) { +func parseInt(val, typ string) (any, error) { switch typ { case "int": return strconv.Atoi(val) @@ -218,7 +218,7 @@ func parseInt(val, typ string) (interface{}, error) { } // parseInt returns an unsigned integer of value val and type typ. -func parseUint(val, typ string) (interface{}, error) { +func parseUint(val, typ string) (any, error) { switch typ { case "uint": i, err := strconv.ParseUint(val, 10, 0) diff --git a/src/internal/fuzz/fuzz.go b/src/internal/fuzz/fuzz.go index cb739232c7..b3f1381dbb 100644 --- a/src/internal/fuzz/fuzz.go +++ b/src/internal/fuzz/fuzz.go @@ -455,7 +455,7 @@ type CorpusEntry = struct { Data []byte // Values is the unmarshaled values from a corpus file. - Values []interface{} + Values []any Generation int @@ -684,7 +684,7 @@ func newCoordinator(opts CoordinateFuzzingOpts) (*coordinator, error) { if len(c.corpus.entries) == 0 { fmt.Fprintf(c.opts.Log, "warning: starting with empty corpus\n") - var vals []interface{} + var vals []any for _, t := range opts.Types { vals = append(vals, zeroValue(t)) } @@ -968,7 +968,7 @@ func ReadCorpus(dir string, types []reflect.Type) ([]CorpusEntry, error) { if err != nil { return nil, fmt.Errorf("failed to read corpus file: %v", err) } - var vals []interface{} + var vals []any vals, err = readCorpusData(data, types) if err != nil { errs = append(errs, fmt.Errorf("%q: %v", filename, err)) @@ -982,7 +982,7 @@ func ReadCorpus(dir string, types []reflect.Type) ([]CorpusEntry, error) { return corpus, nil } -func readCorpusData(data []byte, types []reflect.Type) ([]interface{}, error) { +func readCorpusData(data []byte, types []reflect.Type) ([]any, error) { vals, err := unmarshalCorpusFile(data) if err != nil { return nil, fmt.Errorf("unmarshal: %v", err) @@ -995,7 +995,7 @@ func readCorpusData(data []byte, types []reflect.Type) ([]interface{}, error) { // CheckCorpus verifies that the types in vals match the expected types // provided. -func CheckCorpus(vals []interface{}, types []reflect.Type) error { +func CheckCorpus(vals []any, types []reflect.Type) error { if len(vals) != len(types) { return fmt.Errorf("wrong number of values in corpus entry: %d, want %d", len(vals), len(types)) } @@ -1032,7 +1032,7 @@ func testName(path string) string { return filepath.Base(path) } -func zeroValue(t reflect.Type) interface{} { +func zeroValue(t reflect.Type) any { for _, v := range zeroVals { if reflect.TypeOf(v) == t { return v @@ -1041,7 +1041,7 @@ func zeroValue(t reflect.Type) interface{} { panic(fmt.Sprintf("unsupported type: %v", t)) } -var zeroVals []interface{} = []interface{}{ +var zeroVals []any = []any{ []byte(""), string(""), false, diff --git a/src/internal/fuzz/minimize_test.go b/src/internal/fuzz/minimize_test.go index f9041d1d34..6e5f3184b4 100644 --- a/src/internal/fuzz/minimize_test.go +++ b/src/internal/fuzz/minimize_test.go @@ -22,8 +22,8 @@ func TestMinimizeInput(t *testing.T) { type testcase struct { name string fn func(CorpusEntry) error - input []interface{} - expected []interface{} + input []any + expected []any } cases := []testcase{ { @@ -41,8 +41,8 @@ func TestMinimizeInput(t *testing.T) { } return nil }, - input: []interface{}{[]byte{0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, - expected: []interface{}{[]byte{1, 1, 1}}, + input: []any{[]byte{0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}, + expected: []any{[]byte{1, 1, 1}}, }, { name: "single_bytes", @@ -56,8 +56,8 @@ func TestMinimizeInput(t *testing.T) { } return fmt.Errorf("bad %v", e.Values[0]) }, - input: []interface{}{[]byte{1, 2, 3, 4, 5}}, - expected: []interface{}{[]byte("00")}, + input: []any{[]byte{1, 2, 3, 4, 5}}, + expected: []any{[]byte("00")}, }, { name: "set_of_bytes", @@ -71,8 +71,8 @@ func TestMinimizeInput(t *testing.T) { } return nil }, - input: []interface{}{[]byte{0, 1, 2, 3, 4, 5}}, - expected: []interface{}{[]byte{0, 4, 5}}, + input: []any{[]byte{0, 1, 2, 3, 4, 5}}, + expected: []any{[]byte{0, 4, 5}}, }, { name: "non_ascii_bytes", @@ -83,8 +83,8 @@ func TestMinimizeInput(t *testing.T) { } return nil }, - input: []interface{}{[]byte("ท")}, // ท is 3 bytes - expected: []interface{}{[]byte("000")}, + input: []any{[]byte("ท")}, // ท is 3 bytes + expected: []any{[]byte("000")}, }, { name: "ones_string", @@ -101,8 +101,8 @@ func TestMinimizeInput(t *testing.T) { } return nil }, - input: []interface{}{"001010001000000000000000000"}, - expected: []interface{}{"111"}, + input: []any{"001010001000000000000000000"}, + expected: []any{"111"}, }, { name: "string_length", @@ -113,8 +113,8 @@ func TestMinimizeInput(t *testing.T) { } return nil }, - input: []interface{}{"zzzzz"}, - expected: []interface{}{"00000"}, + input: []any{"zzzzz"}, + expected: []any{"00000"}, }, { name: "string_with_letter", @@ -126,8 +126,8 @@ func TestMinimizeInput(t *testing.T) { } return nil }, - input: []interface{}{"ZZZZZ"}, - expected: []interface{}{"A"}, + input: []any{"ZZZZZ"}, + expected: []any{"A"}, }, } @@ -167,7 +167,7 @@ func TestMinimizeFlaky(t *testing.T) { return time.Second, errors.New("ohno") }} mem := &sharedMem{region: make([]byte, 100)} // big enough to hold value and header - vals := []interface{}{[]byte(nil)} + vals := []any{[]byte(nil)} args := minimizeArgs{KeepCoverage: make([]byte, len(coverageSnapshot))} success, err := ws.minimizeInput(context.Background(), vals, mem, args) if success { diff --git a/src/internal/fuzz/mutator.go b/src/internal/fuzz/mutator.go index a3161c04ea..e26ae5a583 100644 --- a/src/internal/fuzz/mutator.go +++ b/src/internal/fuzz/mutator.go @@ -53,7 +53,7 @@ func min(a, b int) int { } // mutate performs several mutations on the provided values. -func (m *mutator) mutate(vals []interface{}, maxBytes int) { +func (m *mutator) mutate(vals []any, maxBytes int) { // TODO(katiehockman): pull some of these functions into helper methods and // test that each case is working as expected. // TODO(katiehockman): perform more types of mutations for []byte. diff --git a/src/internal/fuzz/mutator_test.go b/src/internal/fuzz/mutator_test.go index d8015ce213..cea7e2e3be 100644 --- a/src/internal/fuzz/mutator_test.go +++ b/src/internal/fuzz/mutator_test.go @@ -34,7 +34,7 @@ func BenchmarkMutatorBytes(b *testing.B) { // resize buffer to the correct shape and reset the PCG buf = buf[0:size] m.r = newPcgRand() - m.mutate([]interface{}{buf}, workerSharedMemSize) + m.mutate([]any{buf}, workerSharedMemSize) } }) } @@ -62,7 +62,7 @@ func BenchmarkMutatorString(b *testing.B) { // resize buffer to the correct shape and reset the PCG buf = buf[0:size] m.r = newPcgRand() - m.mutate([]interface{}{string(buf)}, workerSharedMemSize) + m.mutate([]any{string(buf)}, workerSharedMemSize) } }) } @@ -74,7 +74,7 @@ func BenchmarkMutatorAllBasicTypes(b *testing.B) { os.Setenv("GODEBUG", fmt.Sprintf("%s,fuzzseed=123", origEnv)) m := newMutator() - types := []interface{}{ + types := []any{ []byte(""), string(""), false, @@ -95,14 +95,14 @@ func BenchmarkMutatorAllBasicTypes(b *testing.B) { b.Run(fmt.Sprintf("%T", t), func(b *testing.B) { for i := 0; i < b.N; i++ { m.r = newPcgRand() - m.mutate([]interface{}{t}, workerSharedMemSize) + m.mutate([]any{t}, workerSharedMemSize) } }) } } func TestStringImmutability(t *testing.T) { - v := []interface{}{"hello"} + v := []any{"hello"} m := newMutator() m.mutate(v, 1024) original := v[0].(string) diff --git a/src/internal/fuzz/queue.go b/src/internal/fuzz/queue.go index cf67a28ba7..42a8379541 100644 --- a/src/internal/fuzz/queue.go +++ b/src/internal/fuzz/queue.go @@ -16,7 +16,7 @@ type queue struct { // The queue is empty when begin = end. // The queue is full (until grow is called) when end = begin + N - 1 (mod N) // where N = cap(elems). - elems []interface{} + elems []any head, len int } @@ -30,7 +30,7 @@ func (q *queue) grow() { if newCap == 0 { newCap = 8 } - newElems := make([]interface{}, newCap) + newElems := make([]any, newCap) oldLen := q.len for i := 0; i < oldLen; i++ { newElems[i] = q.elems[(q.head+i)%oldCap] @@ -39,7 +39,7 @@ func (q *queue) grow() { q.head = 0 } -func (q *queue) enqueue(e interface{}) { +func (q *queue) enqueue(e any) { if q.len+1 > q.cap() { q.grow() } @@ -48,7 +48,7 @@ func (q *queue) enqueue(e interface{}) { q.len++ } -func (q *queue) dequeue() (interface{}, bool) { +func (q *queue) dequeue() (any, bool) { if q.len == 0 { return nil, false } @@ -59,7 +59,7 @@ func (q *queue) dequeue() (interface{}, bool) { return e, true } -func (q *queue) peek() (interface{}, bool) { +func (q *queue) peek() (any, bool) { if q.len == 0 { return nil, false } diff --git a/src/internal/fuzz/worker.go b/src/internal/fuzz/worker.go index c39804cad1..c2d553240c 100644 --- a/src/internal/fuzz/worker.go +++ b/src/internal/fuzz/worker.go @@ -654,7 +654,7 @@ func (ws *workerServer) serve(ctx context.Context) error { } } - var resp interface{} + var resp any switch { case c.Fuzz != nil: resp = ws.fuzz(ctx, *c.Fuzz) @@ -726,7 +726,7 @@ func (ws *workerServer) fuzz(ctx context.Context, args fuzzArgs) (resp fuzzRespo resp.InternalErr = err.Error() return resp } - vals := make([]interface{}, len(originalVals)) + vals := make([]any, len(originalVals)) copy(vals, originalVals) shouldStop := func() bool { @@ -827,7 +827,7 @@ func (ws *workerServer) minimize(ctx context.Context, args minimizeArgs) (resp m // coverage, in fuzzFn. It uses the context to determine how long to run, // stopping once closed. It returns a bool indicating whether minimization was // successful and an error if one was found. -func (ws *workerServer) minimizeInput(ctx context.Context, vals []interface{}, mem *sharedMem, args minimizeArgs) (success bool, retErr error) { +func (ws *workerServer) minimizeInput(ctx context.Context, vals []any, mem *sharedMem, args minimizeArgs) (success bool, retErr error) { keepCoverage := args.KeepCoverage memBytes := mem.valueRef() bPtr := &memBytes @@ -900,7 +900,7 @@ func (ws *workerServer) minimizeInput(ctx context.Context, vals []interface{}, m return true, retErr } -func writeToMem(vals []interface{}, mem *sharedMem) { +func writeToMem(vals []any, mem *sharedMem) { b := marshalCorpusFile(vals...) mem.setValue(b) } @@ -1127,7 +1127,7 @@ func (wc *workerClient) ping(ctx context.Context) error { // callLocked sends an RPC from the coordinator to the worker process and waits // for the response. The callLocked may be cancelled with ctx. -func (wc *workerClient) callLocked(ctx context.Context, c call, resp interface{}) (err error) { +func (wc *workerClient) callLocked(ctx context.Context, c call, resp any) (err error) { enc := json.NewEncoder(wc.fuzzIn) dec := json.NewDecoder(&contextReader{ctx: ctx, r: wc.fuzzOut}) if err := enc.Encode(c); err != nil { diff --git a/src/internal/fuzz/worker_test.go b/src/internal/fuzz/worker_test.go index e2ecf0a9c3..d0b21da783 100644 --- a/src/internal/fuzz/worker_test.go +++ b/src/internal/fuzz/worker_test.go @@ -53,7 +53,7 @@ func BenchmarkWorkerFuzzOverhead(b *testing.B) { } }() - initialVal := []interface{}{make([]byte, 32)} + initialVal := []any{make([]byte, 32)} encodedVals := marshalCorpusFile(initialVal...) mem.setValue(encodedVals) @@ -92,7 +92,7 @@ func BenchmarkWorkerFuzz(b *testing.B) { } b.SetParallelism(1) w := newWorkerForTest(b) - entry := CorpusEntry{Values: []interface{}{[]byte(nil)}} + entry := CorpusEntry{Values: []any{[]byte(nil)}} entry.Data = marshalCorpusFile(entry.Values...) for i := int64(0); i < int64(b.N); { args := fuzzArgs{ @@ -183,7 +183,7 @@ func BenchmarkWorkerMinimize(b *testing.B) { ctx := context.Background() for sz := 1; sz <= len(bytes); sz <<= 1 { sz := sz - input := []interface{}{bytes[:sz]} + input := []any{bytes[:sz]} encodedVals := marshalCorpusFile(input...) mem = <-ws.memMu mem.setValue(encodedVals) diff --git a/src/internal/intern/intern.go b/src/internal/intern/intern.go index 666caa6d2f..75641106ab 100644 --- a/src/internal/intern/intern.go +++ b/src/internal/intern/intern.go @@ -21,7 +21,7 @@ import ( // See func Get for how Value pointers may be used. type Value struct { _ [0]func() // prevent people from accidentally using value type as comparable - cmpVal interface{} + cmpVal any // resurrected is guarded by mu (for all instances of Value). // It is set true whenever v is synthesized from a uintptr. resurrected bool @@ -29,21 +29,21 @@ type Value struct { // Get returns the comparable value passed to the Get func // that returned v. -func (v *Value) Get() interface{} { return v.cmpVal } +func (v *Value) Get() any { return v.cmpVal } // key is a key in our global value map. // It contains type-specialized fields to avoid allocations // when converting common types to empty interfaces. type key struct { s string - cmpVal interface{} + cmpVal any // isString reports whether key contains a string. // Without it, the zero value of key is ambiguous. isString bool } // keyFor returns a key to use with cmpVal. -func keyFor(cmpVal interface{}) key { +func keyFor(cmpVal any) key { if s, ok := cmpVal.(string); ok { return key{s: s, isString: true} } @@ -79,7 +79,7 @@ func safeMap() map[key]*Value { // // The returned pointer will be the same for Get(v) and Get(v2) // if and only if v == v2, and can be used as a map key. -func Get(cmpVal interface{}) *Value { +func Get(cmpVal any) *Value { return get(keyFor(cmpVal)) } diff --git a/src/internal/lazytemplate/lazytemplate.go b/src/internal/lazytemplate/lazytemplate.go index c83eaeaf3e..8eeed5a527 100644 --- a/src/internal/lazytemplate/lazytemplate.go +++ b/src/internal/lazytemplate/lazytemplate.go @@ -33,7 +33,7 @@ func (r *Template) build() { r.name, r.text = "", "" } -func (r *Template) Execute(w io.Writer, data interface{}) error { +func (r *Template) Execute(w io.Writer, data any) error { return r.tp().Execute(w, data) } diff --git a/src/internal/nettrace/nettrace.go b/src/internal/nettrace/nettrace.go index de3254df58..94f38a71ee 100644 --- a/src/internal/nettrace/nettrace.go +++ b/src/internal/nettrace/nettrace.go @@ -30,7 +30,7 @@ type Trace struct { // The coalesced parameter is whether singleflight de-dupped // the call. The addrs are of type net.IPAddr but can't // actually be for circular dependency reasons. - DNSDone func(netIPs []interface{}, coalesced bool, err error) + DNSDone func(netIPs []any, coalesced bool, err error) // ConnectStart is called before a Dial, excluding Dials made // during DNS lookups. In the case of DualStack (Happy Eyeballs) diff --git a/src/internal/poll/splice_linux.go b/src/internal/poll/splice_linux.go index 2d87c3d023..43eec04a71 100644 --- a/src/internal/poll/splice_linux.go +++ b/src/internal/poll/splice_linux.go @@ -173,7 +173,7 @@ type splicePipe struct { // a finalizer for each pipe to close its file descriptors before the actual GC. var splicePipePool = sync.Pool{New: newPoolPipe} -func newPoolPipe() interface{} { +func newPoolPipe() any { // Discard the error which occurred during the creation of pipe buffer, // redirecting the data transmission to the conventional way utilizing read() + write() as a fallback. p := newPipe() diff --git a/src/internal/poll/splice_linux_test.go b/src/internal/poll/splice_linux_test.go index 8c4363886e..29bcaab414 100644 --- a/src/internal/poll/splice_linux_test.go +++ b/src/internal/poll/splice_linux_test.go @@ -73,7 +73,7 @@ func TestSplicePipePool(t *testing.T) { // Detect whether all pipes are closed properly. var leakedFDs []int - pendingFDs.Range(func(k, v interface{}) bool { + pendingFDs.Range(func(k, v any) bool { leakedFDs = append(leakedFDs, k.(int)) return true }) diff --git a/src/internal/reflectlite/all_test.go b/src/internal/reflectlite/all_test.go index e15f364fcd..ea750831ef 100644 --- a/src/internal/reflectlite/all_test.go +++ b/src/internal/reflectlite/all_test.go @@ -32,7 +32,7 @@ type T struct { } type pair struct { - i interface{} + i any s string } @@ -421,7 +421,7 @@ func TestAll(t *testing.T) { func TestInterfaceValue(t *testing.T) { var inter struct { - E interface{} + E any } inter.E = 123.456 v1 := ValueOf(&inter) @@ -437,7 +437,7 @@ func TestInterfaceValue(t *testing.T) { } func TestFunctionValue(t *testing.T) { - var x interface{} = func() {} + var x any = func() {} v := ValueOf(x) if fmt.Sprint(ToInterface(v)) != fmt.Sprint(x) { t.Fatalf("TestFunction returned wrong pointer") @@ -496,7 +496,7 @@ type Basic struct { type NotBasic Basic type DeepEqualTest struct { - a, b interface{} + a, b any eq bool } @@ -510,7 +510,7 @@ var ( type self struct{} type Loop *Loop -type Loopy interface{} +type Loopy any var loop1, loop2 Loop var loopy1, loopy2 Loopy @@ -578,7 +578,7 @@ var typeOfTests = []DeepEqualTest{ {int32(1), int64(1), false}, {0.5, "hello", false}, {[]int{1, 2, 3}, [3]int{1, 2, 3}, false}, - {&[3]interface{}{1, 2, 4}, &[3]interface{}{1, 2, "s"}, false}, + {&[3]any{1, 2, 4}, &[3]any{1, 2, "s"}, false}, {Basic{1, 0.5}, NotBasic{1, 0.5}, false}, {map[uint]string{1: "one", 2: "two"}, map[int]string{2: "two", 1: "one"}, false}, @@ -606,14 +606,14 @@ func TestTypeOf(t *testing.T) { } } -func Nil(a interface{}, t *testing.T) { +func Nil(a any, t *testing.T) { n := Field(ValueOf(a), 0) if !n.IsNil() { t.Errorf("%v should be nil", a) } } -func NotNil(a interface{}, t *testing.T) { +func NotNil(a any, t *testing.T) { n := Field(ValueOf(a), 0) if n.IsNil() { t.Errorf("value of type %v should not be nil", TypeString(ValueOf(a).Type())) @@ -623,9 +623,9 @@ func NotNil(a interface{}, t *testing.T) { func TestIsNil(t *testing.T) { // These implement IsNil. // Wrap in extra struct to hide interface type. - doNil := []interface{}{ + doNil := []any{ struct{ x *int }{}, - struct{ x interface{} }{}, + struct{ x any }{}, struct{ x map[string]int }{}, struct{ x func() bool }{}, struct{ x chan int }{}, @@ -668,7 +668,7 @@ func TestIsNil(t *testing.T) { NotNil(mi, t) var ii struct { - x interface{} + x any } Nil(ii, t) ii.x = 2 @@ -770,7 +770,7 @@ func TestImportPath(t *testing.T) { {TypeOf([]byte(nil)), ""}, {TypeOf([]rune(nil)), ""}, {TypeOf(string("")), ""}, - {TypeOf((*interface{})(nil)).Elem(), ""}, + {TypeOf((*any)(nil)).Elem(), ""}, {TypeOf((*byte)(nil)), ""}, {TypeOf((*rune)(nil)), ""}, {TypeOf((*int64)(nil)), ""}, @@ -805,7 +805,7 @@ func noAlloc(t *testing.T, n int, f func(int)) { func TestAllocations(t *testing.T) { noAlloc(t, 100, func(j int) { - var i interface{} + var i any var v Value // We can uncomment this when compiler escape analysis @@ -939,7 +939,7 @@ func TestBigZero(t *testing.T) { func TestInvalid(t *testing.T) { // Used to have inconsistency between IsValid() and Kind() != Invalid. - type T struct{ v interface{} } + type T struct{ v any } v := Field(ValueOf(T{}), 0) if v.IsValid() != true || v.Kind() != Interface { @@ -954,7 +954,7 @@ func TestInvalid(t *testing.T) { type TheNameOfThisTypeIsExactly255BytesLongSoWhenTheCompilerPrependsTheReflectTestPackageNameAndExtraStarTheLinkerRuntimeAndReflectPackagesWillHaveToCorrectlyDecodeTheSecondLengthByte0123456789_0123456789_0123456789_0123456789_0123456789_012345678 int type nameTest struct { - v interface{} + v any want string } @@ -966,7 +966,7 @@ var nameTests = []nameTest{ {(*func() D1)(nil), ""}, {(*<-chan D1)(nil), ""}, {(*chan<- D1)(nil), ""}, - {(*interface{})(nil), ""}, + {(*any)(nil), ""}, {(*interface { F() })(nil), ""}, diff --git a/src/internal/reflectlite/export_test.go b/src/internal/reflectlite/export_test.go index 354ea9dbd0..adae229e92 100644 --- a/src/internal/reflectlite/export_test.go +++ b/src/internal/reflectlite/export_test.go @@ -81,7 +81,7 @@ func Zero(typ Type) Value { // var i interface{} = (v's underlying value) // It panics if the Value was obtained by accessing // unexported struct fields. -func ToInterface(v Value) (i interface{}) { +func ToInterface(v Value) (i any) { return valueInterface(v) } diff --git a/src/internal/reflectlite/set_test.go b/src/internal/reflectlite/set_test.go index a610499d08..ca7ea9b0bc 100644 --- a/src/internal/reflectlite/set_test.go +++ b/src/internal/reflectlite/set_test.go @@ -26,8 +26,8 @@ func TestImplicitSetConversion(t *testing.T) { } var implementsTests = []struct { - x interface{} - t interface{} + x any + t any b bool }{ {new(*bytes.Buffer), new(io.Reader), true}, @@ -73,8 +73,8 @@ func TestImplements(t *testing.T) { } var assignableTests = []struct { - x interface{} - t interface{} + x any + t any b bool }{ {new(chan int), new(<-chan int), true}, @@ -82,13 +82,13 @@ var assignableTests = []struct { {new(*int), new(IntPtr), true}, {new(IntPtr), new(*int), true}, {new(IntPtr), new(IntPtr1), false}, - {new(Ch), new(<-chan interface{}), true}, + {new(Ch), new(<-chan any), true}, // test runs implementsTests too } type IntPtr *int type IntPtr1 *int -type Ch <-chan interface{} +type Ch <-chan any func TestAssignableTo(t *testing.T) { for i, tt := range append(assignableTests, implementsTests...) { diff --git a/src/internal/reflectlite/swapper.go b/src/internal/reflectlite/swapper.go index ac081d49bb..fc402bb38a 100644 --- a/src/internal/reflectlite/swapper.go +++ b/src/internal/reflectlite/swapper.go @@ -14,7 +14,7 @@ import ( // slice. // // Swapper panics if the provided interface is not a slice. -func Swapper(slice interface{}) func(i, j int) { +func Swapper(slice any) func(i, j int) { v := ValueOf(slice) if v.Kind() != Slice { panic(&ValueError{Method: "Swapper", Kind: v.Kind()}) diff --git a/src/internal/reflectlite/type.go b/src/internal/reflectlite/type.go index fdf1584a27..8f649600d2 100644 --- a/src/internal/reflectlite/type.go +++ b/src/internal/reflectlite/type.go @@ -707,7 +707,7 @@ func (t *interfaceType) NumMethod() int { return len(t.methods) } // TypeOf returns the reflection Type that represents the dynamic type of i. // If i is a nil interface value, TypeOf returns nil. -func TypeOf(i interface{}) Type { +func TypeOf(i any) Type { eface := *(*emptyInterface)(unsafe.Pointer(&i)) return toType(eface.typ) } diff --git a/src/internal/reflectlite/value.go b/src/internal/reflectlite/value.go index 0734069255..966230f581 100644 --- a/src/internal/reflectlite/value.go +++ b/src/internal/reflectlite/value.go @@ -99,9 +99,9 @@ func (v Value) pointer() unsafe.Pointer { } // packEface converts v to the empty interface. -func packEface(v Value) interface{} { +func packEface(v Value) any { t := v.typ - var i interface{} + var i any e := (*emptyInterface)(unsafe.Pointer(&i)) // First, fill in the data portion of the interface. switch { @@ -136,7 +136,7 @@ func packEface(v Value) interface{} { } // unpackEface converts the empty interface i to a Value. -func unpackEface(i interface{}) Value { +func unpackEface(i any) Value { e := (*emptyInterface)(unsafe.Pointer(&i)) // NOTE: don't read e.word until we know whether it is really a pointer or not. t := e.typ @@ -226,11 +226,11 @@ func (v Value) Elem() Value { k := v.kind() switch k { case Interface: - var eface interface{} + var eface any if v.typ.NumMethod() == 0 { - eface = *(*interface{})(v.ptr) + eface = *(*any)(v.ptr) } else { - eface = (interface{})(*(*interface { + eface = (any)(*(*interface { M() })(v.ptr)) } @@ -257,7 +257,7 @@ func (v Value) Elem() Value { panic(&ValueError{"reflectlite.Value.Elem", v.kind()}) } -func valueInterface(v Value) interface{} { +func valueInterface(v Value) any { if v.flag == 0 { panic(&ValueError{"reflectlite.Value.Interface", 0}) } @@ -267,7 +267,7 @@ func valueInterface(v Value) interface{} { // Empty interface has one layout, all interfaces with // methods have a second layout. if v.numMethod() == 0 { - return *(*interface{})(v.ptr) + return *(*any)(v.ptr) } return *(*interface { M() @@ -391,7 +391,7 @@ func unsafe_New(*rtype) unsafe.Pointer // ValueOf returns a new Value initialized to the concrete value // stored in the interface i. ValueOf(nil) returns the zero Value. -func ValueOf(i interface{}) Value { +func ValueOf(i any) Value { if i == nil { return Value{} } @@ -433,7 +433,7 @@ func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value } x := valueInterface(v) if dst.NumMethod() == 0 { - *(*interface{})(target) = x + *(*any)(target) = x } else { ifaceE2I(dst, x, target) } @@ -455,7 +455,7 @@ func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Po return add(p, uintptr(i)*eltSize, "i < len") } -func ifaceE2I(t *rtype, src interface{}, dst unsafe.Pointer) +func ifaceE2I(t *rtype, src any, dst unsafe.Pointer) // typedmemmove copies a value of type t to dst from src. //go:noescape @@ -464,7 +464,7 @@ func typedmemmove(t *rtype, dst, src unsafe.Pointer) // Dummy annotation marking that the value x escapes, // for use in cases where the reflect code is so clever that // the compiler cannot follow. -func escapes(x interface{}) { +func escapes(x any) { if dummy.b { dummy.x = x } @@ -472,5 +472,5 @@ func escapes(x interface{}) { var dummy struct { b bool - x interface{} + x any } diff --git a/src/internal/singleflight/singleflight.go b/src/internal/singleflight/singleflight.go index b2d82e26c2..07b3f40ec0 100644 --- a/src/internal/singleflight/singleflight.go +++ b/src/internal/singleflight/singleflight.go @@ -14,7 +14,7 @@ type call struct { // These fields are written once before the WaitGroup is done // and are only read after the WaitGroup is done. - val interface{} + val any err error // These fields are read and written with the singleflight @@ -34,7 +34,7 @@ type Group struct { // Result holds the results of Do, so they can be passed // on a channel. type Result struct { - Val interface{} + Val any Err error Shared bool } @@ -44,7 +44,7 @@ type Result struct { // time. If a duplicate comes in, the duplicate caller waits for the // original to complete and receives the same results. // The return value shared indicates whether v was given to multiple callers. -func (g *Group) Do(key string, fn func() (interface{}, error)) (v interface{}, err error, shared bool) { +func (g *Group) Do(key string, fn func() (any, error)) (v any, err error, shared bool) { g.mu.Lock() if g.m == nil { g.m = make(map[string]*call) @@ -68,7 +68,7 @@ func (g *Group) Do(key string, fn func() (interface{}, error)) (v interface{}, e // results when they are ready. The second result is true if the function // will eventually be called, false if it will not (because there is // a pending request with this key). -func (g *Group) DoChan(key string, fn func() (interface{}, error)) (<-chan Result, bool) { +func (g *Group) DoChan(key string, fn func() (any, error)) (<-chan Result, bool) { ch := make(chan Result, 1) g.mu.Lock() if g.m == nil { @@ -91,7 +91,7 @@ func (g *Group) DoChan(key string, fn func() (interface{}, error)) (<-chan Resul } // doCall handles the single call for a key. -func (g *Group) doCall(c *call, key string, fn func() (interface{}, error)) { +func (g *Group) doCall(c *call, key string, fn func() (any, error)) { c.val, c.err = fn() c.wg.Done() diff --git a/src/internal/singleflight/singleflight_test.go b/src/internal/singleflight/singleflight_test.go index 6404a1775a..c2310375f7 100644 --- a/src/internal/singleflight/singleflight_test.go +++ b/src/internal/singleflight/singleflight_test.go @@ -15,7 +15,7 @@ import ( func TestDo(t *testing.T) { var g Group - v, err, _ := g.Do("key", func() (interface{}, error) { + v, err, _ := g.Do("key", func() (any, error) { return "bar", nil }) if got, want := fmt.Sprintf("%v (%T)", v, v), "bar (string)"; got != want { @@ -29,7 +29,7 @@ func TestDo(t *testing.T) { func TestDoErr(t *testing.T) { var g Group someErr := errors.New("some error") - v, err, _ := g.Do("key", func() (interface{}, error) { + v, err, _ := g.Do("key", func() (any, error) { return nil, someErr }) if err != someErr { @@ -45,7 +45,7 @@ func TestDoDupSuppress(t *testing.T) { var wg1, wg2 sync.WaitGroup c := make(chan string, 1) var calls int32 - fn := func() (interface{}, error) { + fn := func() (any, error) { if atomic.AddInt32(&calls, 1) == 1 { // First invocation. wg1.Done() diff --git a/src/internal/syscall/windows/registry/registry_test.go b/src/internal/syscall/windows/registry/registry_test.go index 134b5450fc..278b0b4911 100644 --- a/src/internal/syscall/windows/registry/registry_test.go +++ b/src/internal/syscall/windows/registry/registry_test.go @@ -118,7 +118,7 @@ func equalStringSlice(a, b []string) bool { type ValueTest struct { Type uint32 Name string - Value interface{} + Value any WillFail bool } diff --git a/src/internal/trace/gc.go b/src/internal/trace/gc.go index cc19fdf891..c1bc862340 100644 --- a/src/internal/trace/gc.go +++ b/src/internal/trace/gc.go @@ -352,11 +352,11 @@ func (h bandUtilHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } -func (h *bandUtilHeap) Push(x interface{}) { +func (h *bandUtilHeap) Push(x any) { *h = append(*h, x.(bandUtil)) } -func (h *bandUtilHeap) Pop() interface{} { +func (h *bandUtilHeap) Pop() any { x := (*h)[len(*h)-1] *h = (*h)[:len(*h)-1] return x @@ -386,11 +386,11 @@ func (h utilHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] } -func (h *utilHeap) Push(x interface{}) { +func (h *utilHeap) Push(x any) { *h = append(*h, x.(UtilWindow)) } -func (h *utilHeap) Pop() interface{} { +func (h *utilHeap) Pop() any { x := (*h)[len(*h)-1] *h = (*h)[:len(*h)-1] return x diff --git a/src/internal/unsafeheader/unsafeheader_test.go b/src/internal/unsafeheader/unsafeheader_test.go index 6fb7cca888..f3d1a9bb68 100644 --- a/src/internal/unsafeheader/unsafeheader_test.go +++ b/src/internal/unsafeheader/unsafeheader_test.go @@ -25,7 +25,7 @@ func TestTypeMatchesReflectType(t *testing.T) { }) } -func testHeaderMatchesReflect(t *testing.T, header, reflectHeader interface{}) { +func testHeaderMatchesReflect(t *testing.T, header, reflectHeader any) { h := reflect.TypeOf(header) rh := reflect.TypeOf(reflectHeader) diff --git a/src/io/fs/fs.go b/src/io/fs/fs.go index e603afadb0..5c0d9a6664 100644 --- a/src/io/fs/fs.go +++ b/src/io/fs/fs.go @@ -153,7 +153,7 @@ type FileInfo interface { Mode() FileMode // file mode bits ModTime() time.Time // modification time IsDir() bool // abbreviation for Mode().IsDir() - Sys() interface{} // underlying data source (can return nil) + Sys() any // underlying data source (can return nil) } // A FileMode represents a file's mode and permission bits. diff --git a/src/io/io.go b/src/io/io.go index 5635392dfb..1ea01d5d63 100644 --- a/src/io/io.go +++ b/src/io/io.go @@ -597,7 +597,7 @@ func (discard) WriteString(s string) (int, error) { } var blackHolePool = sync.Pool{ - New: func() interface{} { + New: func() any { b := make([]byte, 8192) return &b }, diff --git a/src/log/log.go b/src/log/log.go index 3172384718..5e79b19522 100644 --- a/src/log/log.go +++ b/src/log/log.go @@ -198,7 +198,7 @@ func (l *Logger) Output(calldepth int, s string) error { // Printf calls l.Output to print to the logger. // Arguments are handled in the manner of fmt.Printf. -func (l *Logger) Printf(format string, v ...interface{}) { +func (l *Logger) Printf(format string, v ...any) { if atomic.LoadInt32(&l.isDiscard) != 0 { return } @@ -207,7 +207,7 @@ func (l *Logger) Printf(format string, v ...interface{}) { // Print calls l.Output to print to the logger. // Arguments are handled in the manner of fmt.Print. -func (l *Logger) Print(v ...interface{}) { +func (l *Logger) Print(v ...any) { if atomic.LoadInt32(&l.isDiscard) != 0 { return } @@ -216,7 +216,7 @@ func (l *Logger) Print(v ...interface{}) { // Println calls l.Output to print to the logger. // Arguments are handled in the manner of fmt.Println. -func (l *Logger) Println(v ...interface{}) { +func (l *Logger) Println(v ...any) { if atomic.LoadInt32(&l.isDiscard) != 0 { return } @@ -224,39 +224,39 @@ func (l *Logger) Println(v ...interface{}) { } // Fatal is equivalent to l.Print() followed by a call to os.Exit(1). -func (l *Logger) Fatal(v ...interface{}) { +func (l *Logger) Fatal(v ...any) { l.Output(2, fmt.Sprint(v...)) os.Exit(1) } // Fatalf is equivalent to l.Printf() followed by a call to os.Exit(1). -func (l *Logger) Fatalf(format string, v ...interface{}) { +func (l *Logger) Fatalf(format string, v ...any) { l.Output(2, fmt.Sprintf(format, v...)) os.Exit(1) } // Fatalln is equivalent to l.Println() followed by a call to os.Exit(1). -func (l *Logger) Fatalln(v ...interface{}) { +func (l *Logger) Fatalln(v ...any) { l.Output(2, fmt.Sprintln(v...)) os.Exit(1) } // Panic is equivalent to l.Print() followed by a call to panic(). -func (l *Logger) Panic(v ...interface{}) { +func (l *Logger) Panic(v ...any) { s := fmt.Sprint(v...) l.Output(2, s) panic(s) } // Panicf is equivalent to l.Printf() followed by a call to panic(). -func (l *Logger) Panicf(format string, v ...interface{}) { +func (l *Logger) Panicf(format string, v ...any) { s := fmt.Sprintf(format, v...) l.Output(2, s) panic(s) } // Panicln is equivalent to l.Println() followed by a call to panic(). -func (l *Logger) Panicln(v ...interface{}) { +func (l *Logger) Panicln(v ...any) { s := fmt.Sprintln(v...) l.Output(2, s) panic(s) @@ -335,7 +335,7 @@ func Writer() io.Writer { // Print calls Output to print to the standard logger. // Arguments are handled in the manner of fmt.Print. -func Print(v ...interface{}) { +func Print(v ...any) { if atomic.LoadInt32(&std.isDiscard) != 0 { return } @@ -344,7 +344,7 @@ func Print(v ...interface{}) { // Printf calls Output to print to the standard logger. // Arguments are handled in the manner of fmt.Printf. -func Printf(format string, v ...interface{}) { +func Printf(format string, v ...any) { if atomic.LoadInt32(&std.isDiscard) != 0 { return } @@ -353,7 +353,7 @@ func Printf(format string, v ...interface{}) { // Println calls Output to print to the standard logger. // Arguments are handled in the manner of fmt.Println. -func Println(v ...interface{}) { +func Println(v ...any) { if atomic.LoadInt32(&std.isDiscard) != 0 { return } @@ -361,39 +361,39 @@ func Println(v ...interface{}) { } // Fatal is equivalent to Print() followed by a call to os.Exit(1). -func Fatal(v ...interface{}) { +func Fatal(v ...any) { std.Output(2, fmt.Sprint(v...)) os.Exit(1) } // Fatalf is equivalent to Printf() followed by a call to os.Exit(1). -func Fatalf(format string, v ...interface{}) { +func Fatalf(format string, v ...any) { std.Output(2, fmt.Sprintf(format, v...)) os.Exit(1) } // Fatalln is equivalent to Println() followed by a call to os.Exit(1). -func Fatalln(v ...interface{}) { +func Fatalln(v ...any) { std.Output(2, fmt.Sprintln(v...)) os.Exit(1) } // Panic is equivalent to Print() followed by a call to panic(). -func Panic(v ...interface{}) { +func Panic(v ...any) { s := fmt.Sprint(v...) std.Output(2, s) panic(s) } // Panicf is equivalent to Printf() followed by a call to panic(). -func Panicf(format string, v ...interface{}) { +func Panicf(format string, v ...any) { s := fmt.Sprintf(format, v...) std.Output(2, s) panic(s) } // Panicln is equivalent to Println() followed by a call to panic(). -func Panicln(v ...interface{}) { +func Panicln(v ...any) { s := fmt.Sprintln(v...) std.Output(2, s) panic(s) diff --git a/src/math/all_test.go b/src/math/all_test.go index 55c805e199..c11d823233 100644 --- a/src/math/all_test.go +++ b/src/math/all_test.go @@ -3175,7 +3175,7 @@ func TestTrigReduce(t *testing.T) { // https://golang.org/issue/201 type floatTest struct { - val interface{} + val any name string str string } diff --git a/src/math/big/floatconv_test.go b/src/math/big/floatconv_test.go index 3aa6834143..a1cc38a459 100644 --- a/src/math/big/floatconv_test.go +++ b/src/math/big/floatconv_test.go @@ -576,7 +576,7 @@ func TestFloatText(t *testing.T) { func TestFloatFormat(t *testing.T) { for _, test := range []struct { format string - value interface{} // float32, float64, or string (== 512bit *Float) + value any // float32, float64, or string (== 512bit *Float) want string }{ // from fmt/fmt_test.go diff --git a/src/math/bits/make_examples.go b/src/math/bits/make_examples.go index ac4004df41..92e9aabfb5 100644 --- a/src/math/bits/make_examples.go +++ b/src/math/bits/make_examples.go @@ -37,44 +37,44 @@ func main() { for _, e := range []struct { name string in int - out [4]interface{} - out2 [4]interface{} + out [4]any + out2 [4]any }{ { name: "LeadingZeros", in: 1, - out: [4]interface{}{bits.LeadingZeros8(1), bits.LeadingZeros16(1), bits.LeadingZeros32(1), bits.LeadingZeros64(1)}, + out: [4]any{bits.LeadingZeros8(1), bits.LeadingZeros16(1), bits.LeadingZeros32(1), bits.LeadingZeros64(1)}, }, { name: "TrailingZeros", in: 14, - out: [4]interface{}{bits.TrailingZeros8(14), bits.TrailingZeros16(14), bits.TrailingZeros32(14), bits.TrailingZeros64(14)}, + out: [4]any{bits.TrailingZeros8(14), bits.TrailingZeros16(14), bits.TrailingZeros32(14), bits.TrailingZeros64(14)}, }, { name: "OnesCount", in: 14, - out: [4]interface{}{bits.OnesCount8(14), bits.OnesCount16(14), bits.OnesCount32(14), bits.OnesCount64(14)}, + out: [4]any{bits.OnesCount8(14), bits.OnesCount16(14), bits.OnesCount32(14), bits.OnesCount64(14)}, }, { name: "RotateLeft", in: 15, - out: [4]interface{}{bits.RotateLeft8(15, 2), bits.RotateLeft16(15, 2), bits.RotateLeft32(15, 2), bits.RotateLeft64(15, 2)}, - out2: [4]interface{}{bits.RotateLeft8(15, -2), bits.RotateLeft16(15, -2), bits.RotateLeft32(15, -2), bits.RotateLeft64(15, -2)}, + out: [4]any{bits.RotateLeft8(15, 2), bits.RotateLeft16(15, 2), bits.RotateLeft32(15, 2), bits.RotateLeft64(15, 2)}, + out2: [4]any{bits.RotateLeft8(15, -2), bits.RotateLeft16(15, -2), bits.RotateLeft32(15, -2), bits.RotateLeft64(15, -2)}, }, { name: "Reverse", in: 19, - out: [4]interface{}{bits.Reverse8(19), bits.Reverse16(19), bits.Reverse32(19), bits.Reverse64(19)}, + out: [4]any{bits.Reverse8(19), bits.Reverse16(19), bits.Reverse32(19), bits.Reverse64(19)}, }, { name: "ReverseBytes", in: 15, - out: [4]interface{}{nil, bits.ReverseBytes16(15), bits.ReverseBytes32(15), bits.ReverseBytes64(15)}, + out: [4]any{nil, bits.ReverseBytes16(15), bits.ReverseBytes32(15), bits.ReverseBytes64(15)}, }, { name: "Len", in: 8, - out: [4]interface{}{bits.Len8(8), bits.Len16(8), bits.Len32(8), bits.Len64(8)}, + out: [4]any{bits.Len8(8), bits.Len16(8), bits.Len32(8), bits.Len64(8)}, }, } { for i, size := range []int{8, 16, 32, 64} { diff --git a/src/math/rand/example_test.go b/src/math/rand/example_test.go index 4107613555..f691e39d64 100644 --- a/src/math/rand/example_test.go +++ b/src/math/rand/example_test.go @@ -57,7 +57,7 @@ func Example_rand() { // The tabwriter here helps us generate aligned output. w := tabwriter.NewWriter(os.Stdout, 1, 1, 1, ' ', 0) defer w.Flush() - show := func(name string, v1, v2, v3 interface{}) { + show := func(name string, v1, v2, v3 any) { fmt.Fprintf(w, "%s\t%v\t%v\t%v\n", name, v1, v2, v3) } diff --git a/src/math/rand/regress_test.go b/src/math/rand/regress_test.go index 1f30be85d1..813098ec9c 100644 --- a/src/math/rand/regress_test.go +++ b/src/math/rand/regress_test.go @@ -46,7 +46,7 @@ func TestRegress(t *testing.T) { var args []reflect.Value var argstr string if mt.NumIn() == 1 { - var x interface{} + var x any switch mt.In(0).Kind() { default: t.Fatalf("unexpected argument type for r.%s", m.Name) @@ -83,7 +83,7 @@ func TestRegress(t *testing.T) { args = append(args, reflect.ValueOf(x)) } - var out interface{} + var out any out = mv.Call(args)[0].Interface() if m.Name == "Int" || m.Name == "Intn" { out = int64(out.(int)) @@ -120,7 +120,7 @@ func TestRegress(t *testing.T) { } } -var regressGolden = []interface{}{ +var regressGolden = []any{ float64(4.668112973579268), // ExpFloat64() float64(0.1601593871172866), // ExpFloat64() float64(3.0465834105636), // ExpFloat64() diff --git a/src/mime/quotedprintable/reader_test.go b/src/mime/quotedprintable/reader_test.go index 48a7ff6495..19e9fea19b 100644 --- a/src/mime/quotedprintable/reader_test.go +++ b/src/mime/quotedprintable/reader_test.go @@ -22,7 +22,7 @@ import ( func TestReader(t *testing.T) { tests := []struct { in, want string - err interface{} + err any }{ {in: "", want: ""}, {in: "foo bar", want: "foo bar"}, @@ -160,7 +160,7 @@ func TestExhaustive(t *testing.T) { if err != nil { panic(err) } - qpres := make(chan interface{}, 2) + qpres := make(chan any, 2) go func() { br := bufio.NewReader(stderr) s, _ := br.ReadString('\n') diff --git a/src/mime/type.go b/src/mime/type.go index 26424339af..bdb8bb319a 100644 --- a/src/mime/type.go +++ b/src/mime/type.go @@ -23,7 +23,7 @@ var ( ) func clearSyncMap(m *sync.Map) { - m.Range(func(k, _ interface{}) bool { + m.Range(func(k, _ any) bool { m.Delete(k) return true }) diff --git a/src/net/http/cgi/host.go b/src/net/http/cgi/host.go index e7124a2ab0..95b2e13e4e 100644 --- a/src/net/http/cgi/host.go +++ b/src/net/http/cgi/host.go @@ -350,7 +350,7 @@ func (h *Handler) ServeHTTP(rw http.ResponseWriter, req *http.Request) { } } -func (h *Handler) printf(format string, v ...interface{}) { +func (h *Handler) printf(format string, v ...any) { if h.Logger != nil { h.Logger.Printf(format, v...) } else { diff --git a/src/net/http/client_test.go b/src/net/http/client_test.go index 62bf9342f4..c2ea6f4330 100644 --- a/src/net/http/client_test.go +++ b/src/net/http/client_test.go @@ -745,7 +745,7 @@ func (j *RecordingJar) Cookies(u *url.URL) []*Cookie { return nil } -func (j *RecordingJar) logf(format string, args ...interface{}) { +func (j *RecordingJar) logf(format string, args ...any) { j.mu.Lock() defer j.mu.Unlock() fmt.Fprintf(&j.log, format, args...) diff --git a/src/net/http/clientserver_test.go b/src/net/http/clientserver_test.go index 125d63566b..71b2a32cb4 100644 --- a/src/net/http/clientserver_test.go +++ b/src/net/http/clientserver_test.go @@ -81,7 +81,7 @@ func optWithServerLog(lg *log.Logger) func(*httptest.Server) { } } -func newClientServerTest(t *testing.T, h2 bool, h Handler, opts ...interface{}) *clientServerTest { +func newClientServerTest(t *testing.T, h2 bool, h Handler, opts ...any) *clientServerTest { if h2 { CondSkipHTTP2(t) } @@ -189,7 +189,7 @@ type h12Compare struct { ReqFunc reqFunc // optional CheckResponse func(proto string, res *Response) // optional EarlyCheckResponse func(proto string, res *Response) // optional; pre-normalize - Opts []interface{} + Opts []any } func (tt h12Compare) reqFunc() reqFunc { @@ -441,7 +441,7 @@ func TestH12_AutoGzip(t *testing.T) { func TestH12_AutoGzip_Disabled(t *testing.T) { h12Compare{ - Opts: []interface{}{ + Opts: []any{ func(tr *Transport) { tr.DisableCompression = true }, }, Handler: func(w ResponseWriter, r *Request) { @@ -1168,7 +1168,7 @@ func TestInterruptWithPanic_ErrAbortHandler_h1(t *testing.T) { func TestInterruptWithPanic_ErrAbortHandler_h2(t *testing.T) { testInterruptWithPanic(t, h2Mode, ErrAbortHandler) } -func testInterruptWithPanic(t *testing.T, h2 bool, panicValue interface{}) { +func testInterruptWithPanic(t *testing.T, h2 bool, panicValue any) { setParallel(t) const msg = "hello" defer afterTest(t) @@ -1518,7 +1518,7 @@ func TestBidiStreamReverseProxy(t *testing.T) { })) defer proxy.close() - bodyRes := make(chan interface{}, 1) // error or hash.Hash + bodyRes := make(chan any, 1) // error or hash.Hash pr, pw := io.Pipe() req, _ := NewRequest("PUT", proxy.ts.URL, pr) const size = 4 << 20 diff --git a/src/net/http/cookie_test.go b/src/net/http/cookie_test.go index 257dc57420..ccc5f98091 100644 --- a/src/net/http/cookie_test.go +++ b/src/net/http/cookie_test.go @@ -360,7 +360,7 @@ var readSetCookiesTests = []struct { // Header{"Set-Cookie": {"ASP.NET_SessionId=foo; path=/; HttpOnly, .ASPXAUTH=7E3AA; expires=Wed, 07-Mar-2012 14:25:06 GMT; path=/; HttpOnly"}}, } -func toJSON(v interface{}) string { +func toJSON(v any) string { b, err := json.Marshal(v) if err != nil { return fmt.Sprintf("%#v", v) diff --git a/src/net/http/fs_test.go b/src/net/http/fs_test.go index b42ade1e8a..4b01cce72d 100644 --- a/src/net/http/fs_test.go +++ b/src/net/http/fs_test.go @@ -658,7 +658,7 @@ type fakeFileInfo struct { } func (f *fakeFileInfo) Name() string { return f.basename } -func (f *fakeFileInfo) Sys() interface{} { return nil } +func (f *fakeFileInfo) Sys() any { return nil } func (f *fakeFileInfo) ModTime() time.Time { return f.modtime } func (f *fakeFileInfo) IsDir() bool { return f.dir } func (f *fakeFileInfo) Size() int64 { return int64(len(f.contents)) } diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go index bb82f24585..83b6d29144 100644 --- a/src/net/http/h2_bundle.go +++ b/src/net/http/h2_bundle.go @@ -1049,11 +1049,11 @@ var ( 16 << 10, } http2dataChunkPools = [...]sync.Pool{ - {New: func() interface{} { return make([]byte, 1<<10) }}, - {New: func() interface{} { return make([]byte, 2<<10) }}, - {New: func() interface{} { return make([]byte, 4<<10) }}, - {New: func() interface{} { return make([]byte, 8<<10) }}, - {New: func() interface{} { return make([]byte, 16<<10) }}, + {New: func() any { return make([]byte, 1<<10) }}, + {New: func() any { return make([]byte, 2<<10) }}, + {New: func() any { return make([]byte, 4<<10) }}, + {New: func() any { return make([]byte, 8<<10) }}, + {New: func() any { return make([]byte, 16<<10) }}, } ) @@ -1548,7 +1548,7 @@ func (h *http2FrameHeader) invalidate() { h.valid = false } // frame header bytes. // Used only by ReadFrameHeader. var http2fhBytes = sync.Pool{ - New: func() interface{} { + New: func() any { buf := make([]byte, http2frameHeaderLen) return &buf }, @@ -1655,8 +1655,8 @@ type http2Framer struct { debugFramer *http2Framer // only use for logging written writes debugFramerBuf *bytes.Buffer - debugReadLoggerf func(string, ...interface{}) - debugWriteLoggerf func(string, ...interface{}) + debugReadLoggerf func(string, ...any) + debugWriteLoggerf func(string, ...any) frameCache *http2frameCache // nil if frames aren't reused (default) } @@ -3061,7 +3061,7 @@ func http2curGoroutineID() uint64 { } var http2littleBuf = sync.Pool{ - New: func() interface{} { + New: func() any { buf := make([]byte, 64) return &buf }, @@ -3468,7 +3468,7 @@ func http2newBufferedWriter(w io.Writer) *http2bufferedWriter { const http2bufWriterPoolBufferSize = 4 << 10 var http2bufWriterPool = sync.Pool{ - New: func() interface{} { + New: func() any { return bufio.NewWriterSize(nil, http2bufWriterPoolBufferSize) }, } @@ -3540,7 +3540,7 @@ type http2connectionStater interface { ConnectionState() tls.ConnectionState } -var http2sorterPool = sync.Pool{New: func() interface{} { return new(http2sorter) }} +var http2sorterPool = sync.Pool{New: func() any { return new(http2sorter) }} type http2sorter struct { v []string // owned by sorter @@ -3781,7 +3781,7 @@ var ( ) var http2responseWriterStatePool = sync.Pool{ - New: func() interface{} { + New: func() any { rws := &http2responseWriterState{} rws.bw = bufio.NewWriterSize(http2chunkWriter{rws}, http2handlerChunkWriteSize) return rws @@ -3793,7 +3793,7 @@ var ( http2testHookOnConn func() http2testHookGetServerConn func(*http2serverConn) http2testHookOnPanicMu *sync.Mutex // nil except in tests - http2testHookOnPanic func(sc *http2serverConn, panicVal interface{}) (rePanic bool) + http2testHookOnPanic func(sc *http2serverConn, panicVal any) (rePanic bool) ) // Server is an HTTP/2 server. @@ -4086,7 +4086,7 @@ func (s *http2Server) ServeConn(c net.Conn, opts *http2ServeConnOpts) { streams: make(map[uint32]*http2stream), readFrameCh: make(chan http2readFrameResult), wantWriteFrameCh: make(chan http2FrameWriteRequest, 8), - serveMsgCh: make(chan interface{}, 8), + serveMsgCh: make(chan any, 8), wroteFrameCh: make(chan http2frameWriteResult, 1), // buffered; one send in writeFrameAsync bodyReadCh: make(chan http2bodyReadMsg), // buffering doesn't matter either way doneServing: make(chan struct{}), @@ -4216,7 +4216,7 @@ type http2serverConn struct { wantWriteFrameCh chan http2FrameWriteRequest // from handlers -> serve wroteFrameCh chan http2frameWriteResult // from writeFrameAsync -> serve, tickles more frame writes bodyReadCh chan http2bodyReadMsg // from handlers -> serve - serveMsgCh chan interface{} // misc messages & code to send to / run on the serve loop + serveMsgCh chan any // misc messages & code to send to / run on the serve loop flow http2flow // conn-wide (not stream-specific) outbound flow control inflow http2flow // conn-wide inbound flow control tlsState *tls.ConnectionState // shared by all handlers, like net/http @@ -4351,13 +4351,13 @@ func (sc *http2serverConn) setConnState(state ConnState) { } } -func (sc *http2serverConn) vlogf(format string, args ...interface{}) { +func (sc *http2serverConn) vlogf(format string, args ...any) { if http2VerboseLogs { sc.logf(format, args...) } } -func (sc *http2serverConn) logf(format string, args ...interface{}) { +func (sc *http2serverConn) logf(format string, args ...any) { if lg := sc.hs.ErrorLog; lg != nil { lg.Printf(format, args...) } else { @@ -4409,7 +4409,7 @@ func http2isClosedConnError(err error) bool { return false } -func (sc *http2serverConn) condlogf(err error, format string, args ...interface{}) { +func (sc *http2serverConn) condlogf(err error, format string, args ...any) { if err == nil { return } @@ -4679,7 +4679,7 @@ func (sc *http2serverConn) onIdleTimer() { sc.sendServeMsg(http2idleTimerMsg) } func (sc *http2serverConn) onShutdownTimer() { sc.sendServeMsg(http2shutdownTimerMsg) } -func (sc *http2serverConn) sendServeMsg(msg interface{}) { +func (sc *http2serverConn) sendServeMsg(msg any) { sc.serveG.checkNotOn() // NOT select { case sc.serveMsgCh <- msg: @@ -4721,11 +4721,11 @@ func (sc *http2serverConn) readPreface() error { } var http2errChanPool = sync.Pool{ - New: func() interface{} { return make(chan error, 1) }, + New: func() any { return make(chan error, 1) }, } var http2writeDataPool = sync.Pool{ - New: func() interface{} { return new(http2writeData) }, + New: func() any { return new(http2writeData) }, } // writeDataFromHandler writes DATA response frames from a handler on @@ -6712,7 +6712,7 @@ func http2new400Handler(err error) HandlerFunc { // disabled. See comments on h1ServerShutdownChan above for why // the code is written this way. func http2h1ServerKeepAlivesDisabled(hs *Server) bool { - var x interface{} = hs + var x any = hs type I interface { doKeepAlives() bool } @@ -9577,21 +9577,21 @@ var ( http2errRequestHeaderListSize = errors.New("http2: request header list larger than peer's advertised limit") ) -func (cc *http2ClientConn) logf(format string, args ...interface{}) { +func (cc *http2ClientConn) logf(format string, args ...any) { cc.t.logf(format, args...) } -func (cc *http2ClientConn) vlogf(format string, args ...interface{}) { +func (cc *http2ClientConn) vlogf(format string, args ...any) { cc.t.vlogf(format, args...) } -func (t *http2Transport) vlogf(format string, args ...interface{}) { +func (t *http2Transport) vlogf(format string, args ...any) { if http2VerboseLogs { t.logf(format, args...) } } -func (t *http2Transport) logf(format string, args ...interface{}) { +func (t *http2Transport) logf(format string, args ...any) { log.Printf(format, args...) } diff --git a/src/net/http/header.go b/src/net/http/header.go index 5c77cbb882..6487e5025d 100644 --- a/src/net/http/header.go +++ b/src/net/http/header.go @@ -157,7 +157,7 @@ func (s *headerSorter) Swap(i, j int) { s.kvs[i], s.kvs[j] = s.kvs[j], s.kv func (s *headerSorter) Less(i, j int) bool { return s.kvs[i].key < s.kvs[j].key } var headerSorterPool = sync.Pool{ - New: func() interface{} { return new(headerSorter) }, + New: func() any { return new(headerSorter) }, } // sortedKeyValues returns h's keys sorted in the returned kvs diff --git a/src/net/http/httptrace/trace.go b/src/net/http/httptrace/trace.go index 5777c91747..6af30f78d1 100644 --- a/src/net/http/httptrace/trace.go +++ b/src/net/http/httptrace/trace.go @@ -50,7 +50,7 @@ func WithClientTrace(ctx context.Context, trace *ClientTrace) context.Context { } } if trace.DNSDone != nil { - nt.DNSDone = func(netIPs []interface{}, coalesced bool, err error) { + nt.DNSDone = func(netIPs []any, coalesced bool, err error) { addrs := make([]net.IPAddr, len(netIPs)) for i, ip := range netIPs { addrs[i] = ip.(net.IPAddr) diff --git a/src/net/http/httputil/dump_test.go b/src/net/http/httputil/dump_test.go index 366cc8239a..5df2ee8075 100644 --- a/src/net/http/httputil/dump_test.go +++ b/src/net/http/httputil/dump_test.go @@ -31,7 +31,7 @@ type dumpTest struct { Req *http.Request GetReq func() *http.Request - Body interface{} // optional []byte or func() io.ReadCloser to populate Req.Body + Body any // optional []byte or func() io.ReadCloser to populate Req.Body WantDump string WantDumpOut string diff --git a/src/net/http/httputil/reverseproxy.go b/src/net/http/httputil/reverseproxy.go index 71849bb8f7..319e2a3f3f 100644 --- a/src/net/http/httputil/reverseproxy.go +++ b/src/net/http/httputil/reverseproxy.go @@ -484,7 +484,7 @@ func (p *ReverseProxy) copyBuffer(dst io.Writer, src io.Reader, buf []byte) (int } } -func (p *ReverseProxy) logf(format string, args ...interface{}) { +func (p *ReverseProxy) logf(format string, args ...any) { if p.ErrorLog != nil { p.ErrorLog.Printf(format, args...) } else { diff --git a/src/net/http/omithttp2.go b/src/net/http/omithttp2.go index 63c0e92d6a..3316f55c6d 100644 --- a/src/net/http/omithttp2.go +++ b/src/net/http/omithttp2.go @@ -26,7 +26,7 @@ const http2NextProtoTLS = "h2" type http2Transport struct { MaxHeaderListSize uint32 - ConnPool interface{} + ConnPool any } func (*http2Transport) RoundTrip(*Request) (*Response, error) { panic(noHTTP2) } @@ -56,9 +56,9 @@ type http2Server struct { NewWriteScheduler func() http2WriteScheduler } -type http2WriteScheduler interface{} +type http2WriteScheduler any -func http2NewPriorityWriteScheduler(interface{}) http2WriteScheduler { panic(noHTTP2) } +func http2NewPriorityWriteScheduler(any) http2WriteScheduler { panic(noHTTP2) } func http2ConfigureServer(s *Server, conf *http2Server) error { panic(noHTTP2) } diff --git a/src/net/http/requestwrite_test.go b/src/net/http/requestwrite_test.go index 1157bdfff9..bdc1e3c508 100644 --- a/src/net/http/requestwrite_test.go +++ b/src/net/http/requestwrite_test.go @@ -20,7 +20,7 @@ import ( type reqWriteTest struct { Req Request - Body interface{} // optional []byte or func() io.ReadCloser to populate Req.Body + Body any // optional []byte or func() io.ReadCloser to populate Req.Body // Any of these three may be empty to skip that test. WantWrite string // Request.Write diff --git a/src/net/http/response_test.go b/src/net/http/response_test.go index 8eef65474e..5a735b0215 100644 --- a/src/net/http/response_test.go +++ b/src/net/http/response_test.go @@ -646,8 +646,8 @@ type readerAndCloser struct { func TestReadResponseCloseInMiddle(t *testing.T) { t.Parallel() for _, test := range readResponseCloseInMiddleTests { - fatalf := func(format string, args ...interface{}) { - args = append([]interface{}{test.chunked, test.compressed}, args...) + fatalf := func(format string, args ...any) { + args = append([]any{test.chunked, test.compressed}, args...) t.Fatalf("on test chunked=%v, compressed=%v: "+format, args...) } checkErr := func(err error, msg string) { @@ -732,7 +732,7 @@ func TestReadResponseCloseInMiddle(t *testing.T) { } } -func diff(t *testing.T, prefix string, have, want interface{}) { +func diff(t *testing.T, prefix string, have, want any) { t.Helper() hv := reflect.ValueOf(have).Elem() wv := reflect.ValueOf(want).Elem() @@ -849,10 +849,10 @@ func TestReadResponseErrors(t *testing.T) { type testCase struct { name string // optional, defaults to in in string - wantErr interface{} // nil, err value, or string substring + wantErr any // nil, err value, or string substring } - status := func(s string, wantErr interface{}) testCase { + status := func(s string, wantErr any) testCase { if wantErr == true { wantErr = "malformed HTTP status code" } @@ -863,7 +863,7 @@ func TestReadResponseErrors(t *testing.T) { } } - version := func(s string, wantErr interface{}) testCase { + version := func(s string, wantErr any) testCase { if wantErr == true { wantErr = "malformed HTTP version" } @@ -874,7 +874,7 @@ func TestReadResponseErrors(t *testing.T) { } } - contentLength := func(status, body string, wantErr interface{}) testCase { + contentLength := func(status, body string, wantErr any) testCase { return testCase{ name: fmt.Sprintf("status %q %q", status, body), in: fmt.Sprintf("HTTP/1.1 %s\r\n%s", status, body), @@ -947,7 +947,7 @@ func TestReadResponseErrors(t *testing.T) { // wantErr can be nil, an error value to match exactly, or type string to // match a substring. -func matchErr(err error, wantErr interface{}) error { +func matchErr(err error, wantErr any) error { if err == nil { if wantErr == nil { return nil diff --git a/src/net/http/roundtrip_js.go b/src/net/http/roundtrip_js.go index dd042e9a01..01c0600ba5 100644 --- a/src/net/http/roundtrip_js.go +++ b/src/net/http/roundtrip_js.go @@ -118,7 +118,7 @@ func (t *Transport) RoundTrip(req *Request) (*Response, error) { errCh = make(chan error, 1) success, failure js.Func ) - success = js.FuncOf(func(this js.Value, args []js.Value) interface{} { + success = js.FuncOf(func(this js.Value, args []js.Value) any { success.Release() failure.Release() @@ -182,7 +182,7 @@ func (t *Transport) RoundTrip(req *Request) (*Response, error) { return nil }) - failure = js.FuncOf(func(this js.Value, args []js.Value) interface{} { + failure = js.FuncOf(func(this js.Value, args []js.Value) any { success.Release() failure.Release() errCh <- fmt.Errorf("net/http: fetch() failed: %s", args[0].Get("message").String()) @@ -223,7 +223,7 @@ func (r *streamReader) Read(p []byte) (n int, err error) { bCh = make(chan []byte, 1) errCh = make(chan error, 1) ) - success := js.FuncOf(func(this js.Value, args []js.Value) interface{} { + success := js.FuncOf(func(this js.Value, args []js.Value) any { result := args[0] if result.Get("done").Bool() { errCh <- io.EOF @@ -235,7 +235,7 @@ func (r *streamReader) Read(p []byte) (n int, err error) { return nil }) defer success.Release() - failure := js.FuncOf(func(this js.Value, args []js.Value) interface{} { + failure := js.FuncOf(func(this js.Value, args []js.Value) any { // Assumes it's a TypeError. See // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError // for more information on this type. See @@ -289,7 +289,7 @@ func (r *arrayReader) Read(p []byte) (n int, err error) { bCh = make(chan []byte, 1) errCh = make(chan error, 1) ) - success := js.FuncOf(func(this js.Value, args []js.Value) interface{} { + success := js.FuncOf(func(this js.Value, args []js.Value) any { // Wrap the input ArrayBuffer with a Uint8Array uint8arrayWrapper := uint8Array.New(args[0]) value := make([]byte, uint8arrayWrapper.Get("byteLength").Int()) @@ -298,7 +298,7 @@ func (r *arrayReader) Read(p []byte) (n int, err error) { return nil }) defer success.Release() - failure := js.FuncOf(func(this js.Value, args []js.Value) interface{} { + failure := js.FuncOf(func(this js.Value, args []js.Value) any { // Assumes it's a TypeError. See // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError // for more information on this type. diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go index d46400ef75..fb18cb2c6f 100644 --- a/src/net/http/serve_test.go +++ b/src/net/http/serve_test.go @@ -2147,7 +2147,7 @@ func TestInvalidTrailerClosesConnection(t *testing.T) { // Read and Write. type slowTestConn struct { // over multiple calls to Read, time.Durations are slept, strings are read. - script []interface{} + script []any closec chan bool mu sync.Mutex // guards rd/wd @@ -2239,7 +2239,7 @@ func TestRequestBodyTimeoutClosesConnection(t *testing.T) { defer afterTest(t) for _, handler := range testHandlerBodyConsumers { conn := &slowTestConn{ - script: []interface{}{ + script: []any{ "POST /public HTTP/1.1\r\n" + "Host: test\r\n" + "Content-Length: 10000\r\n" + @@ -2766,7 +2766,7 @@ func TestHandlerPanicWithHijack(t *testing.T) { testHandlerPanic(t, true, h1Mode, nil, "intentional death for testing") } -func testHandlerPanic(t *testing.T, withHijack, h2 bool, wrapper func(Handler) Handler, panicValue interface{}) { +func testHandlerPanic(t *testing.T, withHijack, h2 bool, wrapper func(Handler) Handler, panicValue any) { defer afterTest(t) // Unlike the other tests that set the log output to io.Discard // to quiet the output, this test uses a pipe. The pipe serves three @@ -3934,7 +3934,7 @@ func testTransportAndServerSharedBodyRace(t *testing.T, h2 bool) { // this test fails, it hangs. This helps debugging and I've // added this enough times "temporarily". It now gets added // full time. - errorf := func(format string, args ...interface{}) { + errorf := func(format string, args ...any) { v := fmt.Sprintf(format, args...) println(v) t.Error(v) @@ -3943,10 +3943,10 @@ func testTransportAndServerSharedBodyRace(t *testing.T, h2 bool) { unblockBackend := make(chan bool) backend := newClientServerTest(t, h2, HandlerFunc(func(rw ResponseWriter, req *Request) { gone := rw.(CloseNotifier).CloseNotify() - didCopy := make(chan interface{}) + didCopy := make(chan any) go func() { n, err := io.CopyN(rw, req.Body, bodySize) - didCopy <- []interface{}{n, err} + didCopy <- []any{n, err} }() isGone := false Loop: @@ -4938,7 +4938,7 @@ func TestServerContext_LocalAddrContextKey_h2(t *testing.T) { func testServerContext_LocalAddrContextKey(t *testing.T, h2 bool) { setParallel(t) defer afterTest(t) - ch := make(chan interface{}, 1) + ch := make(chan any, 1) cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) { ch <- r.Context().Value(LocalAddrContextKey) })) @@ -6293,7 +6293,7 @@ func testContentEncodingNoSniffing(t *testing.T, h2 bool) { // setting contentEncoding as an interface instead of a string // directly, so as to differentiate between 3 states: // unset, empty string "" and set string "foo/bar". - contentEncoding interface{} + contentEncoding any wantContentType string } diff --git a/src/net/http/server.go b/src/net/http/server.go index f0b0e86e91..ddc799bd9e 100644 --- a/src/net/http/server.go +++ b/src/net/http/server.go @@ -798,7 +798,7 @@ var ( ) var copyBufPool = sync.Pool{ - New: func() interface{} { + New: func() any { b := make([]byte, 32*1024) return &b }, @@ -3190,7 +3190,7 @@ func (srv *Server) SetKeepAlivesEnabled(v bool) { // TODO: Issue 26303: close HTTP/2 conns as soon as they become idle. } -func (s *Server) logf(format string, args ...interface{}) { +func (s *Server) logf(format string, args ...any) { if s.ErrorLog != nil { s.ErrorLog.Printf(format, args...) } else { @@ -3201,7 +3201,7 @@ func (s *Server) logf(format string, args ...interface{}) { // logf prints to the ErrorLog of the *Server associated with request r // via ServerContextKey. If there's no associated server, or if ErrorLog // is nil, logging is done via the log package's standard logger. -func logf(r *Request, format string, args ...interface{}) { +func logf(r *Request, format string, args ...any) { s, _ := r.Context().Value(ServerContextKey).(*Server) if s != nil && s.ErrorLog != nil { s.ErrorLog.Printf(format, args...) @@ -3364,7 +3364,7 @@ func (h *timeoutHandler) ServeHTTP(w ResponseWriter, r *Request) { h: make(Header), req: r, } - panicChan := make(chan interface{}, 1) + panicChan := make(chan any, 1) go func() { defer func() { if p := recover(); p != nil { diff --git a/src/net/http/transfer.go b/src/net/http/transfer.go index 2be1c9fa3c..6d51178ee9 100644 --- a/src/net/http/transfer.go +++ b/src/net/http/transfer.go @@ -73,7 +73,7 @@ type transferWriter struct { ByteReadCh chan readResult // non-nil if probeRequestBody called } -func newTransferWriter(r interface{}) (t *transferWriter, err error) { +func newTransferWriter(r any) (t *transferWriter, err error) { t = &transferWriter{} // Extract relevant fields @@ -481,7 +481,7 @@ func suppressedHeaders(status int) []string { } // msg is *Request or *Response. -func readTransfer(msg interface{}, r *bufio.Reader) (err error) { +func readTransfer(msg any, r *bufio.Reader) (err error) { t := &transferReader{RequestMethod: "GET"} // Unify input @@ -809,7 +809,7 @@ func fixTrailer(header Header, chunked bool) (Header, error) { // and then reads the trailer if necessary. type body struct { src io.Reader - hdr interface{} // non-nil (Response or Request) value means read trailer + hdr any // non-nil (Response or Request) value means read trailer r *bufio.Reader // underlying wire-format reader for the trailer closing bool // is the connection to be closed after reading body? doEarlyClose bool // whether Close should stop early diff --git a/src/net/http/transport.go b/src/net/http/transport.go index f2d2f79280..5fe3e6ebb4 100644 --- a/src/net/http/transport.go +++ b/src/net/http/transport.go @@ -2668,8 +2668,8 @@ func (pc *persistConn) roundTrip(req *transportRequest) (resp *Response, err err // a t.Logf func. See export_test.go's Request.WithT method. type tLogKey struct{} -func (tr *transportRequest) logf(format string, args ...interface{}) { - if logf, ok := tr.Request.Context().Value(tLogKey{}).(func(string, ...interface{})); ok { +func (tr *transportRequest) logf(format string, args ...any) { + if logf, ok := tr.Request.Context().Value(tLogKey{}).(func(string, ...any)); ok { logf(time.Now().Format(time.RFC3339Nano)+": "+format, args...) } } diff --git a/src/net/http/transport_test.go b/src/net/http/transport_test.go index 0cdd946de4..e5d60afb1b 100644 --- a/src/net/http/transport_test.go +++ b/src/net/http/transport_test.go @@ -776,7 +776,7 @@ func TestTransportServerClosingUnexpectedly(t *testing.T) { c := ts.Client() fetch := func(n, retries int) string { - condFatalf := func(format string, arg ...interface{}) { + condFatalf := func(format string, arg ...any) { if retries <= 0 { t.Fatalf(format, arg...) } @@ -3514,7 +3514,7 @@ func TestRetryRequestsOnError(t *testing.T) { mu sync.Mutex logbuf bytes.Buffer ) - logf := func(format string, args ...interface{}) { + logf := func(format string, args ...any) { mu.Lock() defer mu.Unlock() fmt.Fprintf(&logbuf, format, args...) @@ -4491,7 +4491,7 @@ func testTransportEventTrace(t *testing.T, h2 bool, noHooks bool) { var mu sync.Mutex // guards buf var buf bytes.Buffer - logf := func(format string, args ...interface{}) { + logf := func(format string, args ...any) { mu.Lock() defer mu.Unlock() fmt.Fprintf(&buf, format, args...) @@ -4650,7 +4650,7 @@ func testTransportEventTrace(t *testing.T, h2 bool, noHooks bool) { func TestTransportEventTraceTLSVerify(t *testing.T) { var mu sync.Mutex var buf bytes.Buffer - logf := func(format string, args ...interface{}) { + logf := func(format string, args ...any) { mu.Lock() defer mu.Unlock() fmt.Fprintf(&buf, format, args...) @@ -4736,7 +4736,7 @@ func TestTransportEventTraceRealDNS(t *testing.T) { var mu sync.Mutex // guards buf var buf bytes.Buffer - logf := func(format string, args ...interface{}) { + logf := func(format string, args ...any) { mu.Lock() defer mu.Unlock() fmt.Fprintf(&buf, format, args...) diff --git a/src/net/ip_test.go b/src/net/ip_test.go index 10e77f3bdb..777461ad27 100644 --- a/src/net/ip_test.go +++ b/src/net/ip_test.go @@ -718,7 +718,7 @@ var ipAddrScopeTests = []struct { {IP.IsPrivate, IP{0xfe, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, false}, } -func name(f interface{}) string { +func name(f any) string { return runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name() } diff --git a/src/net/listen_test.go b/src/net/listen_test.go index 09ffbb31a1..59c0112122 100644 --- a/src/net/listen_test.go +++ b/src/net/listen_test.go @@ -379,7 +379,7 @@ func differentWildcardAddr(i, j string) bool { return true } -func checkFirstListener(network string, ln interface{}) error { +func checkFirstListener(network string, ln any) error { switch network { case "tcp": fd := ln.(*TCPListener).fd diff --git a/src/net/lookup.go b/src/net/lookup.go index ff4ddbeb82..c7b8dc6905 100644 --- a/src/net/lookup.go +++ b/src/net/lookup.go @@ -265,7 +265,7 @@ type onlyValuesCtx struct { var _ context.Context = (*onlyValuesCtx)(nil) // Value performs a lookup if the original context hasn't expired. -func (ovc *onlyValuesCtx) Value(key interface{}) interface{} { +func (ovc *onlyValuesCtx) Value(key any) any { select { case <-ovc.lookupValues.Done(): return nil @@ -314,7 +314,7 @@ func (r *Resolver) lookupIPAddr(ctx context.Context, network, host string) ([]IP lookupKey := network + "\000" + host dnsWaitGroup.Add(1) - ch, called := r.getLookupGroup().DoChan(lookupKey, func() (interface{}, error) { + ch, called := r.getLookupGroup().DoChan(lookupKey, func() (any, error) { defer dnsWaitGroup.Done() return testHookLookupIP(lookupGroupCtx, resolverFunc, network, host) }) @@ -377,7 +377,7 @@ func (r *Resolver) lookupIPAddr(ctx context.Context, network, host string) ([]IP // lookupIPReturn turns the return values from singleflight.Do into // the return values from LookupIP. -func lookupIPReturn(addrsi interface{}, err error, shared bool) ([]IPAddr, error) { +func lookupIPReturn(addrsi any, err error, shared bool) ([]IPAddr, error) { if err != nil { return nil, err } @@ -391,8 +391,8 @@ func lookupIPReturn(addrsi interface{}, err error, shared bool) ([]IPAddr, error } // ipAddrsEface returns an empty interface slice of addrs. -func ipAddrsEface(addrs []IPAddr) []interface{} { - s := make([]interface{}, len(addrs)) +func ipAddrsEface(addrs []IPAddr) []any { + s := make([]any, len(addrs)) for i, v := range addrs { s[i] = v } diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index 5b3a3e24b2..d71a18c684 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -1057,7 +1057,7 @@ func TestLookupIPAddrPreservesContextValues(t *testing.T) { defer func() { testHookLookupIP = origTestHookLookupIP }() keyValues := []struct { - key, value interface{} + key, value any }{ {"key-1", 12}, {384, "value2"}, diff --git a/src/net/lookup_windows_test.go b/src/net/lookup_windows_test.go index f726ef0f34..9254733364 100644 --- a/src/net/lookup_windows_test.go +++ b/src/net/lookup_windows_test.go @@ -21,7 +21,7 @@ import ( var nslookupTestServers = []string{"mail.golang.com", "gmail.com"} var lookupTestIPs = []string{"8.8.8.8", "1.1.1.1"} -func toJson(v interface{}) string { +func toJson(v any) string { data, _ := json.Marshal(v) return string(data) } diff --git a/src/net/mail/message.go b/src/net/mail/message.go index c120316730..985b6fcae2 100644 --- a/src/net/mail/message.go +++ b/src/net/mail/message.go @@ -35,7 +35,7 @@ var debug = debugT(false) type debugT bool -func (d debugT) Printf(format string, args ...interface{}) { +func (d debugT) Printf(format string, args ...any) { if d { log.Printf(format, args...) } diff --git a/src/net/netip/netip_test.go b/src/net/netip/netip_test.go index 520695cdfb..d988864827 100644 --- a/src/net/netip/netip_test.go +++ b/src/net/netip/netip_test.go @@ -1451,7 +1451,7 @@ type ip4i struct { flags2 byte flags3 byte flags4 byte - ipv6 interface{} + ipv6 any } func newip4i_v4(a, b, c, d byte) ip4i { diff --git a/src/net/platform_test.go b/src/net/platform_test.go index 7d92a0de5d..c522ba2829 100644 --- a/src/net/platform_test.go +++ b/src/net/platform_test.go @@ -173,7 +173,7 @@ func testableListenArgs(network, address, client string) bool { return true } -func condFatalf(t *testing.T, network string, format string, args ...interface{}) { +func condFatalf(t *testing.T, network string, format string, args ...any) { t.Helper() // A few APIs like File and Read/WriteMsg{UDP,IP} are not // fully implemented yet on Plan 9 and Windows. diff --git a/src/net/rpc/client.go b/src/net/rpc/client.go index 60bb2cc99f..42d13519b1 100644 --- a/src/net/rpc/client.go +++ b/src/net/rpc/client.go @@ -27,11 +27,11 @@ var ErrShutdown = errors.New("connection is shut down") // Call represents an active RPC. type Call struct { - ServiceMethod string // The name of the service and method to call. - Args interface{} // The argument to the function (*struct). - Reply interface{} // The reply from the function (*struct). - Error error // After completion, the error status. - Done chan *Call // Receives *Call when Go is complete. + ServiceMethod string // The name of the service and method to call. + Args any // The argument to the function (*struct). + Reply any // The reply from the function (*struct). + Error error // After completion, the error status. + Done chan *Call // Receives *Call when Go is complete. } // Client represents an RPC Client. @@ -61,9 +61,9 @@ type Client struct { // discarded. // See NewClient's comment for information about concurrent access. type ClientCodec interface { - WriteRequest(*Request, interface{}) error + WriteRequest(*Request, any) error ReadResponseHeader(*Response) error - ReadResponseBody(interface{}) error + ReadResponseBody(any) error Close() error } @@ -214,7 +214,7 @@ type gobClientCodec struct { encBuf *bufio.Writer } -func (c *gobClientCodec) WriteRequest(r *Request, body interface{}) (err error) { +func (c *gobClientCodec) WriteRequest(r *Request, body any) (err error) { if err = c.enc.Encode(r); err != nil { return } @@ -228,7 +228,7 @@ func (c *gobClientCodec) ReadResponseHeader(r *Response) error { return c.dec.Decode(r) } -func (c *gobClientCodec) ReadResponseBody(body interface{}) error { +func (c *gobClientCodec) ReadResponseBody(body any) error { return c.dec.Decode(body) } @@ -295,7 +295,7 @@ func (client *Client) Close() error { // the invocation. The done channel will signal when the call is complete by returning // the same Call object. If done is nil, Go will allocate a new channel. // If non-nil, done must be buffered or Go will deliberately crash. -func (client *Client) Go(serviceMethod string, args interface{}, reply interface{}, done chan *Call) *Call { +func (client *Client) Go(serviceMethod string, args any, reply any, done chan *Call) *Call { call := new(Call) call.ServiceMethod = serviceMethod call.Args = args @@ -317,7 +317,7 @@ func (client *Client) Go(serviceMethod string, args interface{}, reply interface } // Call invokes the named function, waits for it to complete, and returns its error status. -func (client *Client) Call(serviceMethod string, args interface{}, reply interface{}) error { +func (client *Client) Call(serviceMethod string, args any, reply any) error { call := <-client.Go(serviceMethod, args, reply, make(chan *Call, 1)).Done return call.Error } diff --git a/src/net/rpc/client_test.go b/src/net/rpc/client_test.go index 38a10ce0b3..ffc12faeda 100644 --- a/src/net/rpc/client_test.go +++ b/src/net/rpc/client_test.go @@ -17,8 +17,8 @@ type shutdownCodec struct { closed bool } -func (c *shutdownCodec) WriteRequest(*Request, interface{}) error { return nil } -func (c *shutdownCodec) ReadResponseBody(interface{}) error { return nil } +func (c *shutdownCodec) WriteRequest(*Request, any) error { return nil } +func (c *shutdownCodec) ReadResponseBody(any) error { return nil } func (c *shutdownCodec) ReadResponseHeader(*Response) error { c.responded <- 1 return errors.New("shutdownCodec ReadResponseHeader") diff --git a/src/net/rpc/debug.go b/src/net/rpc/debug.go index a1d799ff19..9e499fd984 100644 --- a/src/net/rpc/debug.go +++ b/src/net/rpc/debug.go @@ -72,7 +72,7 @@ type debugHTTP struct { func (server debugHTTP) ServeHTTP(w http.ResponseWriter, req *http.Request) { // Build a sorted version of the data. var services serviceArray - server.serviceMap.Range(func(snamei, svci interface{}) bool { + server.serviceMap.Range(func(snamei, svci any) bool { svc := svci.(*service) ds := debugService{svc, snamei.(string), make(methodArray, 0, len(svc.method))} for mname, method := range svc.method { diff --git a/src/net/rpc/jsonrpc/all_test.go b/src/net/rpc/jsonrpc/all_test.go index 667f839f58..f4e1278d03 100644 --- a/src/net/rpc/jsonrpc/all_test.go +++ b/src/net/rpc/jsonrpc/all_test.go @@ -28,9 +28,9 @@ type Reply struct { type Arith int type ArithAddResp struct { - Id interface{} `json:"id"` - Result Reply `json:"result"` - Error interface{} `json:"error"` + Id any `json:"id"` + Result Reply `json:"result"` + Error any `json:"error"` } func (t *Arith) Add(args *Args, reply *Reply) error { diff --git a/src/net/rpc/jsonrpc/client.go b/src/net/rpc/jsonrpc/client.go index e6359bed59..c473017d26 100644 --- a/src/net/rpc/jsonrpc/client.go +++ b/src/net/rpc/jsonrpc/client.go @@ -44,12 +44,12 @@ func NewClientCodec(conn io.ReadWriteCloser) rpc.ClientCodec { } type clientRequest struct { - Method string `json:"method"` - Params [1]interface{} `json:"params"` - Id uint64 `json:"id"` + Method string `json:"method"` + Params [1]any `json:"params"` + Id uint64 `json:"id"` } -func (c *clientCodec) WriteRequest(r *rpc.Request, param interface{}) error { +func (c *clientCodec) WriteRequest(r *rpc.Request, param any) error { c.mutex.Lock() c.pending[r.Seq] = r.ServiceMethod c.mutex.Unlock() @@ -62,7 +62,7 @@ func (c *clientCodec) WriteRequest(r *rpc.Request, param interface{}) error { type clientResponse struct { Id uint64 `json:"id"` Result *json.RawMessage `json:"result"` - Error interface{} `json:"error"` + Error any `json:"error"` } func (r *clientResponse) reset() { @@ -97,7 +97,7 @@ func (c *clientCodec) ReadResponseHeader(r *rpc.Response) error { return nil } -func (c *clientCodec) ReadResponseBody(x interface{}) error { +func (c *clientCodec) ReadResponseBody(x any) error { if x == nil { return nil } diff --git a/src/net/rpc/jsonrpc/server.go b/src/net/rpc/jsonrpc/server.go index 40e4e6f2aa..3ee4ddfef2 100644 --- a/src/net/rpc/jsonrpc/server.go +++ b/src/net/rpc/jsonrpc/server.go @@ -57,8 +57,8 @@ func (r *serverRequest) reset() { type serverResponse struct { Id *json.RawMessage `json:"id"` - Result interface{} `json:"result"` - Error interface{} `json:"error"` + Result any `json:"result"` + Error any `json:"error"` } func (c *serverCodec) ReadRequestHeader(r *rpc.Request) error { @@ -81,7 +81,7 @@ func (c *serverCodec) ReadRequestHeader(r *rpc.Request) error { return nil } -func (c *serverCodec) ReadRequestBody(x interface{}) error { +func (c *serverCodec) ReadRequestBody(x any) error { if x == nil { return nil } @@ -92,14 +92,14 @@ func (c *serverCodec) ReadRequestBody(x interface{}) error { // RPC params is struct. // Unmarshal into array containing struct for now. // Should think about making RPC more general. - var params [1]interface{} + var params [1]any params[0] = x return json.Unmarshal(*c.req.Params, ¶ms) } var null = json.RawMessage([]byte("null")) -func (c *serverCodec) WriteResponse(r *rpc.Response, x interface{}) error { +func (c *serverCodec) WriteResponse(r *rpc.Response, x any) error { c.mutex.Lock() b, ok := c.pending[r.Seq] if !ok { diff --git a/src/net/rpc/server.go b/src/net/rpc/server.go index 223a53cfa7..d5207a42cf 100644 --- a/src/net/rpc/server.go +++ b/src/net/rpc/server.go @@ -221,13 +221,13 @@ func isExportedOrBuiltinType(t reflect.Type) bool { // no suitable methods. It also logs the error using package log. // The client accesses each method using a string of the form "Type.Method", // where Type is the receiver's concrete type. -func (server *Server) Register(rcvr interface{}) error { +func (server *Server) Register(rcvr any) error { return server.register(rcvr, "", false) } // RegisterName is like Register but uses the provided name for the type // instead of the receiver's concrete type. -func (server *Server) RegisterName(name string, rcvr interface{}) error { +func (server *Server) RegisterName(name string, rcvr any) error { return server.register(rcvr, name, true) } @@ -235,7 +235,7 @@ func (server *Server) RegisterName(name string, rcvr interface{}) error { // To debug registration, recompile the package with this set to true. const logRegisterError = false -func (server *Server) register(rcvr interface{}, name string, useName bool) error { +func (server *Server) register(rcvr any, name string, useName bool) error { s := new(service) s.typ = reflect.TypeOf(rcvr) s.rcvr = reflect.ValueOf(rcvr) @@ -344,7 +344,7 @@ func suitableMethods(typ reflect.Type, logErr bool) map[string]*methodType { // contains an error when it is used. var invalidRequest = struct{}{} -func (server *Server) sendResponse(sending *sync.Mutex, req *Request, reply interface{}, codec ServerCodec, errmsg string) { +func (server *Server) sendResponse(sending *sync.Mutex, req *Request, reply any, codec ServerCodec, errmsg string) { resp := server.getResponse() // Encode the response header resp.ServiceMethod = req.ServiceMethod @@ -401,11 +401,11 @@ func (c *gobServerCodec) ReadRequestHeader(r *Request) error { return c.dec.Decode(r) } -func (c *gobServerCodec) ReadRequestBody(body interface{}) error { +func (c *gobServerCodec) ReadRequestBody(body any) error { return c.dec.Decode(body) } -func (c *gobServerCodec) WriteResponse(r *Response, body interface{}) (err error) { +func (c *gobServerCodec) WriteResponse(r *Response, body any) (err error) { if err = c.enc.Encode(r); err != nil { if c.encBuf.Flush() == nil { // Gob couldn't encode the header. Should not happen, so if it does, @@ -636,11 +636,11 @@ func (server *Server) Accept(lis net.Listener) { } // Register publishes the receiver's methods in the DefaultServer. -func Register(rcvr interface{}) error { return DefaultServer.Register(rcvr) } +func Register(rcvr any) error { return DefaultServer.Register(rcvr) } // RegisterName is like Register but uses the provided name for the type // instead of the receiver's concrete type. -func RegisterName(name string, rcvr interface{}) error { +func RegisterName(name string, rcvr any) error { return DefaultServer.RegisterName(name, rcvr) } @@ -654,8 +654,8 @@ func RegisterName(name string, rcvr interface{}) error { // See NewClient's comment for information about concurrent access. type ServerCodec interface { ReadRequestHeader(*Request) error - ReadRequestBody(interface{}) error - WriteResponse(*Response, interface{}) error + ReadRequestBody(any) error + WriteResponse(*Response, any) error // Close can be called multiple times and must be idempotent. Close() error diff --git a/src/net/rpc/server_test.go b/src/net/rpc/server_test.go index e5d7fe0c8f..dc5f5decc7 100644 --- a/src/net/rpc/server_test.go +++ b/src/net/rpc/server_test.go @@ -427,7 +427,7 @@ func (codec *CodecEmulator) ReadRequestHeader(req *Request) error { return nil } -func (codec *CodecEmulator) ReadRequestBody(argv interface{}) error { +func (codec *CodecEmulator) ReadRequestBody(argv any) error { if codec.args == nil { return io.ErrUnexpectedEOF } @@ -435,7 +435,7 @@ func (codec *CodecEmulator) ReadRequestBody(argv interface{}) error { return nil } -func (codec *CodecEmulator) WriteResponse(resp *Response, reply interface{}) error { +func (codec *CodecEmulator) WriteResponse(resp *Response, reply any) error { if resp.Error != "" { codec.err = errors.New(resp.Error) } else { @@ -521,7 +521,7 @@ func TestRegistrationError(t *testing.T) { type WriteFailCodec int -func (WriteFailCodec) WriteRequest(*Request, interface{}) error { +func (WriteFailCodec) WriteRequest(*Request, any) error { // the panic caused by this error used to not unlock a lock. return errors.New("fail") } @@ -530,7 +530,7 @@ func (WriteFailCodec) ReadResponseHeader(*Response) error { select {} } -func (WriteFailCodec) ReadResponseBody(interface{}) error { +func (WriteFailCodec) ReadResponseBody(any) error { select {} } diff --git a/src/net/smtp/smtp.go b/src/net/smtp/smtp.go index bcccaa2597..c1f00a04e1 100644 --- a/src/net/smtp/smtp.go +++ b/src/net/smtp/smtp.go @@ -105,7 +105,7 @@ func (c *Client) Hello(localName string) error { } // cmd is a convenience function that sends a command and returns the response -func (c *Client) cmd(expectCode int, format string, args ...interface{}) (int, string, error) { +func (c *Client) cmd(expectCode int, format string, args ...any) (int, string, error) { id, err := c.Text.Cmd(format, args...) if err != nil { return 0, "", err diff --git a/src/net/textproto/textproto.go b/src/net/textproto/textproto.go index 8fd781e777..cc1a847e4e 100644 --- a/src/net/textproto/textproto.go +++ b/src/net/textproto/textproto.go @@ -111,7 +111,7 @@ func Dial(network, addr string) (*Conn, error) { // } // return c.ReadCodeLine(250) // -func (c *Conn) Cmd(format string, args ...interface{}) (id uint, err error) { +func (c *Conn) Cmd(format string, args ...any) (id uint, err error) { id = c.Next() c.StartRequest(id) err = c.PrintfLine(format, args...) diff --git a/src/net/textproto/writer.go b/src/net/textproto/writer.go index 33c146c022..2ece3f511b 100644 --- a/src/net/textproto/writer.go +++ b/src/net/textproto/writer.go @@ -26,7 +26,7 @@ var crnl = []byte{'\r', '\n'} var dotcrnl = []byte{'.', '\r', '\n'} // PrintfLine writes the formatted output followed by \r\n. -func (w *Writer) PrintfLine(format string, args ...interface{}) error { +func (w *Writer) PrintfLine(format string, args ...any) error { w.closeDot() fmt.Fprintf(w.W, format, args...) w.W.Write(crnl) diff --git a/src/net/url/example_test.go b/src/net/url/example_test.go index 87b6e74a85..a1913508f7 100644 --- a/src/net/url/example_test.go +++ b/src/net/url/example_test.go @@ -365,7 +365,7 @@ func ExampleURL_RequestURI() { // Output: /path?foo=bar } -func toJSON(m interface{}) string { +func toJSON(m any) string { js, err := json.Marshal(m) if err != nil { log.Fatal(err) diff --git a/src/net/url/url_test.go b/src/net/url/url_test.go index 7c807d7a38..664757b832 100644 --- a/src/net/url/url_test.go +++ b/src/net/url/url_test.go @@ -618,7 +618,7 @@ var urltests = []URLTest{ // more useful string for debugging than fmt's struct printer func ufmt(u *URL) string { - var user, pass interface{} + var user, pass any if u.User != nil { user = u.User.Username() if p, ok := u.User.Password(); ok { diff --git a/src/os/dir_unix.go b/src/os/dir_unix.go index 4eeb9ab86c..9b3871a3e8 100644 --- a/src/os/dir_unix.go +++ b/src/os/dir_unix.go @@ -27,7 +27,7 @@ const ( ) var dirBufPool = sync.Pool{ - New: func() interface{} { + New: func() any { // The buffer must be at least a block long. buf := make([]byte, blockSize) return &buf diff --git a/src/os/env_test.go b/src/os/env_test.go index 11b3b89725..f8d56ef8e0 100644 --- a/src/os/env_test.go +++ b/src/os/env_test.go @@ -66,7 +66,7 @@ func TestExpand(t *testing.T) { } } -var global interface{} +var global any func BenchmarkExpand(b *testing.B) { b.Run("noop", func(b *testing.B) { diff --git a/src/os/exec.go b/src/os/exec.go index 2beac55f89..9eb3166ecb 100644 --- a/src/os/exec.go +++ b/src/os/exec.go @@ -164,7 +164,7 @@ func (p *ProcessState) Success() bool { // Sys returns system-dependent exit information about // the process. Convert it to the appropriate underlying // type, such as syscall.WaitStatus on Unix, to access its contents. -func (p *ProcessState) Sys() interface{} { +func (p *ProcessState) Sys() any { return p.sys() } @@ -173,6 +173,6 @@ func (p *ProcessState) Sys() interface{} { // type, such as *syscall.Rusage on Unix, to access its contents. // (On Unix, *syscall.Rusage matches struct rusage as defined in the // getrusage(2) manual page.) -func (p *ProcessState) SysUsage() interface{} { +func (p *ProcessState) SysUsage() any { return p.sysUsage() } diff --git a/src/os/exec/exec.go b/src/os/exec/exec.go index 9551c22d6e..845b737e28 100644 --- a/src/os/exec/exec.go +++ b/src/os/exec/exec.go @@ -216,7 +216,7 @@ func (c *Cmd) String() string { // interfaceEqual protects against panics from doing equality tests on // two interfaces with non-comparable underlying types. -func interfaceEqual(a, b interface{}) bool { +func interfaceEqual(a, b any) bool { defer func() { recover() }() diff --git a/src/os/exec/exec_test.go b/src/os/exec/exec_test.go index 81de018e09..92992a6d66 100644 --- a/src/os/exec/exec_test.go +++ b/src/os/exec/exec_test.go @@ -700,7 +700,7 @@ func TestHelperProcess(*testing.T) { cmd, args := args[0], args[1:] switch cmd { case "echo": - iargs := []interface{}{} + iargs := []any{} for _, s := range args { iargs = append(iargs, s) } diff --git a/src/os/exec_plan9.go b/src/os/exec_plan9.go index cc84f97669..69714ff798 100644 --- a/src/os/exec_plan9.go +++ b/src/os/exec_plan9.go @@ -115,11 +115,11 @@ func (p *ProcessState) success() bool { return p.status.ExitStatus() == 0 } -func (p *ProcessState) sys() interface{} { +func (p *ProcessState) sys() any { return p.status } -func (p *ProcessState) sysUsage() interface{} { +func (p *ProcessState) sysUsage() any { return p.status } diff --git a/src/os/exec_posix.go b/src/os/exec_posix.go index 07e2b36f62..d619984693 100644 --- a/src/os/exec_posix.go +++ b/src/os/exec_posix.go @@ -87,11 +87,11 @@ func (p *ProcessState) success() bool { return p.status.ExitStatus() == 0 } -func (p *ProcessState) sys() interface{} { +func (p *ProcessState) sys() any { return p.status } -func (p *ProcessState) sysUsage() interface{} { +func (p *ProcessState) sysUsage() any { return p.rusage } diff --git a/src/os/stat_plan9.go b/src/os/stat_plan9.go index 57ae6fb0bb..e20accf191 100644 --- a/src/os/stat_plan9.go +++ b/src/os/stat_plan9.go @@ -43,7 +43,7 @@ func fileInfoFromStat(d *syscall.Dir) *fileStat { } // arg is an open *File or a path string. -func dirstat(arg interface{}) (*syscall.Dir, error) { +func dirstat(arg any) (*syscall.Dir, error) { var name string var err error diff --git a/src/os/types_plan9.go b/src/os/types_plan9.go index 125da661b7..ccf4fd932e 100644 --- a/src/os/types_plan9.go +++ b/src/os/types_plan9.go @@ -15,13 +15,13 @@ type fileStat struct { size int64 mode FileMode modTime time.Time - sys interface{} + sys any } func (fs *fileStat) Size() int64 { return fs.size } func (fs *fileStat) Mode() FileMode { return fs.mode } func (fs *fileStat) ModTime() time.Time { return fs.modTime } -func (fs *fileStat) Sys() interface{} { return fs.sys } +func (fs *fileStat) Sys() any { return fs.sys } func sameFile(fs1, fs2 *fileStat) bool { a := fs1.sys.(*syscall.Dir) diff --git a/src/os/types_unix.go b/src/os/types_unix.go index 105bb78765..1b90a5a141 100644 --- a/src/os/types_unix.go +++ b/src/os/types_unix.go @@ -23,7 +23,7 @@ type fileStat struct { func (fs *fileStat) Size() int64 { return fs.size } func (fs *fileStat) Mode() FileMode { return fs.mode } func (fs *fileStat) ModTime() time.Time { return fs.modTime } -func (fs *fileStat) Sys() interface{} { return &fs.sys } +func (fs *fileStat) Sys() any { return &fs.sys } func sameFile(fs1, fs2 *fileStat) bool { return fs1.sys.Dev == fs2.sys.Dev && fs1.sys.Ino == fs2.sys.Ino diff --git a/src/os/types_windows.go b/src/os/types_windows.go index 59bf5ca381..5443dfedc8 100644 --- a/src/os/types_windows.go +++ b/src/os/types_windows.go @@ -138,7 +138,7 @@ func (fs *fileStat) ModTime() time.Time { } // Sys returns syscall.Win32FileAttributeData for file fs. -func (fs *fileStat) Sys() interface{} { +func (fs *fileStat) Sys() any { return &syscall.Win32FileAttributeData{ FileAttributes: fs.FileAttributes, CreationTime: fs.CreationTime, diff --git a/src/os/user/lookup_unix.go b/src/os/user/lookup_unix.go index e25323fbad..058dab1fb5 100644 --- a/src/os/user/lookup_unix.go +++ b/src/os/user/lookup_unix.go @@ -19,7 +19,7 @@ import ( const userFile = "/etc/passwd" // lineFunc returns a value, an error, or (nil, nil) to skip the row. -type lineFunc func(line []byte) (v interface{}, err error) +type lineFunc func(line []byte) (v any, err error) // readColonFile parses r as an /etc/group or /etc/passwd style file, running // fn for each row. readColonFile returns a value, an error, or (nil, nil) if @@ -27,7 +27,7 @@ type lineFunc func(line []byte) (v interface{}, err error) // // readCols is the minimum number of colon-separated fields that will be passed // to fn; in a long line additional fields may be silently discarded. -func readColonFile(r io.Reader, fn lineFunc, readCols int) (v interface{}, err error) { +func readColonFile(r io.Reader, fn lineFunc, readCols int) (v any, err error) { rd := bufio.NewReader(r) // Read the file line-by-line. @@ -98,7 +98,7 @@ func matchGroupIndexValue(value string, idx int) lineFunc { leadColon = ":" } substr := []byte(leadColon + value + ":") - return func(line []byte) (v interface{}, err error) { + return func(line []byte) (v any, err error) { if !bytes.Contains(line, substr) || bytes.Count(line, colon) < 3 { return } @@ -145,7 +145,7 @@ func matchUserIndexValue(value string, idx int) lineFunc { leadColon = ":" } substr := []byte(leadColon + value + ":") - return func(line []byte) (v interface{}, err error) { + return func(line []byte) (v any, err error) { if !bytes.Contains(line, substr) || bytes.Count(line, colon) < 6 { return } diff --git a/src/plugin/plugin.go b/src/plugin/plugin.go index 4a524bfa3f..b2a0fbe3ea 100644 --- a/src/plugin/plugin.go +++ b/src/plugin/plugin.go @@ -22,7 +22,7 @@ type Plugin struct { pluginpath string err string // set if plugin failed to load loaded chan struct{} // closed when loaded - syms map[string]interface{} + syms map[string]any } // Open opens a Go plugin. @@ -69,4 +69,4 @@ func (p *Plugin) Lookup(symName string) (Symbol, error) { // } // *v.(*int) = 7 // f.(func())() // prints "Hello, number 7" -type Symbol interface{} +type Symbol any diff --git a/src/plugin/plugin_dlopen.go b/src/plugin/plugin_dlopen.go index 5fff329fc5..c59f11ef71 100644 --- a/src/plugin/plugin_dlopen.go +++ b/src/plugin/plugin_dlopen.go @@ -102,7 +102,7 @@ func open(name string) (*Plugin, error) { } // Fill out the value of each plugin symbol. - updatedSyms := map[string]interface{}{} + updatedSyms := map[string]any{} for symName, sym := range syms { isFunc := symName[0] == '.' if isFunc { @@ -147,7 +147,7 @@ var ( ) // lastmoduleinit is defined in package runtime -func lastmoduleinit() (pluginpath string, syms map[string]interface{}, errstr string) +func lastmoduleinit() (pluginpath string, syms map[string]any, errstr string) // doInit is defined in package runtime //go:linkname doInit runtime.doInit diff --git a/src/reflect/abi_test.go b/src/reflect/abi_test.go index 41cfd9d082..f39eb5efea 100644 --- a/src/reflect/abi_test.go +++ b/src/reflect/abi_test.go @@ -33,7 +33,7 @@ func TestMethodValueCallABI(t *testing.T) { // for us, so there isn't a whole lot to do. Let's just // make sure that we can pass register and stack arguments // through. The exact combination is not super important. - makeMethodValue := func(method string) (*StructWithMethods, interface{}) { + makeMethodValue := func(method string) (*StructWithMethods, any) { s := new(StructWithMethods) v := reflect.ValueOf(s).MethodByName(method) return s, v.Interface() @@ -256,7 +256,7 @@ func TestReflectMakeFuncCallABI(t *testing.T) { }) } -var abiCallTestCases = []interface{}{ +var abiCallTestCases = []any{ passNone, passInt, passInt8, @@ -551,7 +551,7 @@ func passStruct10AndSmall(a Struct10, b byte, c uint) (Struct10, byte, uint) { return a, b, c } -var abiMakeFuncTestCases = []interface{}{ +var abiMakeFuncTestCases = []any{ callArgsNone, callArgsInt, callArgsInt8, diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go index 8c51d8ec26..9c8434c22c 100644 --- a/src/reflect/all_test.go +++ b/src/reflect/all_test.go @@ -29,7 +29,7 @@ import ( "unsafe" ) -var sink interface{} +var sink any func TestBool(t *testing.T) { v := ValueOf(true) @@ -47,7 +47,7 @@ type T struct { } type pair struct { - i interface{} + i any s string } @@ -337,7 +337,7 @@ func TestSetValue(t *testing.T) { } func TestMapIterSet(t *testing.T) { - m := make(map[string]interface{}, len(valueTests)) + m := make(map[string]any, len(valueTests)) for _, tt := range valueTests { m[tt.s] = tt.i } @@ -385,7 +385,7 @@ func TestCanIntUintFloatComplex(t *testing.T) { var ops = [...]string{"CanInt", "CanUint", "CanFloat", "CanComplex"} var testCases = []struct { - i interface{} + i any want [4]bool }{ // signed integer @@ -691,7 +691,7 @@ func TestAll(t *testing.T) { func TestInterfaceGet(t *testing.T) { var inter struct { - E interface{} + E any } inter.E = 123.456 v1 := ValueOf(&inter) @@ -704,7 +704,7 @@ func TestInterfaceGet(t *testing.T) { func TestInterfaceValue(t *testing.T) { var inter struct { - E interface{} + E any } inter.E = 123.456 v1 := ValueOf(&inter) @@ -720,7 +720,7 @@ func TestInterfaceValue(t *testing.T) { } func TestFunctionValue(t *testing.T) { - var x interface{} = func() {} + var x any = func() {} v := ValueOf(x) if fmt.Sprint(v.Interface()) != fmt.Sprint(x) { t.Fatalf("TestFunction returned wrong pointer") @@ -920,7 +920,7 @@ type Basic struct { type NotBasic Basic type DeepEqualTest struct { - a, b interface{} + a, b any eq bool } @@ -934,11 +934,11 @@ var ( type self struct{} type Loop *Loop -type Loopy interface{} +type Loopy any var loop1, loop2 Loop var loopy1, loopy2 Loopy -var cycleMap1, cycleMap2, cycleMap3 map[string]interface{} +var cycleMap1, cycleMap2, cycleMap3 map[string]any type structWithSelfPtr struct { p *structWithSelfPtr @@ -952,11 +952,11 @@ func init() { loopy1 = &loopy2 loopy2 = &loopy1 - cycleMap1 = map[string]interface{}{} + cycleMap1 = map[string]any{} cycleMap1["cycle"] = cycleMap1 - cycleMap2 = map[string]interface{}{} + cycleMap2 = map[string]any{} cycleMap2["cycle"] = cycleMap2 - cycleMap3 = map[string]interface{}{} + cycleMap3 = map[string]any{} cycleMap3["different"] = cycleMap3 } @@ -1021,7 +1021,7 @@ var deepEqualTests = []DeepEqualTest{ {int32(1), int64(1), false}, {0.5, "hello", false}, {[]int{1, 2, 3}, [3]int{1, 2, 3}, false}, - {&[3]interface{}{1, 2, 4}, &[3]interface{}{1, 2, "s"}, false}, + {&[3]any{1, 2, 4}, &[3]any{1, 2, "s"}, false}, {Basic{1, 0.5}, NotBasic{1, 0.5}, false}, {map[uint]string{1: "one", 2: "two"}, map[int]string{2: "two", 1: "one"}, false}, {[]byte{1, 2, 3}, []MyByte{1, 2, 3}, false}, @@ -1127,7 +1127,7 @@ func TestDeepEqualUnexportedMap(t *testing.T) { } var deepEqualPerfTests = []struct { - x, y interface{} + x, y any }{ {x: int8(99), y: int8(99)}, {x: []int8{99}, y: []int8{99}}, @@ -1202,7 +1202,7 @@ func BenchmarkDeepEqual(b *testing.B) { } } -func check2ndField(x interface{}, offs uintptr, t *testing.T) { +func check2ndField(x any, offs uintptr, t *testing.T) { s := ValueOf(x) f := s.Type().Field(1) if f.Offset != offs { @@ -1235,14 +1235,14 @@ func TestAlignment(t *testing.T) { check2ndField(x1, uintptr(unsafe.Pointer(&x1.f))-uintptr(unsafe.Pointer(&x1)), t) } -func Nil(a interface{}, t *testing.T) { +func Nil(a any, t *testing.T) { n := ValueOf(a).Field(0) if !n.IsNil() { t.Errorf("%v should be nil", a) } } -func NotNil(a interface{}, t *testing.T) { +func NotNil(a any, t *testing.T) { n := ValueOf(a).Field(0) if n.IsNil() { t.Errorf("value of type %v should not be nil", ValueOf(a).Type().String()) @@ -1252,9 +1252,9 @@ func NotNil(a interface{}, t *testing.T) { func TestIsNil(t *testing.T) { // These implement IsNil. // Wrap in extra struct to hide interface type. - doNil := []interface{}{ + doNil := []any{ struct{ x *int }{}, - struct{ x interface{} }{}, + struct{ x any }{}, struct{ x map[string]int }{}, struct{ x func() bool }{}, struct{ x chan int }{}, @@ -1297,7 +1297,7 @@ func TestIsNil(t *testing.T) { NotNil(mi, t) var ii struct { - x interface{} + x any } Nil(ii, t) ii.x = 2 @@ -1313,7 +1313,7 @@ func TestIsNil(t *testing.T) { func TestIsZero(t *testing.T) { for i, tt := range []struct { - x interface{} + x any want bool }{ // Booleans @@ -1425,7 +1425,7 @@ func TestInterfaceExtraction(t *testing.T) { s.W = os.Stdout v := Indirect(ValueOf(&s)).Field(0).Interface() - if v != s.W.(interface{}) { + if v != s.W.(any) { t.Error("Interface() on interface: ", v, s.W) } } @@ -1974,7 +1974,7 @@ func selectWatcher() { // runSelect runs a single select test. // It returns the values returned by Select but also returns // a panic value if the Select panics. -func runSelect(cases []SelectCase, info []caseInfo) (chosen int, recv Value, recvOK bool, panicErr interface{}) { +func runSelect(cases []SelectCase, info []caseInfo) (chosen int, recv Value, recvOK bool, panicErr any) { defer func() { panicErr = recover() @@ -2765,7 +2765,7 @@ func TestMethod5(t *testing.T) { var TinterType = TypeOf(new(Tinter)).Elem() - CheckI := func(name string, i interface{}, inc int) { + CheckI := func(name string, i any, inc int) { v := ValueOf(i) CheckV(name, v, inc) CheckV("(i="+name+")", v.Convert(TinterType), inc) @@ -2814,7 +2814,7 @@ func TestInterfaceSet(t *testing.T) { p := &Point{3, 4} var s struct { - I interface{} + I any P interface { Dist(int) int } @@ -2856,7 +2856,7 @@ func TestAnonymousFields(t *testing.T) { } type FTest struct { - s interface{} + s any name string index []int value int @@ -3087,7 +3087,7 @@ func TestImportPath(t *testing.T) { {TypeOf([]byte(nil)), ""}, {TypeOf([]rune(nil)), ""}, {TypeOf(string("")), ""}, - {TypeOf((*interface{})(nil)).Elem(), ""}, + {TypeOf((*any)(nil)).Elem(), ""}, {TypeOf((*byte)(nil)), ""}, {TypeOf((*rune)(nil)), ""}, {TypeOf((*int64)(nil)), ""}, @@ -3290,7 +3290,7 @@ func TestEmbeddedMethods(t *testing.T) { } } -type FuncDDD func(...interface{}) error +type FuncDDD func(...any) error func (f FuncDDD) M() {} @@ -3328,7 +3328,7 @@ func TestPtrToGC(t *testing.T) { tt := TypeOf(T(nil)) pt := PointerTo(tt) const n = 100 - var x []interface{} + var x []any for i := 0; i < n; i++ { v := New(pt) p := new(*uintptr) @@ -3450,7 +3450,7 @@ func noAlloc(t *testing.T, n int, f func(int)) { func TestAllocations(t *testing.T) { noAlloc(t, 100, func(j int) { - var i interface{} + var i any var v Value // We can uncomment this when compiler escape analysis @@ -3624,7 +3624,7 @@ func TestVariadic(t *testing.T) { } b.Reset() - V(fmt.Fprintf).CallSlice([]Value{V(&b), V("%s, %d world"), V([]interface{}{"hello", 42})}) + V(fmt.Fprintf).CallSlice([]Value{V(&b), V("%s, %d world"), V([]any{"hello", 42})}) if b.String() != "hello, 42 world" { t.Errorf("after Fprintf CallSlice: %q != %q", b.String(), "hello 42 world") } @@ -3967,7 +3967,7 @@ func shouldPanic(expect string, f func()) { f() } -func isNonNil(x interface{}) { +func isNonNil(x any) { if x == nil { panic("nil interface") } @@ -3993,7 +3993,7 @@ func TestAlias(t *testing.T) { var V = ValueOf -func EmptyInterfaceV(x interface{}) Value { +func EmptyInterfaceV(x any) Value { return ValueOf(&x).Elem() } @@ -4434,7 +4434,7 @@ var convertTests = []struct { {V((map[uint]bool)(nil)), V((map[uint]bool)(nil))}, {V([]uint(nil)), V([]uint(nil))}, {V([]int(nil)), V([]int(nil))}, - {V(new(interface{})), V(new(interface{}))}, + {V(new(any)), V(new(any))}, {V(new(io.Reader)), V(new(io.Reader))}, {V(new(io.Writer)), V(new(io.Writer))}, @@ -4633,7 +4633,7 @@ var comparableTests = []struct { {TypeOf(NonComparableStruct{}), false}, {TypeOf([10]map[string]int{}), false}, {TypeOf([10]string{}), true}, - {TypeOf(new(interface{})).Elem(), true}, + {TypeOf(new(any)).Elem(), true}, } func TestComparable(t *testing.T) { @@ -4683,7 +4683,7 @@ func TestOverflow(t *testing.T) { } } -func checkSameType(t *testing.T, x Type, y interface{}) { +func checkSameType(t *testing.T, x Type, y any) { if x != TypeOf(y) || TypeOf(Zero(x).Interface()) != TypeOf(y) { t.Errorf("did not find preexisting type for %s (vs %s)", TypeOf(x), TypeOf(y)) } @@ -4693,73 +4693,73 @@ func TestArrayOf(t *testing.T) { // check construction and use of type not in binary tests := []struct { n int - value func(i int) interface{} + value func(i int) any comparable bool want string }{ { n: 0, - value: func(i int) interface{} { type Tint int; return Tint(i) }, + value: func(i int) any { type Tint int; return Tint(i) }, comparable: true, want: "[]", }, { n: 10, - value: func(i int) interface{} { type Tint int; return Tint(i) }, + value: func(i int) any { type Tint int; return Tint(i) }, comparable: true, want: "[0 1 2 3 4 5 6 7 8 9]", }, { n: 10, - value: func(i int) interface{} { type Tfloat float64; return Tfloat(i) }, + value: func(i int) any { type Tfloat float64; return Tfloat(i) }, comparable: true, want: "[0 1 2 3 4 5 6 7 8 9]", }, { n: 10, - value: func(i int) interface{} { type Tstring string; return Tstring(strconv.Itoa(i)) }, + value: func(i int) any { type Tstring string; return Tstring(strconv.Itoa(i)) }, comparable: true, want: "[0 1 2 3 4 5 6 7 8 9]", }, { n: 10, - value: func(i int) interface{} { type Tstruct struct{ V int }; return Tstruct{i} }, + value: func(i int) any { type Tstruct struct{ V int }; return Tstruct{i} }, comparable: true, want: "[{0} {1} {2} {3} {4} {5} {6} {7} {8} {9}]", }, { n: 10, - value: func(i int) interface{} { type Tint int; return []Tint{Tint(i)} }, + value: func(i int) any { type Tint int; return []Tint{Tint(i)} }, comparable: false, want: "[[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]]", }, { n: 10, - value: func(i int) interface{} { type Tint int; return [1]Tint{Tint(i)} }, + value: func(i int) any { type Tint int; return [1]Tint{Tint(i)} }, comparable: true, want: "[[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]]", }, { n: 10, - value: func(i int) interface{} { type Tstruct struct{ V [1]int }; return Tstruct{[1]int{i}} }, + value: func(i int) any { type Tstruct struct{ V [1]int }; return Tstruct{[1]int{i}} }, comparable: true, want: "[{[0]} {[1]} {[2]} {[3]} {[4]} {[5]} {[6]} {[7]} {[8]} {[9]}]", }, { n: 10, - value: func(i int) interface{} { type Tstruct struct{ V []int }; return Tstruct{[]int{i}} }, + value: func(i int) any { type Tstruct struct{ V []int }; return Tstruct{[]int{i}} }, comparable: false, want: "[{[0]} {[1]} {[2]} {[3]} {[4]} {[5]} {[6]} {[7]} {[8]} {[9]}]", }, { n: 10, - value: func(i int) interface{} { type TstructUV struct{ U, V int }; return TstructUV{i, i} }, + value: func(i int) any { type TstructUV struct{ U, V int }; return TstructUV{i, i} }, comparable: true, want: "[{0 0} {1 1} {2 2} {3 3} {4 4} {5 5} {6 6} {7 7} {8 8} {9 9}]", }, { n: 10, - value: func(i int) interface{} { + value: func(i int) any { type TstructUV struct { U int V float64 @@ -4820,7 +4820,7 @@ func TestArrayOfGC(t *testing.T) { type T *uintptr tt := TypeOf(T(nil)) const n = 100 - var x []interface{} + var x []any for i := 0; i < n; i++ { v := New(ArrayOf(n, tt)).Elem() for j := 0; j < v.Len(); j++ { @@ -4984,7 +4984,7 @@ func TestSliceOfGC(t *testing.T) { tt := TypeOf(T(nil)) st := SliceOf(tt) const n = 100 - var x []interface{} + var x []any for i := 0; i < n; i++ { v := MakeSlice(st, n, n) for j := 0; j < v.Len(); j++ { @@ -5174,7 +5174,7 @@ func TestStructOf(t *testing.T) { checkSameType(t, StructOf(fields[2:3]), struct{ Y uint64 }{}) // gccgo used to fail this test. - type structFieldType interface{} + type structFieldType any checkSameType(t, StructOf([]StructField{ { @@ -5350,7 +5350,7 @@ func TestStructOfGC(t *testing.T) { st := StructOf(fields) const n = 10000 - var x []interface{} + var x []any for i := 0; i < n; i++ { v := New(st).Elem() for j := 0; j < v.NumField(); j++ { @@ -5616,7 +5616,7 @@ func TestStructOfWithInterface(t *testing.T) { { name: "StructI", typ: PointerTo(TypeOf(StructI(want))), - val: ValueOf(func() interface{} { + val: ValueOf(func() any { v := StructI(want) return &v }()), @@ -5625,7 +5625,7 @@ func TestStructOfWithInterface(t *testing.T) { { name: "StructIPtr", typ: PointerTo(TypeOf(StructIPtr(want))), - val: ValueOf(func() interface{} { + val: ValueOf(func() any { v := StructIPtr(want) return &v }()), @@ -5887,7 +5887,7 @@ func TestChanOfGC(t *testing.T) { // so we have to save pointers to channels in x; the pointer code will // use the gc info in the newly constructed chan type. const n = 100 - var x []interface{} + var x []any for i := 0; i < n; i++ { v := MakeChan(ct, n) for j := 0; j < n; j++ { @@ -5945,7 +5945,7 @@ func TestMapOfGCKeys(t *testing.T) { // so we have to save pointers to maps in x; the pointer code will // use the gc info in the newly constructed map type. const n = 100 - var x []interface{} + var x []any for i := 0; i < n; i++ { v := MakeMap(mt) for j := 0; j < n; j++ { @@ -5983,7 +5983,7 @@ func TestMapOfGCValues(t *testing.T) { // so we have to save pointers to maps in x; the pointer code will // use the gc info in the newly constructed map type. const n = 100 - var x []interface{} + var x []any for i := 0; i < n; i++ { v := MakeMap(mt) for j := 0; j < n; j++ { @@ -6051,7 +6051,7 @@ func TestFuncOf(t *testing.T) { testCases := []struct { in, out []Type variadic bool - want interface{} + want any }{ {in: []Type{TypeOf(T1(0))}, want: (func(T1))(nil)}, {in: []Type{TypeOf(int(0))}, want: (func(int))(nil)}, @@ -6544,7 +6544,7 @@ func TestValueString(t *testing.T) { func TestInvalid(t *testing.T) { // Used to have inconsistency between IsValid() and Kind() != Invalid. - type T struct{ v interface{} } + type T struct{ v any } v := ValueOf(T{}).Field(0) if v.IsValid() != true || v.Kind() != Interface { @@ -6562,7 +6562,7 @@ func TestLargeGCProg(t *testing.T) { fv.Call([]Value{ValueOf([256]*byte{})}) } -func fieldIndexRecover(t Type, i int) (recovered interface{}) { +func fieldIndexRecover(t Type, i int) (recovered any) { defer func() { recovered = recover() }() @@ -6736,7 +6736,7 @@ func TestFuncLayout(t *testing.T) { gc: r, }, { - typ: ValueOf(func(a map[int]int, b uintptr, c interface{}) {}).Type(), + typ: ValueOf(func(a map[int]int, b uintptr, c any) {}).Type(), size: 4 * goarch.PtrSize, argsize: 4 * goarch.PtrSize, retOffset: 4 * goarch.PtrSize, @@ -6989,7 +6989,7 @@ func TestGCBits(t *testing.T) { hdr := make([]byte, 8/goarch.PtrSize) - verifyMapBucket := func(t *testing.T, k, e Type, m interface{}, want []byte) { + verifyMapBucket := func(t *testing.T, k, e Type, m any, want []byte) { verifyGCBits(t, MapBucketOf(k, e), want) verifyGCBits(t, CachedBucketOf(TypeOf(m)), want) } @@ -7118,7 +7118,7 @@ func TestChanAlloc(t *testing.T) { type TheNameOfThisTypeIsExactly255BytesLongSoWhenTheCompilerPrependsTheReflectTestPackageNameAndExtraStarTheLinkerRuntimeAndReflectPackagesWillHaveToCorrectlyDecodeTheSecondLengthByte0123456789_0123456789_0123456789_0123456789_0123456789_012345678 int type nameTest struct { - v interface{} + v any want string } @@ -7130,7 +7130,7 @@ var nameTests = []nameTest{ {(*func() D1)(nil), ""}, {(*<-chan D1)(nil), ""}, {(*chan<- D1)(nil), ""}, - {(*interface{})(nil), ""}, + {(*any)(nil), ""}, {(*interface { F() })(nil), ""}, @@ -7156,7 +7156,7 @@ func TestExported(t *testing.T) { type p3 p type exportTest struct { - v interface{} + v any want bool } exportTests := []exportTest{ @@ -7291,9 +7291,9 @@ func TestSwapper(t *testing.T) { type S string tests := []struct { - in interface{} + in any i, j int - want interface{} + want any }{ { in: []int{1, 20, 300}, @@ -7707,7 +7707,7 @@ func TestSetIter(t *testing.T) { }) // Make sure assignment conversion works. - var x interface{} + var x any y := ValueOf(&x).Elem() y.SetIterKey(i) if _, ok := data[x.(string)]; !ok { diff --git a/src/reflect/deepequal.go b/src/reflect/deepequal.go index b71504fa21..eaab101221 100644 --- a/src/reflect/deepequal.go +++ b/src/reflect/deepequal.go @@ -225,7 +225,7 @@ func deepValueEqual(v1, v2 Value, visited map[visit]bool) bool { // values that have been compared before, it treats the values as // equal rather than examining the values to which they point. // This ensures that DeepEqual terminates. -func DeepEqual(x, y interface{}) bool { +func DeepEqual(x, y any) bool { if x == nil || y == nil { return x == y } diff --git a/src/reflect/example_test.go b/src/reflect/example_test.go index 684bafd648..3db971c3ae 100644 --- a/src/reflect/example_test.go +++ b/src/reflect/example_test.go @@ -14,7 +14,7 @@ import ( ) func ExampleKind() { - for _, v := range []interface{}{"hi", 42, func() {}} { + for _, v := range []any{"hi", 42, func() {}} { switch v := reflect.ValueOf(v); v.Kind() { case reflect.String: fmt.Println(v.String()) @@ -45,7 +45,7 @@ func ExampleMakeFunc() { // When the function is invoked, reflect turns the arguments // into Values, calls swap, and then turns swap's result slice // into the values returned by the new function. - makeSwap := func(fptr interface{}) { + makeSwap := func(fptr any) { // fptr is a pointer to a function. // Obtain the function value itself (likely nil) as a reflect.Value // so that we can query its type and then set the value. diff --git a/src/reflect/export_test.go b/src/reflect/export_test.go index ba7fb68067..a5a3c1c271 100644 --- a/src/reflect/export_test.go +++ b/src/reflect/export_test.go @@ -88,7 +88,7 @@ func TypeLinks() []string { var GCBits = gcbits -func gcbits(interface{}) []byte // provided by runtime +func gcbits(any) []byte // provided by runtime func MapBucketOf(x, y Type) Type { return bucketOf(x.(*rtype), y.(*rtype)) diff --git a/src/reflect/set_test.go b/src/reflect/set_test.go index 566dc7fb65..9ce0e09b82 100644 --- a/src/reflect/set_test.go +++ b/src/reflect/set_test.go @@ -31,7 +31,7 @@ func TestImplicitMapConversion(t *testing.T) { } { // convert interface key - m := make(map[interface{}]int) + m := make(map[any]int) mv := ValueOf(m) mv.SetMapIndex(ValueOf(1), ValueOf(2)) x, ok := m[1] @@ -44,7 +44,7 @@ func TestImplicitMapConversion(t *testing.T) { } { // convert interface value - m := make(map[int]interface{}) + m := make(map[int]any) mv := ValueOf(m) mv.SetMapIndex(ValueOf(1), ValueOf(2)) x, ok := m[1] @@ -57,7 +57,7 @@ func TestImplicitMapConversion(t *testing.T) { } { // convert both interface key and interface value - m := make(map[interface{}]interface{}) + m := make(map[any]any) mv := ValueOf(m) mv.SetMapIndex(ValueOf(1), ValueOf(2)) x, ok := m[1] @@ -160,8 +160,8 @@ func TestImplicitAppendConversion(t *testing.T) { } var implementsTests = []struct { - x interface{} - t interface{} + x any + t any b bool }{ {new(*bytes.Buffer), new(io.Reader), true}, @@ -198,8 +198,8 @@ func TestImplements(t *testing.T) { } var assignableTests = []struct { - x interface{} - t interface{} + x any + t any b bool }{ {new(chan int), new(<-chan int), true}, @@ -207,13 +207,13 @@ var assignableTests = []struct { {new(*int), new(IntPtr), true}, {new(IntPtr), new(*int), true}, {new(IntPtr), new(IntPtr1), false}, - {new(Ch), new(<-chan interface{}), true}, + {new(Ch), new(<-chan any), true}, // test runs implementsTests too } type IntPtr *int type IntPtr1 *int -type Ch <-chan interface{} +type Ch <-chan any func TestAssignableTo(t *testing.T) { for _, tt := range append(assignableTests, implementsTests...) { diff --git a/src/reflect/swapper.go b/src/reflect/swapper.go index 67b7fbe59b..745c7b9f49 100644 --- a/src/reflect/swapper.go +++ b/src/reflect/swapper.go @@ -14,7 +14,7 @@ import ( // slice. // // Swapper panics if the provided interface is not a slice. -func Swapper(slice interface{}) func(i, j int) { +func Swapper(slice any) func(i, j int) { v := ValueOf(slice) if v.Kind() != Slice { panic(&ValueError{Method: "Swapper", Kind: v.Kind()}) diff --git a/src/reflect/type.go b/src/reflect/type.go index 4701e06c49..6217291a3f 100644 --- a/src/reflect/type.go +++ b/src/reflect/type.go @@ -1414,7 +1414,7 @@ func (t *structType) FieldByName(name string) (f StructField, present bool) { // TypeOf returns the reflection Type that represents the dynamic type of i. // If i is a nil interface value, TypeOf returns nil. -func TypeOf(i interface{}) Type { +func TypeOf(i any) Type { eface := *(*emptyInterface)(unsafe.Pointer(&i)) return toType(eface.typ) } @@ -1458,7 +1458,7 @@ func (t *rtype) ptrTo() *rtype { // Create a new ptrType starting with the description // of an *unsafe.Pointer. - var iptr interface{} = (*unsafe.Pointer)(nil) + var iptr any = (*unsafe.Pointer)(nil) prototype := *(**ptrType)(unsafe.Pointer(&iptr)) pp := *prototype @@ -1876,7 +1876,7 @@ func ChanOf(dir ChanDir, t Type) Type { } // Make a channel type. - var ichan interface{} = (chan unsafe.Pointer)(nil) + var ichan any = (chan unsafe.Pointer)(nil) prototype := *(**chanType)(unsafe.Pointer(&ichan)) ch := *prototype ch.tflag = tflagRegularMemory @@ -1922,7 +1922,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/reflectdata/reflect.go:writeType. - var imap interface{} = (map[unsafe.Pointer]unsafe.Pointer)(nil) + var imap any = (map[unsafe.Pointer]unsafe.Pointer)(nil) mt := **(**mapType)(unsafe.Pointer(&imap)) mt.str = resolveReflectName(newName(s, "", false)) mt.tflag = 0 @@ -2002,7 +2002,7 @@ func FuncOf(in, out []Type, variadic bool) Type { } // Make a func type. - var ifunc interface{} = (func())(nil) + var ifunc any = (func())(nil) prototype := *(**funcType)(unsafe.Pointer(&ifunc)) n := len(in) + len(out) @@ -2360,7 +2360,7 @@ func SliceOf(t Type) Type { } // Make a slice type. - var islice interface{} = ([]unsafe.Pointer)(nil) + var islice any = ([]unsafe.Pointer)(nil) prototype := *(**sliceType)(unsafe.Pointer(&islice)) slice := *prototype slice.tflag = 0 @@ -2688,7 +2688,7 @@ func StructOf(fields []StructField) Type { size = align(size, uintptr(typalign)) // Make the struct type. - var istruct interface{} = struct{}{} + var istruct any = struct{}{} prototype := *(**structType)(unsafe.Pointer(&istruct)) *typ = *prototype typ.fields = fs @@ -2908,7 +2908,7 @@ func ArrayOf(length int, elem Type) Type { } // Make an array type. - var iarray interface{} = [1]unsafe.Pointer{} + var iarray any = [1]unsafe.Pointer{} prototype := *(**arrayType)(unsafe.Pointer(&iarray)) array := *prototype array.tflag = typ.tflag & tflagRegularMemory @@ -3095,7 +3095,7 @@ func funcLayout(t *funcType, rcvr *rtype) (frametype *rtype, framePool *sync.Poo x.str = resolveReflectName(newName(s, "", false)) // cache result for future callers - framePool = &sync.Pool{New: func() interface{} { + framePool = &sync.Pool{New: func() any { return unsafe_New(x) }} lti, _ := layoutCache.LoadOrStore(k, layoutType{ diff --git a/src/reflect/value.go b/src/reflect/value.go index 02354f2736..dcc359dae4 100644 --- a/src/reflect/value.go +++ b/src/reflect/value.go @@ -104,9 +104,9 @@ func (v Value) pointer() unsafe.Pointer { } // packEface converts v to the empty interface. -func packEface(v Value) interface{} { +func packEface(v Value) any { t := v.typ - var i interface{} + var i any e := (*emptyInterface)(unsafe.Pointer(&i)) // First, fill in the data portion of the interface. switch { @@ -141,7 +141,7 @@ func packEface(v Value) interface{} { } // unpackEface converts the empty interface i to a Value. -func unpackEface(i interface{}) Value { +func unpackEface(i any) Value { e := (*emptyInterface)(unsafe.Pointer(&i)) // NOTE: don't read e.word until we know whether it is really a pointer or not. t := e.typ @@ -1167,11 +1167,11 @@ func (v Value) Elem() Value { k := v.kind() switch k { case Interface: - var eface interface{} + var eface any if v.typ.NumMethod() == 0 { - eface = *(*interface{})(v.ptr) + eface = *(*any)(v.ptr) } else { - eface = (interface{})(*(*interface { + eface = (any)(*(*interface { M() })(v.ptr)) } @@ -1426,11 +1426,11 @@ func (v Value) CanInterface() bool { // var i interface{} = (v's underlying value) // It panics if the Value was obtained by accessing // unexported struct fields. -func (v Value) Interface() (i interface{}) { +func (v Value) Interface() (i any) { return valueInterface(v, true) } -func valueInterface(v Value, safe bool) interface{} { +func valueInterface(v Value, safe bool) any { if v.flag == 0 { panic(&ValueError{"reflect.Value.Interface", Invalid}) } @@ -1449,7 +1449,7 @@ func valueInterface(v Value, safe bool) interface{} { // Empty interface has one layout, all interfaces with // methods have a second layout. if v.NumMethod() == 0 { - return *(*interface{})(v.ptr) + return *(*any)(v.ptr) } return *(*interface { M() @@ -2954,7 +2954,7 @@ func Indirect(v Value) Value { // ValueOf returns a new Value initialized to the concrete value // stored in the interface i. ValueOf(nil) returns the zero Value. -func ValueOf(i interface{}) Value { +func ValueOf(i any) Value { if i == nil { return Value{} } @@ -3051,7 +3051,7 @@ func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value } x := valueInterface(v, false) if dst.NumMethod() == 0 { - *(*interface{})(target) = x + *(*any)(target) = x } else { ifaceE2I(dst, x, target) } @@ -3382,7 +3382,7 @@ func cvtT2I(v Value, typ Type) Value { target := unsafe_New(typ.common()) x := valueInterface(v, false) if typ.NumMethod() == 0 { - *(*interface{})(target) = x + *(*any)(target) = x } else { ifaceE2I(typ.(*rtype), x, target) } @@ -3481,7 +3481,7 @@ func maplen(m unsafe.Pointer) int //go:linkname call runtime.reflectcall func call(stackArgsType *rtype, f, stackArgs unsafe.Pointer, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs) -func ifaceE2I(t *rtype, src interface{}, dst unsafe.Pointer) +func ifaceE2I(t *rtype, src any, dst unsafe.Pointer) // memmove copies size bytes to dst from src. No write barriers are used. //go:noescape @@ -3518,7 +3518,7 @@ func verifyNotInHeapPtr(p uintptr) bool // Dummy annotation marking that the value x escapes, // for use in cases where the reflect code is so clever that // the compiler cannot follow. -func escapes(x interface{}) { +func escapes(x any) { if dummy.b { dummy.x = x } @@ -3526,5 +3526,5 @@ func escapes(x interface{}) { var dummy struct { b bool - x interface{} + x any } diff --git a/src/reflect/visiblefields_test.go b/src/reflect/visiblefields_test.go index 5ae322321b..fdedc21f73 100644 --- a/src/reflect/visiblefields_test.go +++ b/src/reflect/visiblefields_test.go @@ -17,7 +17,7 @@ type structField struct { var fieldsTests = []struct { testName string - val interface{} + val any expect []structField }{{ testName: "SimpleStruct", @@ -279,7 +279,7 @@ type RS3 struct { RS1 } -type M map[string]interface{} +type M map[string]any type Rec1 struct { *Rec2 diff --git a/src/runtime/abi_test.go b/src/runtime/abi_test.go index 5c1f1f4067..f9e8d701ce 100644 --- a/src/runtime/abi_test.go +++ b/src/runtime/abi_test.go @@ -78,7 +78,7 @@ func TestFinalizerRegisterABI(t *testing.T) { tests := []struct { name string - fin interface{} + fin any confirmValue int }{ {"Pointer", regFinalizerPointer, -1}, diff --git a/src/runtime/alg.go b/src/runtime/alg.go index 978a3b85dc..5d7d1c77f4 100644 --- a/src/runtime/alg.go +++ b/src/runtime/alg.go @@ -290,7 +290,7 @@ func int64Hash(i uint64, seed uintptr) uintptr { return memhash64(noescape(unsafe.Pointer(&i)), seed) } -func efaceHash(i interface{}, seed uintptr) uintptr { +func efaceHash(i any, seed uintptr) uintptr { return nilinterhash(noescape(unsafe.Pointer(&i)), seed) } diff --git a/src/runtime/cgo.go b/src/runtime/cgo.go index 395d54a66e..d90468240d 100644 --- a/src/runtime/cgo.go +++ b/src/runtime/cgo.go @@ -42,7 +42,7 @@ var cgoHasExtraM bool // 2) they keep the argument alive until the call site; the call is emitted after // the end of the (presumed) use of the argument by C. // cgoUse should not actually be called (see cgoAlwaysFalse). -func cgoUse(interface{}) { throw("cgoUse should not be called") } +func cgoUse(any) { throw("cgoUse should not be called") } // cgoAlwaysFalse is a boolean value that is always false. // The cgo-generated code says if cgoAlwaysFalse { cgoUse(p) }. diff --git a/src/runtime/cgo/handle.go b/src/runtime/cgo/handle.go index 726f0a396d..d711900d79 100644 --- a/src/runtime/cgo/handle.go +++ b/src/runtime/cgo/handle.go @@ -105,7 +105,7 @@ type Handle uintptr // // The intended use is to pass the returned handle to C code, which // passes it back to Go, which calls Value. -func NewHandle(v interface{}) Handle { +func NewHandle(v any) Handle { h := atomic.AddUintptr(&handleIdx, 1) if h == 0 { panic("runtime/cgo: ran out of handle space") @@ -118,7 +118,7 @@ func NewHandle(v interface{}) Handle { // Value returns the associated Go value for a valid handle. // // The method panics if the handle is invalid. -func (h Handle) Value() interface{} { +func (h Handle) Value() any { v, ok := handles.Load(uintptr(h)) if !ok { panic("runtime/cgo: misuse of an invalid Handle") diff --git a/src/runtime/cgo/handle_test.go b/src/runtime/cgo/handle_test.go index 738051a0ea..b341c8e1e4 100644 --- a/src/runtime/cgo/handle_test.go +++ b/src/runtime/cgo/handle_test.go @@ -13,8 +13,8 @@ func TestHandle(t *testing.T) { v := 42 tests := []struct { - v1 interface{} - v2 interface{} + v1 any + v2 any }{ {v1: v, v2: v}, {v1: &v, v2: &v}, @@ -44,7 +44,7 @@ func TestHandle(t *testing.T) { } siz := 0 - handles.Range(func(k, v interface{}) bool { + handles.Range(func(k, v any) bool { siz++ return true }) diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go index 694b3e66cd..a0c9560fd0 100644 --- a/src/runtime/cgocall.go +++ b/src/runtime/cgocall.go @@ -389,7 +389,7 @@ var racecgosync uint64 // represents possible synchronization in C code // cgoCheckPointer checks if the argument contains a Go pointer that // points to a Go pointer, and panics if it does. -func cgoCheckPointer(ptr interface{}, arg interface{}) { +func cgoCheckPointer(ptr any, arg any) { if debug.cgocheck == 0 { return } @@ -628,7 +628,7 @@ func cgoInRange(p unsafe.Pointer, start, end uintptr) bool { // cgoCheckResult is called to check the result parameter of an // exported Go function. It panics if the result is or contains a Go // pointer. -func cgoCheckResult(val interface{}) { +func cgoCheckResult(val any) { if debug.cgocheck == 0 { return } diff --git a/src/runtime/chan_test.go b/src/runtime/chan_test.go index 355267c5e3..9471d4596c 100644 --- a/src/runtime/chan_test.go +++ b/src/runtime/chan_test.go @@ -494,7 +494,7 @@ func TestSelectFairness(t *testing.T) { func TestChanSendInterface(t *testing.T) { type mt struct{} m := &mt{} - c := make(chan interface{}, 1) + c := make(chan any, 1) c <- m select { case c <- m: diff --git a/src/runtime/crash_test.go b/src/runtime/crash_test.go index 01b1ebcdd7..9b9ab4f3e1 100644 --- a/src/runtime/crash_test.go +++ b/src/runtime/crash_test.go @@ -403,7 +403,7 @@ func TestRuntimePanicWithRuntimeError(t *testing.T) { } } -func panicValue(fn func()) (recovered interface{}) { +func panicValue(fn func()) (recovered any) { defer func() { recovered = recover() }() diff --git a/src/runtime/debug/garbage_test.go b/src/runtime/debug/garbage_test.go index c3501408dd..7213bbe641 100644 --- a/src/runtime/debug/garbage_test.go +++ b/src/runtime/debug/garbage_test.go @@ -151,8 +151,8 @@ func TestFreeOSMemory(t *testing.T) { } var ( - setGCPercentBallast interface{} - setGCPercentSink interface{} + setGCPercentBallast any + setGCPercentSink any ) func TestSetGCPercent(t *testing.T) { diff --git a/src/runtime/debugcall.go b/src/runtime/debugcall.go index 005a259f28..205971c428 100644 --- a/src/runtime/debugcall.go +++ b/src/runtime/debugcall.go @@ -16,7 +16,7 @@ const ( ) func debugCallV2() -func debugCallPanicked(val interface{}) +func debugCallPanicked(val any) // debugCallCheck checks whether it is safe to inject a debugger // function call with return PC pc. If not, it returns a string diff --git a/src/runtime/debuglog.go b/src/runtime/debuglog.go index 588b54d1f5..75b91c4216 100644 --- a/src/runtime/debuglog.go +++ b/src/runtime/debuglog.go @@ -266,7 +266,7 @@ func (l *dlogger) hex(x uint64) *dlogger { } //go:nosplit -func (l *dlogger) p(x interface{}) *dlogger { +func (l *dlogger) p(x any) *dlogger { if !dlogEnabled { return l } diff --git a/src/runtime/defer_test.go b/src/runtime/defer_test.go index 821db0ca12..3a54951c31 100644 --- a/src/runtime/defer_test.go +++ b/src/runtime/defer_test.go @@ -433,7 +433,7 @@ func TestIssue43921(t *testing.T) { }() } -func expect(t *testing.T, n int, err interface{}) { +func expect(t *testing.T, n int, err any) { if n != err { t.Fatalf("have %v, want %v", err, n) } diff --git a/src/runtime/error.go b/src/runtime/error.go index 91f83ae126..43114f092e 100644 --- a/src/runtime/error.go +++ b/src/runtime/error.go @@ -210,7 +210,7 @@ type stringer interface { // printany prints an argument passed to panic. // If panic is called with a value that has a String or Error method, // it has already been converted into a string by preprintpanics. -func printany(i interface{}) { +func printany(i any) { switch v := i.(type) { case nil: print("nil") @@ -253,7 +253,7 @@ func printany(i interface{}) { } } -func printanycustomtype(i interface{}) { +func printanycustomtype(i any) { eface := efaceOf(&i) typestring := eface._type.string() diff --git a/src/runtime/export_debug_test.go b/src/runtime/export_debug_test.go index fffc99d7e5..19a9ec135f 100644 --- a/src/runtime/export_debug_test.go +++ b/src/runtime/export_debug_test.go @@ -22,7 +22,7 @@ import ( // // On success, InjectDebugCall returns the panic value of fn or nil. // If fn did not panic, its results will be available in args. -func InjectDebugCall(gp *g, fn interface{}, regArgs *abi.RegArgs, stackArgs interface{}, tkill func(tid int) error, returnOnUnsafePoint bool) (interface{}, error) { +func InjectDebugCall(gp *g, fn any, regArgs *abi.RegArgs, stackArgs any, tkill func(tid int) error, returnOnUnsafePoint bool) (any, error) { if gp.lockedm == 0 { return nil, plainError("goroutine not locked to thread") } @@ -96,7 +96,7 @@ type debugCallHandler struct { regArgs *abi.RegArgs argp unsafe.Pointer argSize uintptr - panic interface{} + panic any handleF func(info *siginfo, ctxt *sigctxt, gp2 *g) bool diff --git a/src/runtime/export_debuglog_test.go b/src/runtime/export_debuglog_test.go index 8cd943b438..1a9074e646 100644 --- a/src/runtime/export_debuglog_test.go +++ b/src/runtime/export_debuglog_test.go @@ -14,15 +14,15 @@ const DebugLogStringLimit = debugLogStringLimit var Dlog = dlog -func (l *dlogger) End() { l.end() } -func (l *dlogger) B(x bool) *dlogger { return l.b(x) } -func (l *dlogger) I(x int) *dlogger { return l.i(x) } -func (l *dlogger) I16(x int16) *dlogger { return l.i16(x) } -func (l *dlogger) U64(x uint64) *dlogger { return l.u64(x) } -func (l *dlogger) Hex(x uint64) *dlogger { return l.hex(x) } -func (l *dlogger) P(x interface{}) *dlogger { return l.p(x) } -func (l *dlogger) S(x string) *dlogger { return l.s(x) } -func (l *dlogger) PC(x uintptr) *dlogger { return l.pc(x) } +func (l *dlogger) End() { l.end() } +func (l *dlogger) B(x bool) *dlogger { return l.b(x) } +func (l *dlogger) I(x int) *dlogger { return l.i(x) } +func (l *dlogger) I16(x int16) *dlogger { return l.i16(x) } +func (l *dlogger) U64(x uint64) *dlogger { return l.u64(x) } +func (l *dlogger) Hex(x uint64) *dlogger { return l.hex(x) } +func (l *dlogger) P(x any) *dlogger { return l.p(x) } +func (l *dlogger) S(x string) *dlogger { return l.s(x) } +func (l *dlogger) PC(x uintptr) *dlogger { return l.pc(x) } func DumpDebugLog() string { g := getg() diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go index 4a03f24ded..3c8f9eb49b 100644 --- a/src/runtime/export_test.go +++ b/src/runtime/export_test.go @@ -75,7 +75,7 @@ func Netpoll(delta int64) { }) } -func GCMask(x interface{}) (ret []byte) { +func GCMask(x any) (ret []byte) { systemstack(func() { ret = getgcmask(x) }) @@ -218,7 +218,7 @@ func SetEnvs(e []string) { envs = e } // For benchmarking. -func BenchSetType(n int, x interface{}) { +func BenchSetType(n int, x any) { e := *efaceOf(&x) t := e._type var size uintptr @@ -546,7 +546,7 @@ func MapTombstoneCheck(m map[int]int) { // We should have a series of filled and emptyOne cells, followed by // a series of emptyRest cells. h := *(**hmap)(unsafe.Pointer(&m)) - i := interface{}(m) + i := any(m) t := *(**maptype)(unsafe.Pointer(&i)) for x := 0; x < 1< G is inlined and F is excluded from stack // traces, G still appears. diff --git a/src/runtime/syscall_windows_test.go b/src/runtime/syscall_windows_test.go index 65f74b32fb..101e94107c 100644 --- a/src/runtime/syscall_windows_test.go +++ b/src/runtime/syscall_windows_test.go @@ -288,7 +288,7 @@ func TestCallbackInAnotherThread(t *testing.T) { } type cbFunc struct { - goFunc interface{} + goFunc any } func (f cbFunc) cName(cdecl bool) string { diff --git a/src/runtime/testdata/testprog/gc.go b/src/runtime/testdata/testprog/gc.go index 7d371a6a89..215228ea05 100644 --- a/src/runtime/testdata/testprog/gc.go +++ b/src/runtime/testdata/testprog/gc.go @@ -90,7 +90,7 @@ func GCFairness2() { runtime.GOMAXPROCS(1) debug.SetGCPercent(1) var count [3]int64 - var sink [3]interface{} + var sink [3]any for i := range count { go func(i int) { for { @@ -266,9 +266,9 @@ func DeferLiveness() { } //go:noinline -func escape(x interface{}) { sink2 = x; sink2 = nil } +func escape(x any) { sink2 = x; sink2 = nil } -var sink2 interface{} +var sink2 any // Test zombie object detection and reporting. func GCZombie() { diff --git a/src/runtime/testdata/testprog/signal.go b/src/runtime/testdata/testprog/signal.go index 417e105c68..cc5ac8af58 100644 --- a/src/runtime/testdata/testprog/signal.go +++ b/src/runtime/testdata/testprog/signal.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !windows && !plan9 // +build !windows,!plan9 package main diff --git a/src/runtime/testdata/testprog/syscalls_none.go b/src/runtime/testdata/testprog/syscalls_none.go index 7f8ded3994..068bb59af3 100644 --- a/src/runtime/testdata/testprog/syscalls_none.go +++ b/src/runtime/testdata/testprog/syscalls_none.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !linux // +build !linux package main diff --git a/src/runtime/testdata/testprogcgo/callback.go b/src/runtime/testdata/testprogcgo/callback.go index be0409f39d..a2d8a492a4 100644 --- a/src/runtime/testdata/testprogcgo/callback.go +++ b/src/runtime/testdata/testprogcgo/callback.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 && !windows // +build !plan9,!windows package main diff --git a/src/runtime/testdata/testprogcgo/catchpanic.go b/src/runtime/testdata/testprogcgo/catchpanic.go index 55a606d1bc..c722d40a19 100644 --- a/src/runtime/testdata/testprogcgo/catchpanic.go +++ b/src/runtime/testdata/testprogcgo/catchpanic.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 && !windows // +build !plan9,!windows package main diff --git a/src/runtime/testdata/testprogcgo/dropm.go b/src/runtime/testdata/testprogcgo/dropm.go index 9e782f504f..700b7fa0c2 100644 --- a/src/runtime/testdata/testprogcgo/dropm.go +++ b/src/runtime/testdata/testprogcgo/dropm.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 && !windows // +build !plan9,!windows // Test that a sequence of callbacks from C to Go get the same m. diff --git a/src/runtime/testdata/testprogcgo/eintr.go b/src/runtime/testdata/testprogcgo/eintr.go index 1722a75eb9..b35b280a76 100644 --- a/src/runtime/testdata/testprogcgo/eintr.go +++ b/src/runtime/testdata/testprogcgo/eintr.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 && !windows // +build !plan9,!windows package main diff --git a/src/runtime/testdata/testprogcgo/exec.go b/src/runtime/testdata/testprogcgo/exec.go index 15723c7369..c268bcd9b2 100644 --- a/src/runtime/testdata/testprogcgo/exec.go +++ b/src/runtime/testdata/testprogcgo/exec.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 && !windows // +build !plan9,!windows package main diff --git a/src/runtime/testdata/testprogcgo/lockosthread.go b/src/runtime/testdata/testprogcgo/lockosthread.go index 36423d9eb0..8fcea35f52 100644 --- a/src/runtime/testdata/testprogcgo/lockosthread.go +++ b/src/runtime/testdata/testprogcgo/lockosthread.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 && !windows // +build !plan9,!windows package main diff --git a/src/runtime/testdata/testprogcgo/needmdeadlock.go b/src/runtime/testdata/testprogcgo/needmdeadlock.go index 5a9c359006..b95ec77468 100644 --- a/src/runtime/testdata/testprogcgo/needmdeadlock.go +++ b/src/runtime/testdata/testprogcgo/needmdeadlock.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 && !windows // +build !plan9,!windows package main diff --git a/src/runtime/testdata/testprogcgo/numgoroutine.go b/src/runtime/testdata/testprogcgo/numgoroutine.go index 5bdfe52ed4..1b9f202f46 100644 --- a/src/runtime/testdata/testprogcgo/numgoroutine.go +++ b/src/runtime/testdata/testprogcgo/numgoroutine.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 && !windows // +build !plan9,!windows package main diff --git a/src/runtime/testdata/testprogcgo/raceprof.go b/src/runtime/testdata/testprogcgo/raceprof.go index f7ca629789..c098e16196 100644 --- a/src/runtime/testdata/testprogcgo/raceprof.go +++ b/src/runtime/testdata/testprogcgo/raceprof.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build (linux && amd64) || (freebsd && amd64) // +build linux,amd64 freebsd,amd64 package main diff --git a/src/runtime/testdata/testprogcgo/racesig.go b/src/runtime/testdata/testprogcgo/racesig.go index a079b3fd1a..9352679714 100644 --- a/src/runtime/testdata/testprogcgo/racesig.go +++ b/src/runtime/testdata/testprogcgo/racesig.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build (linux && amd64) || (freebsd && amd64) // +build linux,amd64 freebsd,amd64 package main diff --git a/src/runtime/testdata/testprogcgo/segv.go b/src/runtime/testdata/testprogcgo/segv.go index 3237a8c69c..0632475228 100644 --- a/src/runtime/testdata/testprogcgo/segv.go +++ b/src/runtime/testdata/testprogcgo/segv.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 && !windows // +build !plan9,!windows package main diff --git a/src/runtime/testdata/testprogcgo/sigstack.go b/src/runtime/testdata/testprogcgo/sigstack.go index 21b668d6c0..12ca661033 100644 --- a/src/runtime/testdata/testprogcgo/sigstack.go +++ b/src/runtime/testdata/testprogcgo/sigstack.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 && !windows // +build !plan9,!windows // Test handling of Go-allocated signal stacks when calling from diff --git a/src/runtime/testdata/testprogcgo/threadpanic.go b/src/runtime/testdata/testprogcgo/threadpanic.go index f9b48a9026..2d24fe68ea 100644 --- a/src/runtime/testdata/testprogcgo/threadpanic.go +++ b/src/runtime/testdata/testprogcgo/threadpanic.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 // +build !plan9 package main diff --git a/src/runtime/testdata/testprogcgo/threadpprof.go b/src/runtime/testdata/testprogcgo/threadpprof.go index e093f67e1e..ec5e750da9 100644 --- a/src/runtime/testdata/testprogcgo/threadpprof.go +++ b/src/runtime/testdata/testprogcgo/threadpprof.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !plan9 && !windows // +build !plan9,!windows package main @@ -108,7 +109,7 @@ func pprofThread() { C.runCPUHogThread() }) - time.Sleep(1*time.Second) + time.Sleep(1 * time.Second) pprof.StopCPUProfile() diff --git a/src/runtime/testdata/testprogcgo/threadprof.go b/src/runtime/testdata/testprogcgo/threadprof.go index 2d4c1039fb..8081173c0f 100644 --- a/src/runtime/testdata/testprogcgo/threadprof.go +++ b/src/runtime/testdata/testprogcgo/threadprof.go @@ -5,8 +5,8 @@ // We only build this file with the tag "threadprof", since it starts // a thread running a busy loop at constructor time. -// +build !plan9,!windows -// +build threadprof +//go:build !plan9 && !windows && threadprof +// +build !plan9,!windows,threadprof package main diff --git a/src/runtime/testdata/testprognet/signal.go b/src/runtime/testdata/testprognet/signal.go index 4d2de79d97..dfa2e10e7a 100644 --- a/src/runtime/testdata/testprognet/signal.go +++ b/src/runtime/testdata/testprognet/signal.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build !windows && !plan9 // +build !windows,!plan9 // This is in testprognet instead of testprog because testprog diff --git a/src/runtime/testdata/testprognet/signalexec.go b/src/runtime/testdata/testprognet/signalexec.go index 4a988ef6c1..62ebce7176 100644 --- a/src/runtime/testdata/testprognet/signalexec.go +++ b/src/runtime/testdata/testprognet/signalexec.go @@ -2,6 +2,7 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd // +build darwin dragonfly freebsd linux netbsd openbsd // This is in testprognet instead of testprog because testprog diff --git a/src/runtime/testdata/testwinlib/main.go b/src/runtime/testdata/testwinlib/main.go index 400eaa1c82..025ef913e5 100644 --- a/src/runtime/testdata/testwinlib/main.go +++ b/src/runtime/testdata/testwinlib/main.go @@ -1,3 +1,4 @@ +//go:build windows && cgo // +build windows,cgo package main diff --git a/src/runtime/time.go b/src/runtime/time.go index 46e9a8c2ab..a9ad620776 100644 --- a/src/runtime/time.go +++ b/src/runtime/time.go @@ -28,8 +28,8 @@ type timer struct { // when must be positive on an active timer. when int64 period int64 - f func(interface{}, uintptr) - arg interface{} + f func(any, uintptr) + arg any seq uintptr // What to set the when field to in timerModifiedXX status. @@ -232,14 +232,14 @@ func resetTimer(t *timer, when int64) bool { // modTimer modifies an existing timer. //go:linkname modTimer time.modTimer -func modTimer(t *timer, when, period int64, f func(interface{}, uintptr), arg interface{}, seq uintptr) { +func modTimer(t *timer, when, period int64, f func(any, uintptr), arg any, seq uintptr) { modtimer(t, when, period, f, arg, seq) } // Go runtime. // Ready the goroutine arg. -func goroutineReady(arg interface{}, seq uintptr) { +func goroutineReady(arg any, seq uintptr) { goready(arg.(*g), 0) } @@ -421,7 +421,7 @@ func dodeltimer0(pp *p) { // modtimer modifies an existing timer. // This is called by the netpoll code or time.Ticker.Reset or time.Timer.Reset. // Reports whether the timer was modified before it was run. -func modtimer(t *timer, when, period int64, f func(interface{}, uintptr), arg interface{}, seq uintptr) bool { +func modtimer(t *timer, when, period int64, f func(any, uintptr), arg any, seq uintptr) bool { if when <= 0 { throw("timer when must be positive") } diff --git a/src/runtime/trace/annotation.go b/src/runtime/trace/annotation.go index 6e18bfb755..d05b5e2261 100644 --- a/src/runtime/trace/annotation.go +++ b/src/runtime/trace/annotation.go @@ -98,7 +98,7 @@ func Log(ctx context.Context, category, message string) { } // Logf is like Log, but the value is formatted using the specified format spec. -func Logf(ctx context.Context, category, format string, args ...interface{}) { +func Logf(ctx context.Context, category, format string, args ...any) { if IsEnabled() { // Ideally this should be just Log, but that will // add one more frame in the stack trace. diff --git a/src/sort/slice.go b/src/sort/slice.go index 992ad1559d..ba5c2e2f3d 100644 --- a/src/sort/slice.go +++ b/src/sort/slice.go @@ -13,7 +13,7 @@ package sort // // The less function must satisfy the same requirements as // the Interface type's Less method. -func Slice(x interface{}, less func(i, j int) bool) { +func Slice(x any, less func(i, j int) bool) { rv := reflectValueOf(x) swap := reflectSwapper(x) length := rv.Len() @@ -26,7 +26,7 @@ func Slice(x interface{}, less func(i, j int) bool) { // // The less function must satisfy the same requirements as // the Interface type's Less method. -func SliceStable(x interface{}, less func(i, j int) bool) { +func SliceStable(x any, less func(i, j int) bool) { rv := reflectValueOf(x) swap := reflectSwapper(x) stable_func(lessSwap{less, swap}, rv.Len()) @@ -34,7 +34,7 @@ func SliceStable(x interface{}, less func(i, j int) bool) { // SliceIsSorted reports whether the slice x is sorted according to the provided less function. // It panics if x is not a slice. -func SliceIsSorted(x interface{}, less func(i, j int) bool) bool { +func SliceIsSorted(x any, less func(i, j int) bool) bool { rv := reflectValueOf(x) n := rv.Len() for i := n - 1; i > 0; i-- { diff --git a/src/sort/slice_go14.go b/src/sort/slice_go14.go index 5d5949f3ca..e477367618 100644 --- a/src/sort/slice_go14.go +++ b/src/sort/slice_go14.go @@ -11,7 +11,7 @@ import "reflect" var reflectValueOf = reflect.ValueOf -func reflectSwapper(x interface{}) func(int, int) { +func reflectSwapper(x any) func(int, int) { v := reflectValueOf(x) tmp := reflect.New(v.Type().Elem()).Elem() return func(i, j int) { diff --git a/src/strings/export_test.go b/src/strings/export_test.go index b39cee6b1d..81d1cab9d0 100644 --- a/src/strings/export_test.go +++ b/src/strings/export_test.go @@ -4,7 +4,7 @@ package strings -func (r *Replacer) Replacer() interface{} { +func (r *Replacer) Replacer() any { r.once.Do(r.buildOnce) return r.r } diff --git a/src/strings/reader_test.go b/src/strings/reader_test.go index 5adea6f7ab..dc99f9c248 100644 --- a/src/strings/reader_test.go +++ b/src/strings/reader_test.go @@ -77,7 +77,7 @@ func TestReaderAt(t *testing.T) { off int64 n int want string - wanterr interface{} + wanterr any }{ {0, 10, "0123456789", nil}, {1, 10, "123456789", io.EOF}, diff --git a/src/sync/atomic/atomic_test.go b/src/sync/atomic/atomic_test.go index 4b8c2a58f3..8a53094cb7 100644 --- a/src/sync/atomic/atomic_test.go +++ b/src/sync/atomic/atomic_test.go @@ -32,7 +32,7 @@ const ( ) // Do the 64-bit functions panic? If so, don't bother testing. -var test64err = func() (err interface{}) { +var test64err = func() (err any) { defer func() { err = recover() }() diff --git a/src/sync/atomic/value.go b/src/sync/atomic/value.go index af6295de91..f18b7ee095 100644 --- a/src/sync/atomic/value.go +++ b/src/sync/atomic/value.go @@ -14,7 +14,7 @@ import ( // // A Value must not be copied after first use. type Value struct { - v interface{} + v any } // ifaceWords is interface{} internal representation. @@ -25,7 +25,7 @@ type ifaceWords struct { // Load returns the value set by the most recent Store. // It returns nil if there has been no call to Store for this Value. -func (v *Value) Load() (val interface{}) { +func (v *Value) Load() (val any) { vp := (*ifaceWords)(unsafe.Pointer(v)) typ := LoadPointer(&vp.typ) if typ == nil || typ == unsafe.Pointer(&firstStoreInProgress) { @@ -44,7 +44,7 @@ var firstStoreInProgress byte // Store sets the value of the Value to x. // All calls to Store for a given Value must use values of the same concrete type. // Store of an inconsistent type panics, as does Store(nil). -func (v *Value) Store(val interface{}) { +func (v *Value) Store(val any) { if val == nil { panic("sync/atomic: store of nil value into Value") } @@ -87,7 +87,7 @@ func (v *Value) Store(val interface{}) { // // All calls to Swap for a given Value must use values of the same concrete // type. Swap of an inconsistent type panics, as does Swap(nil). -func (v *Value) Swap(new interface{}) (old interface{}) { +func (v *Value) Swap(new any) (old any) { if new == nil { panic("sync/atomic: swap of nil value into Value") } @@ -132,7 +132,7 @@ func (v *Value) Swap(new interface{}) (old interface{}) { // All calls to CompareAndSwap for a given Value must use values of the same // concrete type. CompareAndSwap of an inconsistent type panics, as does // CompareAndSwap(old, nil). -func (v *Value) CompareAndSwap(old, new interface{}) (swapped bool) { +func (v *Value) CompareAndSwap(old, new any) (swapped bool) { if new == nil { panic("sync/atomic: compare and swap of nil value into Value") } @@ -179,7 +179,7 @@ func (v *Value) CompareAndSwap(old, new interface{}) (swapped bool) { // CompareAndSwapPointer below only ensures vp.data // has not changed since LoadPointer. data := LoadPointer(&vp.data) - var i interface{} + var i any (*ifaceWords)(unsafe.Pointer(&i)).typ = typ (*ifaceWords)(unsafe.Pointer(&i)).data = data if i != old { diff --git a/src/sync/atomic/value_test.go b/src/sync/atomic/value_test.go index a5e717d6e0..721da965e3 100644 --- a/src/sync/atomic/value_test.go +++ b/src/sync/atomic/value_test.go @@ -80,7 +80,7 @@ func TestValuePanic(t *testing.T) { } func TestValueConcurrent(t *testing.T) { - tests := [][]interface{}{ + tests := [][]any{ {uint16(0), ^uint16(0), uint16(1 + 2<<8), uint16(3 + 4<<8)}, {uint32(0), ^uint32(0), uint32(1 + 2<<16), uint32(3 + 4<<16)}, {uint64(0), ^uint64(0), uint64(1 + 2<<32), uint64(3 + 4<<32)}, @@ -138,10 +138,10 @@ func BenchmarkValueRead(b *testing.B) { } var Value_SwapTests = []struct { - init interface{} - new interface{} - want interface{} - err interface{} + init any + new any + want any + err any }{ {init: nil, new: nil, err: "sync/atomic: swap of nil value into Value"}, {init: nil, new: true, want: nil, err: nil}, @@ -207,11 +207,11 @@ func TestValueSwapConcurrent(t *testing.T) { var heapA, heapB = struct{ uint }{0}, struct{ uint }{0} var Value_CompareAndSwapTests = []struct { - init interface{} - new interface{} - old interface{} + init any + new any + old any want bool - err interface{} + err any }{ {init: nil, new: nil, old: nil, err: "sync/atomic: compare and swap of nil value into Value"}, {init: nil, new: true, old: "", err: "sync/atomic: compare and swap of inconsistently typed values into Value"}, diff --git a/src/sync/example_pool_test.go b/src/sync/example_pool_test.go index 8288d41e8c..2fb4c1e6b9 100644 --- a/src/sync/example_pool_test.go +++ b/src/sync/example_pool_test.go @@ -13,7 +13,7 @@ import ( ) var bufPool = sync.Pool{ - New: func() interface{} { + New: func() any { // The Pool's New function should generally only return pointer // types, since a pointer can be put into the return interface // value without an allocation: diff --git a/src/sync/export_test.go b/src/sync/export_test.go index ffbe567464..c020ef737d 100644 --- a/src/sync/export_test.go +++ b/src/sync/export_test.go @@ -12,9 +12,9 @@ var Runtime_procUnpin = runtime_procUnpin // poolDequeue testing. type PoolDequeue interface { - PushHead(val interface{}) bool - PopHead() (interface{}, bool) - PopTail() (interface{}, bool) + PushHead(val any) bool + PopHead() (any, bool) + PopTail() (any, bool) } func NewPoolDequeue(n int) PoolDequeue { @@ -27,15 +27,15 @@ func NewPoolDequeue(n int) PoolDequeue { return d } -func (d *poolDequeue) PushHead(val interface{}) bool { +func (d *poolDequeue) PushHead(val any) bool { return d.pushHead(val) } -func (d *poolDequeue) PopHead() (interface{}, bool) { +func (d *poolDequeue) PopHead() (any, bool) { return d.popHead() } -func (d *poolDequeue) PopTail() (interface{}, bool) { +func (d *poolDequeue) PopTail() (any, bool) { return d.popTail() } @@ -43,15 +43,15 @@ func NewPoolChain() PoolDequeue { return new(poolChain) } -func (c *poolChain) PushHead(val interface{}) bool { +func (c *poolChain) PushHead(val any) bool { c.pushHead(val) return true } -func (c *poolChain) PopHead() (interface{}, bool) { +func (c *poolChain) PopHead() (any, bool) { return c.popHead() } -func (c *poolChain) PopTail() (interface{}, bool) { +func (c *poolChain) PopTail() (any, bool) { return c.popTail() } diff --git a/src/sync/map.go b/src/sync/map.go index 7a6c82e5c3..2fa3253429 100644 --- a/src/sync/map.go +++ b/src/sync/map.go @@ -48,7 +48,7 @@ type Map struct { // // If the dirty map is nil, the next write to the map will initialize it by // making a shallow copy of the clean map, omitting stale entries. - dirty map[interface{}]*entry + dirty map[any]*entry // misses counts the number of loads since the read map was last updated that // needed to lock mu to determine whether the key was present. @@ -61,13 +61,13 @@ type Map struct { // readOnly is an immutable struct stored atomically in the Map.read field. type readOnly struct { - m map[interface{}]*entry + m map[any]*entry amended bool // true if the dirty map contains some key not in m. } // expunged is an arbitrary pointer that marks entries which have been deleted // from the dirty map. -var expunged = unsafe.Pointer(new(interface{})) +var expunged = unsafe.Pointer(new(any)) // An entry is a slot in the map corresponding to a particular key. type entry struct { @@ -93,14 +93,14 @@ type entry struct { p unsafe.Pointer // *interface{} } -func newEntry(i interface{}) *entry { +func newEntry(i any) *entry { return &entry{p: unsafe.Pointer(&i)} } // Load returns the value stored in the map for a key, or nil if no // value is present. // The ok result indicates whether value was found in the map. -func (m *Map) Load(key interface{}) (value interface{}, ok bool) { +func (m *Map) Load(key any) (value any, ok bool) { read, _ := m.read.Load().(readOnly) e, ok := read.m[key] if !ok && read.amended { @@ -125,16 +125,16 @@ func (m *Map) Load(key interface{}) (value interface{}, ok bool) { return e.load() } -func (e *entry) load() (value interface{}, ok bool) { +func (e *entry) load() (value any, ok bool) { p := atomic.LoadPointer(&e.p) if p == nil || p == expunged { return nil, false } - return *(*interface{})(p), true + return *(*any)(p), true } // Store sets the value for a key. -func (m *Map) Store(key, value interface{}) { +func (m *Map) Store(key, value any) { read, _ := m.read.Load().(readOnly) if e, ok := read.m[key]; ok && e.tryStore(&value) { return @@ -167,7 +167,7 @@ func (m *Map) Store(key, value interface{}) { // // If the entry is expunged, tryStore returns false and leaves the entry // unchanged. -func (e *entry) tryStore(i *interface{}) bool { +func (e *entry) tryStore(i *any) bool { for { p := atomic.LoadPointer(&e.p) if p == expunged { @@ -190,14 +190,14 @@ func (e *entry) unexpungeLocked() (wasExpunged bool) { // storeLocked unconditionally stores a value to the entry. // // The entry must be known not to be expunged. -func (e *entry) storeLocked(i *interface{}) { +func (e *entry) storeLocked(i *any) { atomic.StorePointer(&e.p, unsafe.Pointer(i)) } // LoadOrStore returns the existing value for the key if present. // Otherwise, it stores and returns the given value. // The loaded result is true if the value was loaded, false if stored. -func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) { +func (m *Map) LoadOrStore(key, value any) (actual any, loaded bool) { // Avoid locking if it's a clean hit. read, _ := m.read.Load().(readOnly) if e, ok := read.m[key]; ok { @@ -237,13 +237,13 @@ func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bo // // If the entry is expunged, tryLoadOrStore leaves the entry unchanged and // returns with ok==false. -func (e *entry) tryLoadOrStore(i interface{}) (actual interface{}, loaded, ok bool) { +func (e *entry) tryLoadOrStore(i any) (actual any, loaded, ok bool) { p := atomic.LoadPointer(&e.p) if p == expunged { return nil, false, false } if p != nil { - return *(*interface{})(p), true, true + return *(*any)(p), true, true } // Copy the interface after the first load to make this method more amenable @@ -259,14 +259,14 @@ func (e *entry) tryLoadOrStore(i interface{}) (actual interface{}, loaded, ok bo return nil, false, false } if p != nil { - return *(*interface{})(p), true, true + return *(*any)(p), true, true } } } // LoadAndDelete deletes the value for a key, returning the previous value if any. // The loaded result reports whether the key was present. -func (m *Map) LoadAndDelete(key interface{}) (value interface{}, loaded bool) { +func (m *Map) LoadAndDelete(key any) (value any, loaded bool) { read, _ := m.read.Load().(readOnly) e, ok := read.m[key] if !ok && read.amended { @@ -290,18 +290,18 @@ func (m *Map) LoadAndDelete(key interface{}) (value interface{}, loaded bool) { } // Delete deletes the value for a key. -func (m *Map) Delete(key interface{}) { +func (m *Map) Delete(key any) { m.LoadAndDelete(key) } -func (e *entry) delete() (value interface{}, ok bool) { +func (e *entry) delete() (value any, ok bool) { for { p := atomic.LoadPointer(&e.p) if p == nil || p == expunged { return nil, false } if atomic.CompareAndSwapPointer(&e.p, p, nil) { - return *(*interface{})(p), true + return *(*any)(p), true } } } @@ -317,7 +317,7 @@ func (e *entry) delete() (value interface{}, ok bool) { // // Range may be O(N) with the number of elements in the map even if f returns // false after a constant number of calls. -func (m *Map) Range(f func(key, value interface{}) bool) { +func (m *Map) Range(f func(key, value any) bool) { // We need to be able to iterate over all of the keys that were already // present at the start of the call to Range. // If read.amended is false, then read.m satisfies that property without @@ -366,7 +366,7 @@ func (m *Map) dirtyLocked() { } read, _ := m.read.Load().(readOnly) - m.dirty = make(map[interface{}]*entry, len(read.m)) + m.dirty = make(map[any]*entry, len(read.m)) for k, e := range read.m { if !e.tryExpungeLocked() { m.dirty[k] = e diff --git a/src/sync/map_bench_test.go b/src/sync/map_bench_test.go index cf0a3d7fde..e7b0e6039c 100644 --- a/src/sync/map_bench_test.go +++ b/src/sync/map_bench_test.go @@ -216,7 +216,7 @@ func BenchmarkRange(b *testing.B) { perG: func(b *testing.B, pb *testing.PB, i int, m mapInterface) { for ; pb.Next(); i++ { - m.Range(func(_, _ interface{}) bool { return true }) + m.Range(func(_, _ any) bool { return true }) } }, }) @@ -263,7 +263,7 @@ func BenchmarkAdversarialDelete(b *testing.B) { m.Load(i) if i%mapSize == 0 { - m.Range(func(k, _ interface{}) bool { + m.Range(func(k, _ any) bool { m.Delete(k) return false }) diff --git a/src/sync/map_reference_test.go b/src/sync/map_reference_test.go index d105a24e92..1122b40b9b 100644 --- a/src/sync/map_reference_test.go +++ b/src/sync/map_reference_test.go @@ -13,43 +13,43 @@ import ( // mapInterface is the interface Map implements. type mapInterface interface { - Load(interface{}) (interface{}, bool) - Store(key, value interface{}) - LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) - LoadAndDelete(key interface{}) (value interface{}, loaded bool) - Delete(interface{}) - Range(func(key, value interface{}) (shouldContinue bool)) + Load(any) (any, bool) + Store(key, value any) + LoadOrStore(key, value any) (actual any, loaded bool) + LoadAndDelete(key any) (value any, loaded bool) + Delete(any) + Range(func(key, value any) (shouldContinue bool)) } // RWMutexMap is an implementation of mapInterface using a sync.RWMutex. type RWMutexMap struct { mu sync.RWMutex - dirty map[interface{}]interface{} + dirty map[any]any } -func (m *RWMutexMap) Load(key interface{}) (value interface{}, ok bool) { +func (m *RWMutexMap) Load(key any) (value any, ok bool) { m.mu.RLock() value, ok = m.dirty[key] m.mu.RUnlock() return } -func (m *RWMutexMap) Store(key, value interface{}) { +func (m *RWMutexMap) Store(key, value any) { m.mu.Lock() if m.dirty == nil { - m.dirty = make(map[interface{}]interface{}) + m.dirty = make(map[any]any) } m.dirty[key] = value m.mu.Unlock() } -func (m *RWMutexMap) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) { +func (m *RWMutexMap) LoadOrStore(key, value any) (actual any, loaded bool) { m.mu.Lock() actual, loaded = m.dirty[key] if !loaded { actual = value if m.dirty == nil { - m.dirty = make(map[interface{}]interface{}) + m.dirty = make(map[any]any) } m.dirty[key] = value } @@ -57,7 +57,7 @@ func (m *RWMutexMap) LoadOrStore(key, value interface{}) (actual interface{}, lo return actual, loaded } -func (m *RWMutexMap) LoadAndDelete(key interface{}) (value interface{}, loaded bool) { +func (m *RWMutexMap) LoadAndDelete(key any) (value any, loaded bool) { m.mu.Lock() value, loaded = m.dirty[key] if !loaded { @@ -69,15 +69,15 @@ func (m *RWMutexMap) LoadAndDelete(key interface{}) (value interface{}, loaded b return value, loaded } -func (m *RWMutexMap) Delete(key interface{}) { +func (m *RWMutexMap) Delete(key any) { m.mu.Lock() delete(m.dirty, key) m.mu.Unlock() } -func (m *RWMutexMap) Range(f func(key, value interface{}) (shouldContinue bool)) { +func (m *RWMutexMap) Range(f func(key, value any) (shouldContinue bool)) { m.mu.RLock() - keys := make([]interface{}, 0, len(m.dirty)) + keys := make([]any, 0, len(m.dirty)) for k := range m.dirty { keys = append(keys, k) } @@ -102,13 +102,13 @@ type DeepCopyMap struct { clean atomic.Value } -func (m *DeepCopyMap) Load(key interface{}) (value interface{}, ok bool) { - clean, _ := m.clean.Load().(map[interface{}]interface{}) +func (m *DeepCopyMap) Load(key any) (value any, ok bool) { + clean, _ := m.clean.Load().(map[any]any) value, ok = clean[key] return value, ok } -func (m *DeepCopyMap) Store(key, value interface{}) { +func (m *DeepCopyMap) Store(key, value any) { m.mu.Lock() dirty := m.dirty() dirty[key] = value @@ -116,8 +116,8 @@ func (m *DeepCopyMap) Store(key, value interface{}) { m.mu.Unlock() } -func (m *DeepCopyMap) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) { - clean, _ := m.clean.Load().(map[interface{}]interface{}) +func (m *DeepCopyMap) LoadOrStore(key, value any) (actual any, loaded bool) { + clean, _ := m.clean.Load().(map[any]any) actual, loaded = clean[key] if loaded { return actual, loaded @@ -125,7 +125,7 @@ func (m *DeepCopyMap) LoadOrStore(key, value interface{}) (actual interface{}, l m.mu.Lock() // Reload clean in case it changed while we were waiting on m.mu. - clean, _ = m.clean.Load().(map[interface{}]interface{}) + clean, _ = m.clean.Load().(map[any]any) actual, loaded = clean[key] if !loaded { dirty := m.dirty() @@ -137,7 +137,7 @@ func (m *DeepCopyMap) LoadOrStore(key, value interface{}) (actual interface{}, l return actual, loaded } -func (m *DeepCopyMap) LoadAndDelete(key interface{}) (value interface{}, loaded bool) { +func (m *DeepCopyMap) LoadAndDelete(key any) (value any, loaded bool) { m.mu.Lock() dirty := m.dirty() value, loaded = dirty[key] @@ -147,7 +147,7 @@ func (m *DeepCopyMap) LoadAndDelete(key interface{}) (value interface{}, loaded return } -func (m *DeepCopyMap) Delete(key interface{}) { +func (m *DeepCopyMap) Delete(key any) { m.mu.Lock() dirty := m.dirty() delete(dirty, key) @@ -155,8 +155,8 @@ func (m *DeepCopyMap) Delete(key interface{}) { m.mu.Unlock() } -func (m *DeepCopyMap) Range(f func(key, value interface{}) (shouldContinue bool)) { - clean, _ := m.clean.Load().(map[interface{}]interface{}) +func (m *DeepCopyMap) Range(f func(key, value any) (shouldContinue bool)) { + clean, _ := m.clean.Load().(map[any]any) for k, v := range clean { if !f(k, v) { break @@ -164,9 +164,9 @@ func (m *DeepCopyMap) Range(f func(key, value interface{}) (shouldContinue bool) } } -func (m *DeepCopyMap) dirty() map[interface{}]interface{} { - clean, _ := m.clean.Load().(map[interface{}]interface{}) - dirty := make(map[interface{}]interface{}, len(clean)+1) +func (m *DeepCopyMap) dirty() map[any]any { + clean, _ := m.clean.Load().(map[any]any) + dirty := make(map[any]any, len(clean)+1) for k, v := range clean { dirty[k] = v } diff --git a/src/sync/map_test.go b/src/sync/map_test.go index c4a8f8b99a..8352471104 100644 --- a/src/sync/map_test.go +++ b/src/sync/map_test.go @@ -29,10 +29,10 @@ var mapOps = [...]mapOp{opLoad, opStore, opLoadOrStore, opLoadAndDelete, opDelet // mapCall is a quick.Generator for calls on mapInterface. type mapCall struct { op mapOp - k, v interface{} + k, v any } -func (c mapCall) apply(m mapInterface) (interface{}, bool) { +func (c mapCall) apply(m mapInterface) (any, bool) { switch c.op { case opLoad: return m.Load(c.k) @@ -52,11 +52,11 @@ func (c mapCall) apply(m mapInterface) (interface{}, bool) { } type mapResult struct { - value interface{} + value any ok bool } -func randValue(r *rand.Rand) interface{} { +func randValue(r *rand.Rand) any { b := make([]byte, r.Intn(4)) for i := range b { b[i] = 'a' + byte(rand.Intn(26)) @@ -73,14 +73,14 @@ func (mapCall) Generate(r *rand.Rand, size int) reflect.Value { return reflect.ValueOf(c) } -func applyCalls(m mapInterface, calls []mapCall) (results []mapResult, final map[interface{}]interface{}) { +func applyCalls(m mapInterface, calls []mapCall) (results []mapResult, final map[any]any) { for _, c := range calls { v, ok := c.apply(m) results = append(results, mapResult{v, ok}) } - final = make(map[interface{}]interface{}) - m.Range(func(k, v interface{}) bool { + final = make(map[any]any) + m.Range(func(k, v any) bool { final[k] = v return true }) @@ -88,15 +88,15 @@ func applyCalls(m mapInterface, calls []mapCall) (results []mapResult, final map return results, final } -func applyMap(calls []mapCall) ([]mapResult, map[interface{}]interface{}) { +func applyMap(calls []mapCall) ([]mapResult, map[any]any) { return applyCalls(new(sync.Map), calls) } -func applyRWMutexMap(calls []mapCall) ([]mapResult, map[interface{}]interface{}) { +func applyRWMutexMap(calls []mapCall) ([]mapResult, map[any]any) { return applyCalls(new(RWMutexMap), calls) } -func applyDeepCopyMap(calls []mapCall) ([]mapResult, map[interface{}]interface{}) { +func applyDeepCopyMap(calls []mapCall) ([]mapResult, map[any]any) { return applyCalls(new(DeepCopyMap), calls) } @@ -155,7 +155,7 @@ func TestConcurrentRange(t *testing.T) { for n := iters; n > 0; n-- { seen := make(map[int64]bool, mapSize) - m.Range(func(ki, vi interface{}) bool { + m.Range(func(ki, vi any) bool { k, v := ki.(int64), vi.(int64) if v%k != 0 { t.Fatalf("while Storing multiples of %v, Range saw value %v", k, v) @@ -201,8 +201,8 @@ func TestMapRangeNestedCall(t *testing.T) { // Issue 46399 for i, v := range [3]string{"hello", "world", "Go"} { m.Store(i, v) } - m.Range(func(key, value interface{}) bool { - m.Range(func(key, value interface{}) bool { + m.Range(func(key, value any) bool { + m.Range(func(key, value any) bool { // We should be able to load the key offered in the Range callback, // because there are no concurrent Delete involved in this tested map. if v, ok := m.Load(key); !ok || !reflect.DeepEqual(v, value) { @@ -236,7 +236,7 @@ func TestMapRangeNestedCall(t *testing.T) { // Issue 46399 // After a Range of Delete, all keys should be removed and any // further Range won't invoke the callback. Hence length remains 0. length := 0 - m.Range(func(key, value interface{}) bool { + m.Range(func(key, value any) bool { length++ return true }) diff --git a/src/sync/pool.go b/src/sync/pool.go index 9802f29d6f..d1abb6a8b7 100644 --- a/src/sync/pool.go +++ b/src/sync/pool.go @@ -53,13 +53,13 @@ type Pool struct { // New optionally specifies a function to generate // a value when Get would otherwise return nil. // It may not be changed concurrently with calls to Get. - New func() interface{} + New func() any } // Local per-P Pool appendix. type poolLocalInternal struct { - private interface{} // Can be used only by the respective P. - shared poolChain // Local P can pushHead/popHead; any P can popTail. + private any // Can be used only by the respective P. + shared poolChain // Local P can pushHead/popHead; any P can popTail. } type poolLocal struct { @@ -80,14 +80,14 @@ var poolRaceHash [128]uint64 // directly, for fear of conflicting with other synchronization on that address. // Instead, we hash the pointer to get an index into poolRaceHash. // See discussion on golang.org/cl/31589. -func poolRaceAddr(x interface{}) unsafe.Pointer { +func poolRaceAddr(x any) unsafe.Pointer { ptr := uintptr((*[2]unsafe.Pointer)(unsafe.Pointer(&x))[1]) h := uint32((uint64(uint32(ptr)) * 0x85ebca6b) >> 16) return unsafe.Pointer(&poolRaceHash[h%uint32(len(poolRaceHash))]) } // Put adds x to the pool. -func (p *Pool) Put(x interface{}) { +func (p *Pool) Put(x any) { if x == nil { return } @@ -121,7 +121,7 @@ func (p *Pool) Put(x interface{}) { // // If Get would otherwise return nil and p.New is non-nil, Get returns // the result of calling p.New. -func (p *Pool) Get() interface{} { +func (p *Pool) Get() any { if race.Enabled { race.Disable() } @@ -150,7 +150,7 @@ func (p *Pool) Get() interface{} { return x } -func (p *Pool) getSlow(pid int) interface{} { +func (p *Pool) getSlow(pid int) any { // See the comment in pin regarding ordering of the loads. size := runtime_LoadAcquintptr(&p.localSize) // load-acquire locals := p.local // load-consume diff --git a/src/sync/pool_test.go b/src/sync/pool_test.go index d991621624..bb20043a54 100644 --- a/src/sync/pool_test.go +++ b/src/sync/pool_test.go @@ -64,7 +64,7 @@ func TestPoolNew(t *testing.T) { i := 0 p := Pool{ - New: func() interface{} { + New: func() any { i++ return i }, @@ -143,7 +143,7 @@ func TestPoolStress(t *testing.T) { done := make(chan bool) for i := 0; i < P; i++ { go func() { - var v interface{} = 0 + var v any = 0 for j := 0; j < N; j++ { if v == nil { v = 0 @@ -290,7 +290,7 @@ func BenchmarkPoolStarvation(b *testing.B) { }) } -var globalSink interface{} +var globalSink any func BenchmarkPoolSTW(b *testing.B) { // Take control of GC. @@ -303,7 +303,7 @@ func BenchmarkPoolSTW(b *testing.B) { for i := 0; i < b.N; i++ { // Put a large number of items into a pool. const N = 100000 - var item interface{} = 42 + var item any = 42 for i := 0; i < N; i++ { p.Put(item) } @@ -338,7 +338,7 @@ func BenchmarkPoolExpensiveNew(b *testing.B) { // Create a pool that's "expensive" to fill. var p Pool var nNew uint64 - p.New = func() interface{} { + p.New = func() any { atomic.AddUint64(&nNew, 1) time.Sleep(time.Millisecond) return 42 @@ -348,7 +348,7 @@ func BenchmarkPoolExpensiveNew(b *testing.B) { b.RunParallel(func(pb *testing.PB) { // Simulate 100X the number of goroutines having items // checked out from the Pool simultaneously. - items := make([]interface{}, 100) + items := make([]any, 100) var sink []byte for pb.Next() { // Stress the pool. diff --git a/src/sync/poolqueue.go b/src/sync/poolqueue.go index 9be83e9a43..631f2c15fd 100644 --- a/src/sync/poolqueue.go +++ b/src/sync/poolqueue.go @@ -77,7 +77,7 @@ func (d *poolDequeue) pack(head, tail uint32) uint64 { // pushHead adds val at the head of the queue. It returns false if the // queue is full. It must only be called by a single producer. -func (d *poolDequeue) pushHead(val interface{}) bool { +func (d *poolDequeue) pushHead(val any) bool { ptrs := atomic.LoadUint64(&d.headTail) head, tail := d.unpack(ptrs) if (tail+uint32(len(d.vals)))&(1<= 1 { // on Node.js 8, fs.utimes calls the callback without any arguments diff --git a/src/syscall/js/func.go b/src/syscall/js/func.go index 77fb9e66ca..cc94972364 100644 --- a/src/syscall/js/func.go +++ b/src/syscall/js/func.go @@ -10,7 +10,7 @@ import "sync" var ( funcsMu sync.Mutex - funcs = make(map[uint32]func(Value, []Value) interface{}) + funcs = make(map[uint32]func(Value, []Value) any) nextFuncID uint32 = 1 ) @@ -38,7 +38,7 @@ type Func struct { // new goroutine. // // Func.Release must be called to free up resources when the function will not be invoked any more. -func FuncOf(fn func(this Value, args []Value) interface{}) Func { +func FuncOf(fn func(this Value, args []Value) any) Func { funcsMu.Lock() id := nextFuncID nextFuncID++ diff --git a/src/syscall/js/js.go b/src/syscall/js/js.go index d80d5d63de..a5210faf7f 100644 --- a/src/syscall/js/js.go +++ b/src/syscall/js/js.go @@ -148,7 +148,7 @@ func Global() Value { // | map[string]interface{} | new object | // // Panics if x is not one of the expected types. -func ValueOf(x interface{}) Value { +func ValueOf(x any) Value { switch x := x.(type) { case Value: return x @@ -192,13 +192,13 @@ func ValueOf(x interface{}) Value { return floatValue(x) case string: return makeValue(stringVal(x)) - case []interface{}: + case []any: a := arrayConstructor.New(len(x)) for i, s := range x { a.SetIndex(i, s) } return a - case map[string]interface{}: + case map[string]any: o := objectConstructor.New() for k, v := range x { o.Set(k, v) @@ -296,7 +296,7 @@ func valueGet(v ref, p string) ref // Set sets the JavaScript property p of value v to ValueOf(x). // It panics if v is not a JavaScript object. -func (v Value) Set(p string, x interface{}) { +func (v Value) Set(p string, x any) { if vType := v.Type(); !vType.isObject() { panic(&ValueError{"Value.Set", vType}) } @@ -335,7 +335,7 @@ func valueIndex(v ref, i int) ref // SetIndex sets the JavaScript index i of value v to ValueOf(x). // It panics if v is not a JavaScript object. -func (v Value) SetIndex(i int, x interface{}) { +func (v Value) SetIndex(i int, x any) { if vType := v.Type(); !vType.isObject() { panic(&ValueError{"Value.SetIndex", vType}) } @@ -347,7 +347,7 @@ func (v Value) SetIndex(i int, x interface{}) { func valueSetIndex(v ref, i int, x ref) -func makeArgs(args []interface{}) ([]Value, []ref) { +func makeArgs(args []any) ([]Value, []ref) { argVals := make([]Value, len(args)) argRefs := make([]ref, len(args)) for i, arg := range args { @@ -374,7 +374,7 @@ func valueLength(v ref) int // Call does a JavaScript call to the method m of value v with the given arguments. // It panics if v has no method m. // The arguments get mapped to JavaScript values according to the ValueOf function. -func (v Value) Call(m string, args ...interface{}) Value { +func (v Value) Call(m string, args ...any) Value { argVals, argRefs := makeArgs(args) res, ok := valueCall(v.ref, m, argRefs) runtime.KeepAlive(v) @@ -396,7 +396,7 @@ func valueCall(v ref, m string, args []ref) (ref, bool) // Invoke does a JavaScript call of the value v with the given arguments. // It panics if v is not a JavaScript function. // The arguments get mapped to JavaScript values according to the ValueOf function. -func (v Value) Invoke(args ...interface{}) Value { +func (v Value) Invoke(args ...any) Value { argVals, argRefs := makeArgs(args) res, ok := valueInvoke(v.ref, argRefs) runtime.KeepAlive(v) @@ -415,7 +415,7 @@ func valueInvoke(v ref, args []ref) (ref, bool) // New uses JavaScript's "new" operator with value v as constructor and the given arguments. // It panics if v is not a JavaScript function. // The arguments get mapped to JavaScript values according to the ValueOf function. -func (v Value) New(args ...interface{}) Value { +func (v Value) New(args ...any) Value { argVals, argRefs := makeArgs(args) res, ok := valueNew(v.ref, argRefs) runtime.KeepAlive(v) diff --git a/src/syscall/js/js_test.go b/src/syscall/js/js_test.go index fa8c782459..f860a5bb50 100644 --- a/src/syscall/js/js_test.go +++ b/src/syscall/js/js_test.go @@ -364,8 +364,8 @@ func TestType(t *testing.T) { } } -type object = map[string]interface{} -type array = []interface{} +type object = map[string]any +type array = []any func TestValueOf(t *testing.T) { a := js.ValueOf(array{0, array{0, 42, 0}, 0}) @@ -388,7 +388,7 @@ func TestZeroValue(t *testing.T) { func TestFuncOf(t *testing.T) { c := make(chan struct{}) - cb := js.FuncOf(func(this js.Value, args []js.Value) interface{} { + cb := js.FuncOf(func(this js.Value, args []js.Value) any { if got := args[0].Int(); got != 42 { t.Errorf("got %#v, want %#v", got, 42) } @@ -402,8 +402,8 @@ func TestFuncOf(t *testing.T) { func TestInvokeFunction(t *testing.T) { called := false - cb := js.FuncOf(func(this js.Value, args []js.Value) interface{} { - cb2 := js.FuncOf(func(this js.Value, args []js.Value) interface{} { + cb := js.FuncOf(func(this js.Value, args []js.Value) any { + cb2 := js.FuncOf(func(this js.Value, args []js.Value) any { called = true return 42 }) @@ -423,7 +423,7 @@ func TestInterleavedFunctions(t *testing.T) { c1 := make(chan struct{}) c2 := make(chan struct{}) - js.Global().Get("setTimeout").Invoke(js.FuncOf(func(this js.Value, args []js.Value) interface{} { + js.Global().Get("setTimeout").Invoke(js.FuncOf(func(this js.Value, args []js.Value) any { c1 <- struct{}{} <-c2 return nil @@ -432,7 +432,7 @@ func TestInterleavedFunctions(t *testing.T) { <-c1 c2 <- struct{}{} // this goroutine is running, but the callback of setTimeout did not return yet, invoke another function now - f := js.FuncOf(func(this js.Value, args []js.Value) interface{} { + f := js.FuncOf(func(this js.Value, args []js.Value) any { return nil }) f.Invoke() @@ -440,7 +440,7 @@ func TestInterleavedFunctions(t *testing.T) { func ExampleFuncOf() { var cb js.Func - cb = js.FuncOf(func(this js.Value, args []js.Value) interface{} { + cb = js.FuncOf(func(this js.Value, args []js.Value) any { fmt.Println("button clicked") cb.Release() // release the function if the button will not be clicked again return nil @@ -593,7 +593,7 @@ func BenchmarkDOM(b *testing.B) { } func TestGlobal(t *testing.T) { - ident := js.FuncOf(func(this js.Value, args []js.Value) interface{} { + ident := js.FuncOf(func(this js.Value, args []js.Value) any { return args[0] }) defer ident.Release() diff --git a/src/syscall/net_js.go b/src/syscall/net_js.go index 253ab22dd9..2ed4e191bd 100644 --- a/src/syscall/net_js.go +++ b/src/syscall/net_js.go @@ -45,8 +45,7 @@ const ( SYS_FCNTL = 500 // unsupported ) -type Sockaddr interface { -} +type Sockaddr any type SockaddrInet4 struct { Port int diff --git a/src/syscall/syscall_windows.go b/src/syscall/syscall_windows.go index ecb1eeecf6..78e46a656d 100644 --- a/src/syscall/syscall_windows.go +++ b/src/syscall/syscall_windows.go @@ -169,7 +169,7 @@ func (e Errno) Timeout() bool { } // Implemented in runtime/syscall_windows.go. -func compileCallback(fn interface{}, cleanstack bool) uintptr +func compileCallback(fn any, cleanstack bool) uintptr // NewCallback converts a Go function to a function pointer conforming to the stdcall calling convention. // This is useful when interoperating with Windows code requiring callbacks. @@ -177,7 +177,7 @@ func compileCallback(fn interface{}, cleanstack bool) uintptr // Only a limited number of callbacks may be created in a single Go process, and any memory allocated // for these callbacks is never released. // Between NewCallback and NewCallbackCDecl, at least 1024 callbacks can always be created. -func NewCallback(fn interface{}) uintptr { +func NewCallback(fn any) uintptr { return compileCallback(fn, true) } @@ -187,7 +187,7 @@ func NewCallback(fn interface{}) uintptr { // Only a limited number of callbacks may be created in a single Go process, and any memory allocated // for these callbacks is never released. // Between NewCallback and NewCallbackCDecl, at least 1024 callbacks can always be created. -func NewCallbackCDecl(fn interface{}) uintptr { +func NewCallbackCDecl(fn any) uintptr { return compileCallback(fn, false) } diff --git a/src/testing/allocs_test.go b/src/testing/allocs_test.go index 5b346aaf83..bbd3ae79c8 100644 --- a/src/testing/allocs_test.go +++ b/src/testing/allocs_test.go @@ -6,7 +6,7 @@ package testing_test import "testing" -var global interface{} +var global any var allocsPerRunTests = []struct { name string diff --git a/src/testing/example.go b/src/testing/example.go index 0217c5d242..f33e8d2f92 100644 --- a/src/testing/example.go +++ b/src/testing/example.go @@ -64,7 +64,7 @@ func sortLines(output string) string { // If recovered is non-nil, it'll panic with that value. // If the test panicked with nil, or invoked runtime.Goexit, it'll be // made to fail and panic with errNilPanicOrGoexit -func (eg *InternalExample) processRunResult(stdout string, timeSpent time.Duration, finished bool, recovered interface{}) (passed bool) { +func (eg *InternalExample) processRunResult(stdout string, timeSpent time.Duration, finished bool, recovered any) (passed bool) { passed = true dstr := fmtDuration(timeSpent) var fail string diff --git a/src/testing/fstest/mapfs.go b/src/testing/fstest/mapfs.go index 056ef133fa..4595b7313d 100644 --- a/src/testing/fstest/mapfs.go +++ b/src/testing/fstest/mapfs.go @@ -37,7 +37,7 @@ type MapFile struct { Data []byte // file content Mode fs.FileMode // FileInfo.Mode ModTime time.Time // FileInfo.ModTime - Sys interface{} // FileInfo.Sys + Sys any // FileInfo.Sys } var _ fs.FS = MapFS(nil) @@ -156,7 +156,7 @@ func (i *mapFileInfo) Mode() fs.FileMode { return i.f.Mode } func (i *mapFileInfo) Type() fs.FileMode { return i.f.Mode.Type() } func (i *mapFileInfo) ModTime() time.Time { return i.f.ModTime } func (i *mapFileInfo) IsDir() bool { return i.f.Mode&fs.ModeDir != 0 } -func (i *mapFileInfo) Sys() interface{} { return i.f.Sys } +func (i *mapFileInfo) Sys() any { return i.f.Sys } func (i *mapFileInfo) Info() (fs.FileInfo, error) { return i, nil } // An openMapFile is a regular (non-directory) fs.File open for reading. diff --git a/src/testing/fstest/testfs.go b/src/testing/fstest/testfs.go index 5c4f30af16..9a65fbbd0b 100644 --- a/src/testing/fstest/testfs.go +++ b/src/testing/fstest/testfs.go @@ -105,7 +105,7 @@ type fsTester struct { } // errorf adds an error line to errText. -func (t *fsTester) errorf(format string, args ...interface{}) { +func (t *fsTester) errorf(format string, args ...any) { if len(t.errText) > 0 { t.errText = append(t.errText, '\n') } diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go index 19ff39947b..18f2b2f319 100644 --- a/src/testing/fuzz.go +++ b/src/testing/fuzz.go @@ -91,7 +91,7 @@ type corpusEntry = struct { Parent string Path string Data []byte - Values []interface{} + Values []any Generation int IsSeed bool } @@ -149,8 +149,8 @@ func (f *F) Skipped() bool { // Add will add the arguments to the seed corpus for the fuzz test. This will be // a no-op if called after or within the fuzz target, and args must match the // arguments for the fuzz target. -func (f *F) Add(args ...interface{}) { - var values []interface{} +func (f *F) Add(args ...any) { + var values []any for i := range args { if t := reflect.TypeOf(args[i]); !supportedTypes[t] { panic(fmt.Sprintf("testing: unsupported type to Add %v", t)) @@ -207,7 +207,7 @@ var supportedTypes = map[reflect.Type]bool{ // When fuzzing, F.Fuzz does not return until a problem is found, time runs out // (set with -fuzztime), or the test process is interrupted by a signal. F.Fuzz // should be called exactly once, unless F.Skip or F.Fail is called beforehand. -func (f *F) Fuzz(ff interface{}) { +func (f *F) Fuzz(ff any) { if f.fuzzCalled { panic("testing: F.Fuzz called more than once") } @@ -638,7 +638,7 @@ func fRunner(f *F, fn func(*F)) { // If we recovered a panic or inappropriate runtime.Goexit, fail the test, // flush the output log up to the root, then panic. - doPanic := func(err interface{}) { + doPanic := func(err any) { f.Fail() if r := f.runCleanup(recoverAndReturnPanic); r != nil { f.Logf("cleanup panicked with %v", r) diff --git a/src/testing/internal/testdeps/deps.go b/src/testing/internal/testdeps/deps.go index c612355a00..2e85a41b07 100644 --- a/src/testing/internal/testdeps/deps.go +++ b/src/testing/internal/testdeps/deps.go @@ -186,7 +186,7 @@ func (TestDeps) ReadCorpus(dir string, types []reflect.Type) ([]fuzz.CorpusEntry return fuzz.ReadCorpus(dir, types) } -func (TestDeps) CheckCorpus(vals []interface{}, types []reflect.Type) error { +func (TestDeps) CheckCorpus(vals []any, types []reflect.Type) error { return fuzz.CheckCorpus(vals, types) } diff --git a/src/testing/quick/quick.go b/src/testing/quick/quick.go index 777338bb37..e73d307c13 100644 --- a/src/testing/quick/quick.go +++ b/src/testing/quick/quick.go @@ -227,7 +227,7 @@ func (s SetupError) Error() string { return string(s) } // A CheckError is the result of Check finding an error. type CheckError struct { Count int - In []interface{} + In []any } func (s *CheckError) Error() string { @@ -237,8 +237,8 @@ func (s *CheckError) Error() string { // A CheckEqualError is the result CheckEqual finding an error. type CheckEqualError struct { CheckError - Out1 []interface{} - Out2 []interface{} + Out1 []any + Out2 []any } func (s *CheckEqualError) Error() string { @@ -260,7 +260,7 @@ func (s *CheckEqualError) Error() string { // t.Error(err) // } // } -func Check(f interface{}, config *Config) error { +func Check(f any, config *Config) error { if config == nil { config = &defaultConfig } @@ -299,7 +299,7 @@ func Check(f interface{}, config *Config) error { // It calls f and g repeatedly with arbitrary values for each argument. // If f and g return different answers, CheckEqual returns a *CheckEqualError // describing the input and the outputs. -func CheckEqual(f, g interface{}, config *Config) error { +func CheckEqual(f, g any, config *Config) error { if config == nil { config = &defaultConfig } @@ -358,7 +358,7 @@ func arbitraryValues(args []reflect.Value, f reflect.Type, config *Config, rand return } -func functionAndType(f interface{}) (v reflect.Value, t reflect.Type, ok bool) { +func functionAndType(f any) (v reflect.Value, t reflect.Type, ok bool) { v = reflect.ValueOf(f) ok = v.Kind() == reflect.Func if !ok { @@ -368,15 +368,15 @@ func functionAndType(f interface{}) (v reflect.Value, t reflect.Type, ok bool) { return } -func toInterfaces(values []reflect.Value) []interface{} { - ret := make([]interface{}, len(values)) +func toInterfaces(values []reflect.Value) []any { + ret := make([]any, len(values)) for i, v := range values { ret[i] = v.Interface() } return ret } -func toString(interfaces []interface{}) string { +func toString(interfaces []any) string { s := make([]string, len(interfaces)) for i, v := range interfaces { s[i] = fmt.Sprintf("%#v", v) diff --git a/src/testing/testing.go b/src/testing/testing.go index e4b7aa30e5..7bd13a850c 100644 --- a/src/testing/testing.go +++ b/src/testing/testing.go @@ -453,7 +453,7 @@ func newChattyPrinter(w io.Writer) *chattyPrinter { // Updatef prints a message about the status of the named test to w. // // The formatted message must include the test name itself. -func (p *chattyPrinter) Updatef(testName, format string, args ...interface{}) { +func (p *chattyPrinter) Updatef(testName, format string, args ...any) { p.lastNameMu.Lock() defer p.lastNameMu.Unlock() @@ -467,7 +467,7 @@ func (p *chattyPrinter) Updatef(testName, format string, args ...interface{}) { // Printf prints a message, generated by the named test, that does not // necessarily mention that tests's name itself. -func (p *chattyPrinter) Printf(testName, format string, args ...interface{}) { +func (p *chattyPrinter) Printf(testName, format string, args ...any) { p.lastNameMu.Lock() defer p.lastNameMu.Unlock() @@ -680,7 +680,7 @@ func (c *common) decorate(s string, skip int) string { // flushToParent writes c.output to the parent after first writing the header // with the given format and arguments. -func (c *common) flushToParent(testName, format string, args ...interface{}) { +func (c *common) flushToParent(testName, format string, args ...any) { p := c.parent p.mu.Lock() defer p.mu.Unlock() @@ -743,21 +743,21 @@ func fmtDuration(d time.Duration) string { // TB is the interface common to T, B, and F. type TB interface { Cleanup(func()) - Error(args ...interface{}) - Errorf(format string, args ...interface{}) + Error(args ...any) + Errorf(format string, args ...any) Fail() FailNow() Failed() bool - Fatal(args ...interface{}) - Fatalf(format string, args ...interface{}) + Fatal(args ...any) + Fatalf(format string, args ...any) Helper() - Log(args ...interface{}) - Logf(format string, args ...interface{}) + Log(args ...any) + Logf(format string, args ...any) Name() string Setenv(key, value string) - Skip(args ...interface{}) + Skip(args ...any) SkipNow() - Skipf(format string, args ...interface{}) + Skipf(format string, args ...any) Skipped() bool TempDir() string @@ -906,7 +906,7 @@ func (c *common) logDepth(s string, depth int) { // and records the text in the error log. For tests, the text will be printed only if // the test fails or the -test.v flag is set. For benchmarks, the text is always // printed to avoid having performance depend on the value of the -test.v flag. -func (c *common) Log(args ...interface{}) { +func (c *common) Log(args ...any) { c.checkFuzzFn("Log") c.log(fmt.Sprintln(args...)) } @@ -916,48 +916,48 @@ func (c *common) Log(args ...interface{}) { // tests, the text will be printed only if the test fails or the -test.v flag is // set. For benchmarks, the text is always printed to avoid having performance // depend on the value of the -test.v flag. -func (c *common) Logf(format string, args ...interface{}) { +func (c *common) Logf(format string, args ...any) { c.checkFuzzFn("Logf") c.log(fmt.Sprintf(format, args...)) } // Error is equivalent to Log followed by Fail. -func (c *common) Error(args ...interface{}) { +func (c *common) Error(args ...any) { c.checkFuzzFn("Error") c.log(fmt.Sprintln(args...)) c.Fail() } // Errorf is equivalent to Logf followed by Fail. -func (c *common) Errorf(format string, args ...interface{}) { +func (c *common) Errorf(format string, args ...any) { c.checkFuzzFn("Errorf") c.log(fmt.Sprintf(format, args...)) c.Fail() } // Fatal is equivalent to Log followed by FailNow. -func (c *common) Fatal(args ...interface{}) { +func (c *common) Fatal(args ...any) { c.checkFuzzFn("Fatal") c.log(fmt.Sprintln(args...)) c.FailNow() } // Fatalf is equivalent to Logf followed by FailNow. -func (c *common) Fatalf(format string, args ...interface{}) { +func (c *common) Fatalf(format string, args ...any) { c.checkFuzzFn("Fatalf") c.log(fmt.Sprintf(format, args...)) c.FailNow() } // Skip is equivalent to Log followed by SkipNow. -func (c *common) Skip(args ...interface{}) { +func (c *common) Skip(args ...any) { c.checkFuzzFn("Skip") c.log(fmt.Sprintln(args...)) c.SkipNow() } // Skipf is equivalent to Logf followed by SkipNow. -func (c *common) Skipf(format string, args ...interface{}) { +func (c *common) Skipf(format string, args ...any) { c.checkFuzzFn("Skipf") c.log(fmt.Sprintf(format, args...)) c.SkipNow() @@ -1141,7 +1141,7 @@ const ( // runCleanup is called at the end of the test. // If catchPanic is true, this will catch panics, and return the recovered // value if any. -func (c *common) runCleanup(ph panicHandling) (panicVal interface{}) { +func (c *common) runCleanup(ph panicHandling) (panicVal any) { if ph == recoverAndReturnPanic { defer func() { panicVal = recover() @@ -1340,7 +1340,7 @@ func tRunner(t *T, fn func(t *T)) { t.signal <- signal }() - doPanic := func(err interface{}) { + doPanic := func(err any) { t.Fail() if r := t.runCleanup(recoverAndReturnPanic); r != nil { t.Logf("cleanup panicked with %v", r) @@ -1554,9 +1554,9 @@ func (f matchStringOnly) RunFuzzWorker(func(corpusEntry) error) error { return e func (f matchStringOnly) ReadCorpus(string, []reflect.Type) ([]corpusEntry, error) { return nil, errMain } -func (f matchStringOnly) CheckCorpus([]interface{}, []reflect.Type) error { return nil } -func (f matchStringOnly) ResetCoverage() {} -func (f matchStringOnly) SnapshotCoverage() {} +func (f matchStringOnly) CheckCorpus([]any, []reflect.Type) error { return nil } +func (f matchStringOnly) ResetCoverage() {} +func (f matchStringOnly) SnapshotCoverage() {} // Main is an internal function, part of the implementation of the "go test" command. // It was exported because it is cross-package and predates "internal" packages. @@ -1602,7 +1602,7 @@ type testDeps interface { CoordinateFuzzing(time.Duration, int64, time.Duration, int64, int, []corpusEntry, []reflect.Type, string, string) error RunFuzzWorker(func(corpusEntry) error) error ReadCorpus(string, []reflect.Type) ([]corpusEntry, error) - CheckCorpus([]interface{}, []reflect.Type) error + CheckCorpus([]any, []reflect.Type) error ResetCoverage() SnapshotCoverage() } diff --git a/src/text/scanner/scanner.go b/src/text/scanner/scanner.go index c5fc4ff93b..f1fbf9861d 100644 --- a/src/text/scanner/scanner.go +++ b/src/text/scanner/scanner.go @@ -340,7 +340,7 @@ func (s *Scanner) error(msg string) { fmt.Fprintf(os.Stderr, "%s: %s\n", pos, msg) } -func (s *Scanner) errorf(format string, args ...interface{}) { +func (s *Scanner) errorf(format string, args ...any) { s.error(fmt.Sprintf(format, args...)) } diff --git a/src/text/template/exec.go b/src/text/template/exec.go index c42cbb2ad3..37984cf91a 100644 --- a/src/text/template/exec.go +++ b/src/text/template/exec.go @@ -126,7 +126,7 @@ func (e ExecError) Unwrap() error { } // errorf records an ExecError and terminates processing. -func (s *state) errorf(format string, args ...interface{}) { +func (s *state) errorf(format string, args ...any) { name := doublePercent(s.tmpl.Name()) if s.node == nil { format = fmt.Sprintf("template: %s: %s", name, format) @@ -179,7 +179,7 @@ func errRecover(errp *error) { // the output writer. // A template may be executed safely in parallel, although if parallel // executions share a Writer the output may be interleaved. -func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error { +func (t *Template) ExecuteTemplate(wr io.Writer, name string, data any) error { tmpl := t.Lookup(name) if tmpl == nil { return fmt.Errorf("template: no template %q associated with template %q", name, t.name) @@ -197,11 +197,11 @@ func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) // // If data is a reflect.Value, the template applies to the concrete // value that the reflect.Value holds, as in fmt.Print. -func (t *Template) Execute(wr io.Writer, data interface{}) error { +func (t *Template) Execute(wr io.Writer, data any) error { return t.execute(wr, data) } -func (t *Template) execute(wr io.Writer, data interface{}) (err error) { +func (t *Template) execute(wr io.Writer, data any) (err error) { defer errRecover(&err) value, ok := data.(reflect.Value) if !ok { @@ -311,7 +311,7 @@ func (s *state) walkIfOrWith(typ parse.NodeType, dot reflect.Value, pipe *parse. // IsTrue reports whether the value is 'true', in the sense of not the zero of its type, // and whether the value has a meaningful truth value. This is the definition of // truth used by if and other such actions. -func IsTrue(val interface{}) (truth, ok bool) { +func IsTrue(val any) (truth, ok bool) { return isTrue(reflect.ValueOf(val)) } @@ -1023,7 +1023,7 @@ func (s *state) printValue(n parse.Node, v reflect.Value) { // printableValue returns the, possibly indirected, interface value inside v that // is best for a call to formatted printer. -func printableValue(v reflect.Value) (interface{}, bool) { +func printableValue(v reflect.Value) (any, bool) { if v.Kind() == reflect.Pointer { v, _ = indirect(v) // fmt.Fprint handles nil. } diff --git a/src/text/template/exec_test.go b/src/text/template/exec_test.go index 3c40aa901e..8c8143396d 100644 --- a/src/text/template/exec_test.go +++ b/src/text/template/exec_test.go @@ -46,7 +46,7 @@ type T struct { MSI map[string]int MSIone map[string]int // one element, for deterministic output MSIEmpty map[string]int - MXI map[interface{}]int + MXI map[any]int MII map[int]int MI32S map[int32]string MI64S map[int64]string @@ -56,11 +56,11 @@ type T struct { MUI8S map[uint8]string SMSI []map[string]int // Empty interfaces; used to see if we can dig inside one. - Empty0 interface{} // nil - Empty1 interface{} - Empty2 interface{} - Empty3 interface{} - Empty4 interface{} + Empty0 any // nil + Empty1 any + Empty2 any + Empty3 any + Empty4 any // Non-empty interfaces. NonEmptyInterface I NonEmptyInterfacePtS *I @@ -138,7 +138,7 @@ var tVal = &T{ SB: []bool{true, false}, MSI: map[string]int{"one": 1, "two": 2, "three": 3}, MSIone: map[string]int{"one": 1}, - MXI: map[interface{}]int{"one": 1}, + MXI: map[any]int{"one": 1}, MII: map[int]int{1: 1}, MI32S: map[int32]string{1: "one", 2: "two"}, MI64S: map[int64]string{2: "i642", 3: "i643"}, @@ -209,7 +209,7 @@ func (t *T) Method2(a uint16, b string) string { return fmt.Sprintf("Method2: %d %s", a, b) } -func (t *T) Method3(v interface{}) string { +func (t *T) Method3(v any) string { return fmt.Sprintf("Method3: %v", v) } @@ -249,7 +249,7 @@ func (u *U) TrueFalse(b bool) string { return "" } -func typeOf(arg interface{}) string { +func typeOf(arg any) string { return fmt.Sprintf("%T", arg) } @@ -257,7 +257,7 @@ type execTest struct { name string input string output string - data interface{} + data any ok bool } @@ -390,7 +390,7 @@ var execTests = []execTest{ {".VariadicFuncInt", "{{call .VariadicFuncInt 33 `he` `llo`}}", "33=", tVal, true}, {"if .BinaryFunc call", "{{ if .BinaryFunc}}{{call .BinaryFunc `1` `2`}}{{end}}", "[1=2]", tVal, true}, {"if not .BinaryFunc call", "{{ if not .BinaryFunc}}{{call .BinaryFunc `1` `2`}}{{else}}No{{end}}", "No", tVal, true}, - {"Interface Call", `{{stringer .S}}`, "foozle", map[string]interface{}{"S": bytes.NewBufferString("foozle")}, true}, + {"Interface Call", `{{stringer .S}}`, "foozle", map[string]any{"S": bytes.NewBufferString("foozle")}, true}, {".ErrFunc", "{{call .ErrFunc}}", "bla", tVal, true}, {"call nil", "{{call nil}}", "", tVal, false}, @@ -748,7 +748,7 @@ func add(args ...int) int { return sum } -func echo(arg interface{}) interface{} { +func echo(arg any) any { return arg } @@ -767,7 +767,7 @@ func stringer(s fmt.Stringer) string { return s.String() } -func mapOfThree() interface{} { +func mapOfThree() any { return map[string]int{"three": 3} } @@ -1468,7 +1468,7 @@ func TestBlock(t *testing.T) { func TestEvalFieldErrors(t *testing.T) { tests := []struct { name, src string - value interface{} + value any want string }{ { @@ -1611,7 +1611,7 @@ func TestInterfaceValues(t *testing.T) { for _, tt := range tests { tmpl := Must(New("tmpl").Parse(tt.text)) var buf bytes.Buffer - err := tmpl.Execute(&buf, map[string]interface{}{ + err := tmpl.Execute(&buf, map[string]any{ "PlusOne": func(n int) int { return n + 1 }, @@ -1640,7 +1640,7 @@ func TestInterfaceValues(t *testing.T) { // Check that panics during calls are recovered and returned as errors. func TestExecutePanicDuringCall(t *testing.T) { - funcs := map[string]interface{}{ + funcs := map[string]any{ "doPanic": func() string { panic("custom panic string") }, @@ -1648,7 +1648,7 @@ func TestExecutePanicDuringCall(t *testing.T) { tests := []struct { name string input string - data interface{} + data any wantErr string }{ { diff --git a/src/text/template/funcs.go b/src/text/template/funcs.go index 11e2e903c8..dca5ed28db 100644 --- a/src/text/template/funcs.go +++ b/src/text/template/funcs.go @@ -31,7 +31,7 @@ import ( // apply to arguments of arbitrary type can use parameters of type interface{} or // of type reflect.Value. Similarly, functions meant to return a result of arbitrary // type can return interface{} or reflect.Value. -type FuncMap map[string]interface{} +type FuncMap map[string]any // builtins returns the FuncMap. // It is not a global variable so the linker can dead code eliminate @@ -627,7 +627,7 @@ func HTMLEscapeString(s string) string { // HTMLEscaper returns the escaped HTML equivalent of the textual // representation of its arguments. -func HTMLEscaper(args ...interface{}) string { +func HTMLEscaper(args ...any) string { return HTMLEscapeString(evalArgs(args)) } @@ -718,13 +718,13 @@ func jsIsSpecial(r rune) bool { // JSEscaper returns the escaped JavaScript equivalent of the textual // representation of its arguments. -func JSEscaper(args ...interface{}) string { +func JSEscaper(args ...any) string { return JSEscapeString(evalArgs(args)) } // URLQueryEscaper returns the escaped value of the textual representation of // its arguments in a form suitable for embedding in a URL query. -func URLQueryEscaper(args ...interface{}) string { +func URLQueryEscaper(args ...any) string { return url.QueryEscape(evalArgs(args)) } @@ -733,7 +733,7 @@ func URLQueryEscaper(args ...interface{}) string { // except that each argument is indirected (if a pointer), as required, // using the same rules as the default string evaluation during template // execution. -func evalArgs(args []interface{}) string { +func evalArgs(args []any) string { ok := false var s string // Fast path for simple common case. diff --git a/src/text/template/parse/lex.go b/src/text/template/parse/lex.go index 95e33771c0..40d0411121 100644 --- a/src/text/template/parse/lex.go +++ b/src/text/template/parse/lex.go @@ -190,7 +190,7 @@ func (l *lexer) acceptRun(valid string) { // errorf returns an error token and terminates the scan by passing // back a nil pointer that will be the next state, terminating l.nextItem. -func (l *lexer) errorf(format string, args ...interface{}) stateFn { +func (l *lexer) errorf(format string, args ...any) stateFn { l.items <- item{itemError, l.start, fmt.Sprintf(format, args...), l.startLine} return nil } diff --git a/src/text/template/parse/parse.go b/src/text/template/parse/parse.go index 64b29a2e16..b0cbe9dfc8 100644 --- a/src/text/template/parse/parse.go +++ b/src/text/template/parse/parse.go @@ -24,7 +24,7 @@ type Tree struct { Mode Mode // parsing mode. text string // text parsed to create the template (or its parent) // Parsing only; cleared after parse. - funcs []map[string]interface{} + funcs []map[string]any lex *lexer token [3]item // three-token lookahead for parser. peekCount int @@ -59,7 +59,7 @@ func (t *Tree) Copy() *Tree { // templates described in the argument string. The top-level template will be // given the specified name. If an error is encountered, parsing stops and an // empty map is returned with the error. -func Parse(name, text, leftDelim, rightDelim string, funcs ...map[string]interface{}) (map[string]*Tree, error) { +func Parse(name, text, leftDelim, rightDelim string, funcs ...map[string]any) (map[string]*Tree, error) { treeSet := make(map[string]*Tree) t := New(name) t.text = text @@ -128,7 +128,7 @@ func (t *Tree) peekNonSpace() item { // Parsing. // New allocates a new parse tree with the given name. -func New(name string, funcs ...map[string]interface{}) *Tree { +func New(name string, funcs ...map[string]any) *Tree { return &Tree{ Name: name, funcs: funcs, @@ -158,7 +158,7 @@ func (t *Tree) ErrorContext(n Node) (location, context string) { } // errorf formats the error and terminates processing. -func (t *Tree) errorf(format string, args ...interface{}) { +func (t *Tree) errorf(format string, args ...any) { t.Root = nil format = fmt.Sprintf("template: %s:%d: %s", t.ParseName, t.token[0].line, format) panic(fmt.Errorf(format, args...)) @@ -218,7 +218,7 @@ func (t *Tree) recover(errp *error) { } // startParse initializes the parser, using the lexer. -func (t *Tree) startParse(funcs []map[string]interface{}, lex *lexer, treeSet map[string]*Tree) { +func (t *Tree) startParse(funcs []map[string]any, lex *lexer, treeSet map[string]*Tree) { t.Root = nil t.lex = lex t.vars = []string{"$"} @@ -240,7 +240,7 @@ func (t *Tree) stopParse() { // the template for execution. If either action delimiter string is empty, the // default ("{{" or "}}") is used. Embedded template definitions are added to // the treeSet map. -func (t *Tree) Parse(text, leftDelim, rightDelim string, treeSet map[string]*Tree, funcs ...map[string]interface{}) (tree *Tree, err error) { +func (t *Tree) Parse(text, leftDelim, rightDelim string, treeSet map[string]*Tree, funcs ...map[string]any) (tree *Tree, err error) { defer t.recover(&err) t.ParseName = t.Name emitComment := t.Mode&ParseComments != 0 diff --git a/src/text/template/parse/parse_test.go b/src/text/template/parse/parse_test.go index c3679a08de..0c4778c7b3 100644 --- a/src/text/template/parse/parse_test.go +++ b/src/text/template/parse/parse_test.go @@ -318,7 +318,7 @@ var parseTests = []parseTest{ {"block definition", `{{block "foo"}}hello{{end}}`, hasError, ""}, } -var builtins = map[string]interface{}{ +var builtins = map[string]any{ "printf": fmt.Sprintf, "contains": strings.Contains, } diff --git a/src/time/internal_test.go b/src/time/internal_test.go index 2c75e449d3..f0dddb7373 100644 --- a/src/time/internal_test.go +++ b/src/time/internal_test.go @@ -31,7 +31,7 @@ func forceZipFileForTesting(zipOnly bool) { var Interrupt = interrupt var DaysIn = daysIn -func empty(arg interface{}, seq uintptr) {} +func empty(arg any, seq uintptr) {} // Test that a runtimeTimer with a period that would overflow when on // expiration does not throw or cause other timers to hang. diff --git a/src/time/sleep.go b/src/time/sleep.go index b467d1d589..1ffaabec67 100644 --- a/src/time/sleep.go +++ b/src/time/sleep.go @@ -14,8 +14,8 @@ type runtimeTimer struct { pp uintptr when int64 period int64 - f func(interface{}, uintptr) // NOTE: must not be closure - arg interface{} + f func(any, uintptr) // NOTE: must not be closure + arg any seq uintptr nextwhen int64 status uint32 @@ -41,7 +41,7 @@ func when(d Duration) int64 { func startTimer(*runtimeTimer) func stopTimer(*runtimeTimer) bool func resetTimer(*runtimeTimer, int64) bool -func modTimer(t *runtimeTimer, when, period int64, f func(interface{}, uintptr), arg interface{}, seq uintptr) +func modTimer(t *runtimeTimer, when, period int64, f func(any, uintptr), arg any, seq uintptr) // The Timer type represents a single event. // When the Timer expires, the current time will be sent on C, @@ -140,7 +140,7 @@ func (t *Timer) Reset(d Duration) bool { } // sendTime does a non-blocking send of the current time on c. -func sendTime(c interface{}, seq uintptr) { +func sendTime(c any, seq uintptr) { select { case c.(chan Time) <- Now(): default: @@ -172,6 +172,6 @@ func AfterFunc(d Duration, f func()) *Timer { return t } -func goFunc(arg interface{}, seq uintptr) { +func goFunc(arg any, seq uintptr) { go arg.(func())() } diff --git a/src/time/tzdata/generate_zipdata.go b/src/time/tzdata/generate_zipdata.go index 4f40b51c73..653577cafa 100644 --- a/src/time/tzdata/generate_zipdata.go +++ b/src/time/tzdata/generate_zipdata.go @@ -71,7 +71,7 @@ func main() { } } -func die(format string, args ...interface{}) { +func die(format string, args ...any) { fmt.Fprintf(os.Stderr, format+"\n", args...) os.Exit(1) } From f909f813a0c12fde089a6c5e18fdcb9e71759cf7 Mon Sep 17 00:00:00 2001 From: Katie Hockman Date: Fri, 10 Dec 2021 14:03:20 -0500 Subject: [PATCH 472/752] testing: update docs for fuzzcachedir Although most of the code seems to be already implemented to support this for general use, it didn't make it in for Go 1.18, so for now we should at least document that it's only for use by the go command. Change-Id: Id559e72d590aedeaaa50bcf880bca1a385d858dd Reviewed-on: https://go-review.googlesource.com/c/go/+/370954 Trust: Katie Hockman Run-TryBot: Katie Hockman TryBot-Result: Gopher Robot Reviewed-by: Bryan Mills --- src/testing/fuzz.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go index 18f2b2f319..4a5def1ab4 100644 --- a/src/testing/fuzz.go +++ b/src/testing/fuzz.go @@ -22,8 +22,9 @@ func initFuzzFlags() { matchFuzz = flag.String("test.fuzz", "", "run the fuzz test matching `regexp`") flag.Var(&fuzzDuration, "test.fuzztime", "time to spend fuzzing; default is to run indefinitely") flag.Var(&minimizeDuration, "test.fuzzminimizetime", "time to spend minimizing a value after finding a failing input") - fuzzCacheDir = flag.String("test.fuzzcachedir", "", "directory where interesting fuzzing inputs are stored") - isFuzzWorker = flag.Bool("test.fuzzworker", false, "coordinate with the parent process to fuzz random values") + + fuzzCacheDir = flag.String("test.fuzzcachedir", "", "directory where interesting fuzzing inputs are stored (for use only by cmd/go)") + isFuzzWorker = flag.Bool("test.fuzzworker", false, "coordinate with the parent process to fuzz random values (for use only by cmd/go)") } var ( From 3e8aa5dd495d30ff29cd4fb78aabe8fc0ebb1eda Mon Sep 17 00:00:00 2001 From: Than McIntosh Date: Mon, 13 Dec 2021 12:03:13 -0500 Subject: [PATCH 473/752] cmd/compile/internal/amd64: fix for coverage testing Fix up a unit test to make it more friendly for coverage runs. Currently on tip if you do cd ${GOROOT}/src ; go test -cover cmd/compile/... it will cause a failure in the TestGoAMD64v1 testpoint of cmd/compile/internal/amd64, the reason being that this testpoint copies and reruns the test executable, expecting the rerun to produce only the output "PASS", whereas if "-cover" is used, the output will include percentage of statements covered as well. To fix, rework the test to tolerate additional output if coverage is enabled. Change-Id: I2512e06ca06e5f38108f2891ff84276d148c4f9e Reviewed-on: https://go-review.googlesource.com/c/go/+/371234 Reviewed-by: Keith Randall Run-TryBot: Keith Randall TryBot-Result: Gopher Robot Reviewed-by: Cherry Mui --- src/cmd/compile/internal/amd64/versions_test.go | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/cmd/compile/internal/amd64/versions_test.go b/src/cmd/compile/internal/amd64/versions_test.go index ee1a8ca3aa..7aa697b811 100644 --- a/src/cmd/compile/internal/amd64/versions_test.go +++ b/src/cmd/compile/internal/amd64/versions_test.go @@ -74,8 +74,18 @@ func TestGoAMD64v1(t *testing.T) { if err != nil { t.Fatalf("couldn't execute test: %s", err) } - if string(out) != "PASS\n" { - t.Fatalf("test reported error: %s", string(out)) + // Expect to see output of the form "PASS\n", unless the test binary + // was compiled for coverage (in which case there will be an extra line). + success := false + lines := strings.Split(string(out), "\n") + if len(lines) == 2 { + success = lines[0] == "PASS" && lines[1] == "" + } else if len(lines) == 3 { + success = lines[0] == "PASS" && + strings.HasPrefix(lines[1], "coverage") && lines[2] == "" + } + if !success { + t.Fatalf("test reported error: %s lines=%+v", string(out), lines) } } From 7bdbc73be1d10a9b32cb5edc6b9d0c93805f059c Mon Sep 17 00:00:00 2001 From: Katie Hockman Date: Fri, 10 Dec 2021 14:25:55 -0500 Subject: [PATCH 474/752] cmd/go: document -fuzzminimizetime Change-Id: I435942ff7285d32ffbc8901d9d7e76544d5aeb61 Reviewed-on: https://go-review.googlesource.com/c/go/+/370881 Trust: Katie Hockman Run-TryBot: Katie Hockman Reviewed-by: Bryan Mills TryBot-Result: Gopher Robot --- src/cmd/go/alldocs.go | 18 +++++++++++++----- src/cmd/go/internal/test/test.go | 18 +++++++++++++----- 2 files changed, 26 insertions(+), 10 deletions(-) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index f9a2b59c05..6703792054 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -2861,11 +2861,19 @@ // section of the testing package documentation for details. // // -fuzztime t -// Run enough iterations of the fuzz test to take t, specified as a -// time.Duration (for example, -fuzztime 1h30s). The default is to run -// forever. -// The special syntax Nx means to run the fuzz test N times -// (for example, -fuzztime 100x). +// Run enough iterations of the fuzz target during fuzzing to take t, +// specified as a time.Duration (for example, -fuzztime 1h30s). +// The default is to run forever. +// The special syntax Nx means to run the fuzz target N times +// (for example, -fuzztime 1000x). +// +// -fuzzminimizetime t +// Run enough iterations of the fuzz target during each minimization +// attempt to take t, as specified as a time.Duration (for example, +// -fuzzminimizetime 30s). +// The default is 60s. +// The special syntax Nx means to run the fuzz target N times +// (for example, -fuzzminimizetime 100x). // // -json // Log verbose output and test results in JSON. This presents the diff --git a/src/cmd/go/internal/test/test.go b/src/cmd/go/internal/test/test.go index 7ea9d4f1f1..50e6d5201b 100644 --- a/src/cmd/go/internal/test/test.go +++ b/src/cmd/go/internal/test/test.go @@ -257,11 +257,19 @@ control the execution of any test: section of the testing package documentation for details. -fuzztime t - Run enough iterations of the fuzz test to take t, specified as a - time.Duration (for example, -fuzztime 1h30s). The default is to run - forever. - The special syntax Nx means to run the fuzz test N times - (for example, -fuzztime 100x). + Run enough iterations of the fuzz target during fuzzing to take t, + specified as a time.Duration (for example, -fuzztime 1h30s). + The default is to run forever. + The special syntax Nx means to run the fuzz target N times + (for example, -fuzztime 1000x). + + -fuzzminimizetime t + Run enough iterations of the fuzz target during each minimization + attempt to take t, as specified as a time.Duration (for example, + -fuzzminimizetime 30s). + The default is 60s. + The special syntax Nx means to run the fuzz target N times + (for example, -fuzzminimizetime 100x). -json Log verbose output and test results in JSON. This presents the From 9e85dc5f183d688f5297203dd76f281a6d87d94f Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 13 Dec 2021 16:12:50 -0500 Subject: [PATCH 475/752] net/http: revert h2_bundle.go formatting change from CL 368254 h2_bundle.go is automatically generated from x/net/http2. Any formatting changes within that file need to be first made upstream. This brings the contents of h2_bundle.go back in line with the upstream generator, fixing the cmd/internal/moddeps test that is currently failing on the longtest builders. For #49884 Change-Id: I5757240b77e250e0026b8a52a0e867e1578ec2d4 Reviewed-on: https://go-review.googlesource.com/c/go/+/371297 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: David Chase TryBot-Result: Gopher Robot --- src/net/http/h2_bundle.go | 52 +++++++++++++++++++-------------------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go index 83b6d29144..bb82f24585 100644 --- a/src/net/http/h2_bundle.go +++ b/src/net/http/h2_bundle.go @@ -1049,11 +1049,11 @@ var ( 16 << 10, } http2dataChunkPools = [...]sync.Pool{ - {New: func() any { return make([]byte, 1<<10) }}, - {New: func() any { return make([]byte, 2<<10) }}, - {New: func() any { return make([]byte, 4<<10) }}, - {New: func() any { return make([]byte, 8<<10) }}, - {New: func() any { return make([]byte, 16<<10) }}, + {New: func() interface{} { return make([]byte, 1<<10) }}, + {New: func() interface{} { return make([]byte, 2<<10) }}, + {New: func() interface{} { return make([]byte, 4<<10) }}, + {New: func() interface{} { return make([]byte, 8<<10) }}, + {New: func() interface{} { return make([]byte, 16<<10) }}, } ) @@ -1548,7 +1548,7 @@ func (h *http2FrameHeader) invalidate() { h.valid = false } // frame header bytes. // Used only by ReadFrameHeader. var http2fhBytes = sync.Pool{ - New: func() any { + New: func() interface{} { buf := make([]byte, http2frameHeaderLen) return &buf }, @@ -1655,8 +1655,8 @@ type http2Framer struct { debugFramer *http2Framer // only use for logging written writes debugFramerBuf *bytes.Buffer - debugReadLoggerf func(string, ...any) - debugWriteLoggerf func(string, ...any) + debugReadLoggerf func(string, ...interface{}) + debugWriteLoggerf func(string, ...interface{}) frameCache *http2frameCache // nil if frames aren't reused (default) } @@ -3061,7 +3061,7 @@ func http2curGoroutineID() uint64 { } var http2littleBuf = sync.Pool{ - New: func() any { + New: func() interface{} { buf := make([]byte, 64) return &buf }, @@ -3468,7 +3468,7 @@ func http2newBufferedWriter(w io.Writer) *http2bufferedWriter { const http2bufWriterPoolBufferSize = 4 << 10 var http2bufWriterPool = sync.Pool{ - New: func() any { + New: func() interface{} { return bufio.NewWriterSize(nil, http2bufWriterPoolBufferSize) }, } @@ -3540,7 +3540,7 @@ type http2connectionStater interface { ConnectionState() tls.ConnectionState } -var http2sorterPool = sync.Pool{New: func() any { return new(http2sorter) }} +var http2sorterPool = sync.Pool{New: func() interface{} { return new(http2sorter) }} type http2sorter struct { v []string // owned by sorter @@ -3781,7 +3781,7 @@ var ( ) var http2responseWriterStatePool = sync.Pool{ - New: func() any { + New: func() interface{} { rws := &http2responseWriterState{} rws.bw = bufio.NewWriterSize(http2chunkWriter{rws}, http2handlerChunkWriteSize) return rws @@ -3793,7 +3793,7 @@ var ( http2testHookOnConn func() http2testHookGetServerConn func(*http2serverConn) http2testHookOnPanicMu *sync.Mutex // nil except in tests - http2testHookOnPanic func(sc *http2serverConn, panicVal any) (rePanic bool) + http2testHookOnPanic func(sc *http2serverConn, panicVal interface{}) (rePanic bool) ) // Server is an HTTP/2 server. @@ -4086,7 +4086,7 @@ func (s *http2Server) ServeConn(c net.Conn, opts *http2ServeConnOpts) { streams: make(map[uint32]*http2stream), readFrameCh: make(chan http2readFrameResult), wantWriteFrameCh: make(chan http2FrameWriteRequest, 8), - serveMsgCh: make(chan any, 8), + serveMsgCh: make(chan interface{}, 8), wroteFrameCh: make(chan http2frameWriteResult, 1), // buffered; one send in writeFrameAsync bodyReadCh: make(chan http2bodyReadMsg), // buffering doesn't matter either way doneServing: make(chan struct{}), @@ -4216,7 +4216,7 @@ type http2serverConn struct { wantWriteFrameCh chan http2FrameWriteRequest // from handlers -> serve wroteFrameCh chan http2frameWriteResult // from writeFrameAsync -> serve, tickles more frame writes bodyReadCh chan http2bodyReadMsg // from handlers -> serve - serveMsgCh chan any // misc messages & code to send to / run on the serve loop + serveMsgCh chan interface{} // misc messages & code to send to / run on the serve loop flow http2flow // conn-wide (not stream-specific) outbound flow control inflow http2flow // conn-wide inbound flow control tlsState *tls.ConnectionState // shared by all handlers, like net/http @@ -4351,13 +4351,13 @@ func (sc *http2serverConn) setConnState(state ConnState) { } } -func (sc *http2serverConn) vlogf(format string, args ...any) { +func (sc *http2serverConn) vlogf(format string, args ...interface{}) { if http2VerboseLogs { sc.logf(format, args...) } } -func (sc *http2serverConn) logf(format string, args ...any) { +func (sc *http2serverConn) logf(format string, args ...interface{}) { if lg := sc.hs.ErrorLog; lg != nil { lg.Printf(format, args...) } else { @@ -4409,7 +4409,7 @@ func http2isClosedConnError(err error) bool { return false } -func (sc *http2serverConn) condlogf(err error, format string, args ...any) { +func (sc *http2serverConn) condlogf(err error, format string, args ...interface{}) { if err == nil { return } @@ -4679,7 +4679,7 @@ func (sc *http2serverConn) onIdleTimer() { sc.sendServeMsg(http2idleTimerMsg) } func (sc *http2serverConn) onShutdownTimer() { sc.sendServeMsg(http2shutdownTimerMsg) } -func (sc *http2serverConn) sendServeMsg(msg any) { +func (sc *http2serverConn) sendServeMsg(msg interface{}) { sc.serveG.checkNotOn() // NOT select { case sc.serveMsgCh <- msg: @@ -4721,11 +4721,11 @@ func (sc *http2serverConn) readPreface() error { } var http2errChanPool = sync.Pool{ - New: func() any { return make(chan error, 1) }, + New: func() interface{} { return make(chan error, 1) }, } var http2writeDataPool = sync.Pool{ - New: func() any { return new(http2writeData) }, + New: func() interface{} { return new(http2writeData) }, } // writeDataFromHandler writes DATA response frames from a handler on @@ -6712,7 +6712,7 @@ func http2new400Handler(err error) HandlerFunc { // disabled. See comments on h1ServerShutdownChan above for why // the code is written this way. func http2h1ServerKeepAlivesDisabled(hs *Server) bool { - var x any = hs + var x interface{} = hs type I interface { doKeepAlives() bool } @@ -9577,21 +9577,21 @@ var ( http2errRequestHeaderListSize = errors.New("http2: request header list larger than peer's advertised limit") ) -func (cc *http2ClientConn) logf(format string, args ...any) { +func (cc *http2ClientConn) logf(format string, args ...interface{}) { cc.t.logf(format, args...) } -func (cc *http2ClientConn) vlogf(format string, args ...any) { +func (cc *http2ClientConn) vlogf(format string, args ...interface{}) { cc.t.vlogf(format, args...) } -func (t *http2Transport) vlogf(format string, args ...any) { +func (t *http2Transport) vlogf(format string, args ...interface{}) { if http2VerboseLogs { t.logf(format, args...) } } -func (t *http2Transport) logf(format string, args ...any) { +func (t *http2Transport) logf(format string, args ...interface{}) { log.Printf(format, args...) } From 67917c3d78002ebca7de697f4ede74e602701554 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Mon, 13 Dec 2021 10:24:07 -0500 Subject: [PATCH 476/752] cmd/internal/obj: fix tail call in non-zero frame leaf function on MIPS and S390X A "RET f(SB)" wasn't assembled correctly in a leaf function with non-zero frame size. Follows CL 371034, for MIPS(32/64)(be/le) and S390X. Other architectures seem to do it right. Add a test. Change-Id: I41349a7ae9862b924f3a3de2bcb55b782061ce21 Reviewed-on: https://go-review.googlesource.com/c/go/+/371214 Trust: Cherry Mui Run-TryBot: Cherry Mui Reviewed-by: David Chase --- src/cmd/internal/obj/mips/obj0.go | 12 +++++++++--- src/cmd/internal/obj/s390x/objz.go | 9 +++++++-- test/retjmp.dir/a.s | 4 ++++ test/retjmp.dir/main.go | 8 +++++++- 4 files changed, 27 insertions(+), 6 deletions(-) diff --git a/src/cmd/internal/obj/mips/obj0.go b/src/cmd/internal/obj/mips/obj0.go index 9e2ccc1929..b96a28a944 100644 --- a/src/cmd/internal/obj/mips/obj0.go +++ b/src/cmd/internal/obj/mips/obj0.go @@ -466,9 +466,15 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) { q = c.newprog() q.As = AJMP q.Pos = p.Pos - q.To.Type = obj.TYPE_MEM - q.To.Offset = 0 - q.To.Reg = REGLINK + if retSym != nil { // retjmp + q.To.Type = obj.TYPE_BRANCH + q.To.Name = obj.NAME_EXTERN + q.To.Sym = retSym + } else { + q.To.Type = obj.TYPE_MEM + q.To.Reg = REGLINK + q.To.Offset = 0 + } q.Mark |= BRANCH q.Spadj = +autosize diff --git a/src/cmd/internal/obj/s390x/objz.go b/src/cmd/internal/obj/s390x/objz.go index de40ff05af..aebbf8dbc5 100644 --- a/src/cmd/internal/obj/s390x/objz.go +++ b/src/cmd/internal/obj/s390x/objz.go @@ -488,8 +488,13 @@ func preprocess(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) { q = obj.Appendp(p, c.newprog) q.As = ABR q.From = obj.Addr{} - q.To.Type = obj.TYPE_REG - q.To.Reg = REG_LR + if retTarget == nil { + q.To.Type = obj.TYPE_REG + q.To.Reg = REG_LR + } else { + q.To.Type = obj.TYPE_BRANCH + q.To.Sym = retTarget + } q.Mark |= BRANCH q.Spadj = autosize break diff --git a/test/retjmp.dir/a.s b/test/retjmp.dir/a.s index c67a06638f..101b3428fc 100644 --- a/test/retjmp.dir/a.s +++ b/test/retjmp.dir/a.s @@ -10,3 +10,7 @@ TEXT ·f(SB), 4, $8-0 TEXT ·leaf(SB), 4, $0-0 RET ·f3(SB) JMP ·unreachable(SB) + +TEXT ·leaf2(SB), 4, $32-0 // nonzero frame size + RET ·f4(SB) + JMP ·unreachable(SB) diff --git a/test/retjmp.dir/main.go b/test/retjmp.dir/main.go index cb4bd018bf..0bed5a61b7 100644 --- a/test/retjmp.dir/main.go +++ b/test/retjmp.dir/main.go @@ -6,8 +6,9 @@ package main func f() func leaf() +func leaf2() -var f1called, f2called, f3called bool +var f1called, f2called, f3called, f4called bool func main() { f() @@ -21,11 +22,16 @@ func main() { if !f3called { panic("f3 not called") } + leaf2() + if !f4called { + panic("f4 not called") + } } func f1() { f1called = true } func f2() { f2called = true } func f3() { f3called = true } +func f4() { f4called = true } func unreachable() { panic("unreachable function called") From 5b9207ff67bd3df43a95fd403b2e06e2aa4c33bf Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Mon, 13 Dec 2021 12:42:38 -0800 Subject: [PATCH 477/752] cmd/compile: avoid re-instantiating method that is already imported We can import an shape-instantiated function/method for inlining purposes. If we are instantiating the methods of a instantiated type that we have seen, and it happens to need a shape instantiation that we have imported, then don't re-create the instantiation, since we will end up with conflicting/duplicate definitions for the instantiation symbol. Instead, we can just use the existing imported instantation, and enter it in the instInfoMap[]. Fixes #50121 Change-Id: I6eeb8786faad71106e261e113048b579afad04fa Reviewed-on: https://go-review.googlesource.com/c/go/+/371414 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: Keith Randall --- src/cmd/compile/internal/noder/stencil.go | 19 +++++++++++++++++-- test/typeparam/issue50121.dir/a.go | 22 ++++++++++++++++++++++ test/typeparam/issue50121.dir/main.go | 18 ++++++++++++++++++ test/typeparam/issue50121.go | 7 +++++++ 4 files changed, 64 insertions(+), 2 deletions(-) create mode 100644 test/typeparam/issue50121.dir/a.go create mode 100644 test/typeparam/issue50121.dir/main.go create mode 100644 test/typeparam/issue50121.go diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go index 004db54c3b..62c306b89e 100644 --- a/src/cmd/compile/internal/noder/stencil.go +++ b/src/cmd/compile/internal/noder/stencil.go @@ -684,7 +684,22 @@ func (g *genInst) getInstantiation(nameNode *ir.Name, shapes []*types.Type, isMe } info.dictInfo.shapeToBound = make(map[*types.Type]*types.Type) - // genericSubst fills in info.dictParam and info.tparamToBound. + if sym.Def != nil { + // This instantiation must have been imported from another + // package (because it was needed for inlining), so we should + // not re-generate it and have conflicting definitions for the + // symbol (issue #50121). It will have already gone through the + // dictionary transformations of dictPass, so we don't actually + // need the info.dictParam and info.shapeToBound info filled in + // below. We just set the imported instantiation as info.fun. + assert(sym.Pkg != types.LocalPkg) + info.fun = sym.Def.(*ir.Name).Func + assert(info.fun != nil) + g.instInfoMap[sym] = info + return info + } + + // genericSubst fills in info.dictParam and info.shapeToBound. st := g.genericSubst(sym, nameNode, shapes, isMeth, info) info.fun = st g.instInfoMap[sym] = info @@ -722,7 +737,7 @@ type subster struct { // args shapes. For a method with a generic receiver, it returns an instantiated // function type where the receiver becomes the first parameter. For either a generic // method or function, a dictionary parameter is the added as the very first -// parameter. genericSubst fills in info.dictParam and info.tparamToBound. +// parameter. genericSubst fills in info.dictParam and info.shapeToBound. func (g *genInst) genericSubst(newsym *types.Sym, nameNode *ir.Name, shapes []*types.Type, isMethod bool, info *instInfo) *ir.Func { var tparams []*types.Type if isMethod { diff --git a/test/typeparam/issue50121.dir/a.go b/test/typeparam/issue50121.dir/a.go new file mode 100644 index 0000000000..9918fa38a6 --- /dev/null +++ b/test/typeparam/issue50121.dir/a.go @@ -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. + +package a + +import ( + "constraints" + "math/rand" +) + +type Builder[T constraints.Integer] struct{} + +func (r Builder[T]) New() T { + return T(rand.Int()) +} + +var IntBuilder = Builder[int]{} + +func BuildInt() int { + return IntBuilder.New() +} diff --git a/test/typeparam/issue50121.dir/main.go b/test/typeparam/issue50121.dir/main.go new file mode 100644 index 0000000000..71eb44ff62 --- /dev/null +++ b/test/typeparam/issue50121.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" +) + +//go:noinline +func BuildInt() int { + return a.BuildInt() +} + +func main() { + BuildInt() +} diff --git a/test/typeparam/issue50121.go b/test/typeparam/issue50121.go new file mode 100644 index 0000000000..76930e5e4f --- /dev/null +++ b/test/typeparam/issue50121.go @@ -0,0 +1,7 @@ +// rundir -G=3 + +// 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 From 006d4e627812816123a5bb86ebf5a2fa57af8b4a Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Mon, 13 Dec 2021 16:15:52 -0800 Subject: [PATCH 478/752] cmd/compile: fix case where we didn't delay transformAssign in varDecl We delay all transformations on generic functions, and only do them on instantiated functions, for several reasons, of which one is that otherwise the compiler won't understand the relationship between constrained type parameters. In an instantiation with shape arguments, the underlying relationship between the type arguments are clear and don't lead to compiler errors. This issue is because I missed delaying assignment transformations for variable declarations. So, we were trying to transform an assignment, and the compiler doesn't understand the relationship between the T and U type parameters. The fix is to delay assignment transformations for variable declarations of generic functions, just as we do already for normal assignment statements. A work-around for this issue would be to just separate the assignment from the variable declaration in the generic function (for this case of an assignment involving both of the constrained type parameters). Fixes #50147 Change-Id: Icdbcda147e5c4b386e4715811761cbe73d0d837e Reviewed-on: https://go-review.googlesource.com/c/go/+/371534 Trust: Dan Scales Reviewed-by: Keith Randall --- src/cmd/compile/internal/noder/decl.go | 24 ++++++++++++++---------- test/typeparam/issue50147.go | 11 +++++++++++ 2 files changed, 25 insertions(+), 10 deletions(-) create mode 100644 test/typeparam/issue50147.go diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go index b7fd95e2e8..df1ca1c505 100644 --- a/src/cmd/compile/internal/noder/decl.go +++ b/src/cmd/compile/internal/noder/decl.go @@ -286,22 +286,26 @@ func (g *irgen) varDecl(out *ir.Nodes, decl *syntax.VarDecl) { } else if ir.CurFunc == nil { name.Defn = as } - lhs := []ir.Node{as.X} - rhs := []ir.Node{} - if as.Y != nil { - rhs = []ir.Node{as.Y} - } - transformAssign(as, lhs, rhs) - as.X = lhs[0] - if as.Y != nil { - as.Y = rhs[0] + if !g.delayTransform() { + lhs := []ir.Node{as.X} + rhs := []ir.Node{} + if as.Y != nil { + rhs = []ir.Node{as.Y} + } + transformAssign(as, lhs, rhs) + as.X = lhs[0] + if as.Y != nil { + as.Y = rhs[0] + } } as.SetTypecheck(1) out.Append(as) } } if as2 != nil { - transformAssign(as2, as2.Lhs, as2.Rhs) + if !g.delayTransform() { + transformAssign(as2, as2.Lhs, as2.Rhs) + } as2.SetTypecheck(1) out.Append(as2) } diff --git a/test/typeparam/issue50147.go b/test/typeparam/issue50147.go new file mode 100644 index 0000000000..2bdce6c504 --- /dev/null +++ b/test/typeparam/issue50147.go @@ -0,0 +1,11 @@ +// compile -G=3 + +// 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 Foo[T any, U interface{ *T }](x T) { + var _ U = &x +} From 1afa432ab93aa9adb2e0f04b6c15eb654762d652 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 13 Dec 2021 15:04:43 -0800 Subject: [PATCH 479/752] go/types, types2: record (top-level) union types Fixes #50093. Change-Id: Ibebeda542d2a81c979670f9098c4a6d2c3e73abb Reviewed-on: https://go-review.googlesource.com/c/go/+/371514 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/api.go | 6 +++++ src/cmd/compile/internal/types2/api_test.go | 10 ++++++++ src/cmd/compile/internal/types2/interface.go | 10 +------- src/cmd/compile/internal/types2/union.go | 24 +++++++++++++++----- src/go/types/api.go | 6 +++++ src/go/types/api_test.go | 10 ++++++++ src/go/types/interface.go | 10 +------- src/go/types/union.go | 24 +++++++++++++++----- 8 files changed, 70 insertions(+), 30 deletions(-) diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go index 4ea3989c39..ed5bced643 100644 --- a/src/cmd/compile/internal/types2/api.go +++ b/src/cmd/compile/internal/types2/api.go @@ -202,6 +202,12 @@ type Info struct { // identifier z in a variable declaration 'var z int' is found // only in the Defs map, and identifiers denoting packages in // qualified identifiers are collected in the Uses map. + // + // For binary expressions representing unions in constraint + // position or type elements in interfaces, a union type is + // recorded for the top-level expression only. For instance, + // given the constraint a|b|c, the union type for (a|b)|c + // is recorded, but not the union type for a|b. Types map[syntax.Expr]TypeAndValue // Instances maps identifiers denoting parameterized types or functions to diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go index 4227397df9..fc8b5cd4ee 100644 --- a/src/cmd/compile/internal/types2/api_test.go +++ b/src/cmd/compile/internal/types2/api_test.go @@ -342,6 +342,16 @@ func TestTypesInfo(t *testing.T) { // issue 47895 {`package p; import "unsafe"; type S struct { f int }; var s S; var _ = unsafe.Offsetof(s.f)`, `s.f`, `int`}, + + // issue 50093 + {`package u0a; func _[_ interface{int}]() {}`, `int`, `int`}, + {`package u1a; func _[_ interface{~int}]() {}`, `~int`, `~int`}, + {`package u2a; func _[_ interface{int|string}]() {}`, `int | string`, `int|string`}, + {`package u3a; func _[_ interface{int|string|~bool}]() {}`, `int | string | ~bool`, `int|string|~bool`}, + {`package u0b; func _[_ int]() {}`, `int`, `int`}, + {`package u1b; func _[_ ~int]() {}`, `~int`, `~int`}, + {`package u2b; func _[_ int|string]() {}`, `int | string`, `int|string`}, + {`package u3b; func _[_ int|string|~bool]() {}`, `int | string | ~bool`, `int|string|~bool`}, } for _, test := range tests { diff --git a/src/cmd/compile/internal/types2/interface.go b/src/cmd/compile/internal/types2/interface.go index 96c92ccaec..b048fdd9e2 100644 --- a/src/cmd/compile/internal/types2/interface.go +++ b/src/cmd/compile/internal/types2/interface.go @@ -111,7 +111,7 @@ func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType for _, f := range iface.MethodList { if f.Name == nil { - addEmbedded(posFor(f.Type), parseUnion(check, flattenUnion(nil, f.Type))) + addEmbedded(posFor(f.Type), parseUnion(check, f.Type)) continue } // f.Name != nil @@ -182,11 +182,3 @@ func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType ityp.check = nil }).describef(iface, "compute type set for %s", ityp) } - -func flattenUnion(list []syntax.Expr, x syntax.Expr) []syntax.Expr { - if o, _ := x.(*syntax.Operation); o != nil && o.Op == syntax.Or { - list = flattenUnion(list, o.X) - x = o.Y - } - return append(list, x) -} diff --git a/src/cmd/compile/internal/types2/union.go b/src/cmd/compile/internal/types2/union.go index 2304b30280..97581fe863 100644 --- a/src/cmd/compile/internal/types2/union.go +++ b/src/cmd/compile/internal/types2/union.go @@ -46,10 +46,11 @@ func (t *Term) String() string { return (*term)(t).String() } // Avoid excessive type-checking times due to quadratic termlist operations. const maxTermCount = 100 -// parseUnion parses the given list of type expressions tlist as a union of -// those expressions. The result is a Union type, or Typ[Invalid] for some -// errors. -func parseUnion(check *Checker, tlist []syntax.Expr) Type { +// parseUnion parses uexpr as a union of expressions. +// The result is a Union type, or Typ[Invalid] for some errors. +func parseUnion(check *Checker, uexpr syntax.Expr) Type { + tlist := flattenUnion(nil, uexpr) + var terms []*Term for _, x := range tlist { tilde, typ := parseTilde(check, x) @@ -57,10 +58,11 @@ func parseUnion(check *Checker, tlist []syntax.Expr) Type { // Single type. Ok to return early because all relevant // checks have been performed in parseTilde (no need to // run through term validity check below). - return typ + return typ // typ already recorded through check.typ in parseTilde } if len(terms) >= maxTermCount { check.errorf(x, "cannot handle more than %d union terms (implementation limitation)", maxTermCount) + check.recordTypeAndValue(uexpr, typexpr, Typ[Invalid], nil) return Typ[Invalid] } terms = append(terms, NewTerm(tilde, typ)) @@ -105,7 +107,9 @@ func parseUnion(check *Checker, tlist []syntax.Expr) Type { } }) - return &Union{terms, nil} + u := &Union{terms, nil} + check.recordTypeAndValue(uexpr, typexpr, u, nil) + return u } func parseTilde(check *Checker, x syntax.Expr) (tilde bool, typ Type) { @@ -143,3 +147,11 @@ func overlappingTerm(terms []*Term, y *Term) int { } return -1 } + +func flattenUnion(list []syntax.Expr, x syntax.Expr) []syntax.Expr { + if o, _ := x.(*syntax.Operation); o != nil && o.Op == syntax.Or { + list = flattenUnion(list, o.X) + x = o.Y + } + return append(list, x) +} diff --git a/src/go/types/api.go b/src/go/types/api.go index 51d58c49aa..c4d81c1491 100644 --- a/src/go/types/api.go +++ b/src/go/types/api.go @@ -197,6 +197,12 @@ type Info struct { // identifier z in a variable declaration 'var z int' is found // only in the Defs map, and identifiers denoting packages in // qualified identifiers are collected in the Uses map. + // + // For binary expressions representing unions in constraint + // position or type elements in interfaces, a union type is + // recorded for the top-level expression only. For instance, + // given the constraint a|b|c, the union type for (a|b)|c + // is recorded, but not the union type for a|b. Types map[ast.Expr]TypeAndValue // Instances maps identifiers denoting parameterized types or functions to diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go index 7b7baa7604..1ee9806fd0 100644 --- a/src/go/types/api_test.go +++ b/src/go/types/api_test.go @@ -373,6 +373,16 @@ func TestTypesInfo(t *testing.T) { // issue 47895 {`package p; import "unsafe"; type S struct { f int }; var s S; var _ = unsafe.Offsetof(s.f)`, `s.f`, `int`}, + + // issue 50093 + {genericPkg + `u0a; func _[_ interface{int}]() {}`, `int`, `int`}, + {genericPkg + `u1a; func _[_ interface{~int}]() {}`, `~int`, `~int`}, + {genericPkg + `u2a; func _[_ interface{int|string}]() {}`, `int | string`, `int|string`}, + {genericPkg + `u3a; func _[_ interface{int|string|~bool}]() {}`, `int | string | ~bool`, `int|string|~bool`}, + {genericPkg + `u0b; func _[_ int]() {}`, `int`, `int`}, + {genericPkg + `u1b; func _[_ ~int]() {}`, `~int`, `~int`}, + {genericPkg + `u2b; func _[_ int|string]() {}`, `int | string`, `int|string`}, + {genericPkg + `u3b; func _[_ int|string|~bool]() {}`, `int | string | ~bool`, `int|string|~bool`}, } for _, test := range tests { diff --git a/src/go/types/interface.go b/src/go/types/interface.go index ef65bc6b2b..1ff9015780 100644 --- a/src/go/types/interface.go +++ b/src/go/types/interface.go @@ -152,7 +152,7 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d for _, f := range iface.Methods.List { if len(f.Names) == 0 { - addEmbedded(f.Type.Pos(), parseUnion(check, flattenUnion(nil, f.Type))) + addEmbedded(f.Type.Pos(), parseUnion(check, f.Type)) continue } // f.Name != nil @@ -223,11 +223,3 @@ func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, d ityp.check = nil }).describef(iface, "compute type set for %s", ityp) } - -func flattenUnion(list []ast.Expr, x ast.Expr) []ast.Expr { - if o, _ := x.(*ast.BinaryExpr); o != nil && o.Op == token.OR { - list = flattenUnion(list, o.X) - x = o.Y - } - return append(list, x) -} diff --git a/src/go/types/union.go b/src/go/types/union.go index 2a65ca4d8e..1437bd4624 100644 --- a/src/go/types/union.go +++ b/src/go/types/union.go @@ -49,10 +49,11 @@ func (t *Term) String() string { return (*term)(t).String() } // Avoid excessive type-checking times due to quadratic termlist operations. const maxTermCount = 100 -// parseUnion parses the given list of type expressions tlist as a union of -// those expressions. The result is a Union type, or Typ[Invalid] for some -// errors. -func parseUnion(check *Checker, tlist []ast.Expr) Type { +// parseUnion parses uexpr as a union of expressions. +// The result is a Union type, or Typ[Invalid] for some errors. +func parseUnion(check *Checker, uexpr ast.Expr) Type { + tlist := flattenUnion(nil, uexpr) + var terms []*Term for _, x := range tlist { tilde, typ := parseTilde(check, x) @@ -60,10 +61,11 @@ func parseUnion(check *Checker, tlist []ast.Expr) Type { // Single type. Ok to return early because all relevant // checks have been performed in parseTilde (no need to // run through term validity check below). - return typ + return typ // typ already recorded through check.typ in parseTilde } if len(terms) >= maxTermCount { check.errorf(x, _InvalidUnion, "cannot handle more than %d union terms (implementation limitation)", maxTermCount) + check.recordTypeAndValue(uexpr, typexpr, Typ[Invalid], nil) return Typ[Invalid] } terms = append(terms, NewTerm(tilde, typ)) @@ -108,7 +110,9 @@ func parseUnion(check *Checker, tlist []ast.Expr) Type { } }) - return &Union{terms, nil} + u := &Union{terms, nil} + check.recordTypeAndValue(uexpr, typexpr, u, nil) + return u } func parseTilde(check *Checker, x ast.Expr) (tilde bool, typ Type) { @@ -146,3 +150,11 @@ func overlappingTerm(terms []*Term, y *Term) int { } return -1 } + +func flattenUnion(list []ast.Expr, x ast.Expr) []ast.Expr { + if o, _ := x.(*ast.BinaryExpr); o != nil && o.Op == token.OR { + list = flattenUnion(list, o.X) + x = o.Y + } + return append(list, x) +} From c1f012a0d9b4c7bc9f2a1474f4935e53eccd1794 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 14 Dec 2021 10:49:07 -0500 Subject: [PATCH 480/752] cmd/compile: fix any in -G=0 mode Fixes go test -gcflags=all=-G=0 -short std, except for the packages with generics in their tests (constraints, encoding/xml), and except for the go/internal/gcimporter and go/types tests, because the compiler does not preserve any in its -G=0 export information. (That's probably acceptable for now.) Fixes cd test/; GO_BUILDER_NAME=longtest go run run.go completely, which should fix the longtest builder. Fixes #50159. Change-Id: I9390972239c18831833edd6530191da2842b876b Reviewed-on: https://go-review.googlesource.com/c/go/+/371715 Trust: Russ Cox Run-TryBot: Russ Cox Reviewed-by: Cherry Mui TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types/universe.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/cmd/compile/internal/types/universe.go b/src/cmd/compile/internal/types/universe.go index f845614e13..54b04bda22 100644 --- a/src/cmd/compile/internal/types/universe.go +++ b/src/cmd/compile/internal/types/universe.go @@ -57,7 +57,7 @@ func InitTypes(defTypeName func(sym *Sym, typ *Type) Object) { SimType[et] = et } - Types[TANY] = newType(TANY) + Types[TANY] = newType(TANY) // note: an old placeholder type, NOT the new builtin 'any' alias for interface{} Types[TINTER] = NewInterface(LocalPkg, nil, false) CheckSize(Types[TINTER]) @@ -91,6 +91,7 @@ func InitTypes(defTypeName func(sym *Sym, typ *Type) Object) { // int32 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)? + // NOTE(rsc): No, the error message quality is important. // (Alternatively, we could introduce an OTALIAS node representing // type aliases, albeit at the cost of having to deal with it everywhere). ByteType = defBasic(TUINT8, BuiltinPkg, "byte") @@ -111,12 +112,11 @@ func InitTypes(defTypeName func(sym *Sym, typ *Type) Object) { // any type (interface) DeferCheckSize() AnyType = defBasic(TFORW, BuiltinPkg, "any") - AnyType.SetUnderlying(NewInterface(NoPkg, []*Field{}, false)) + AnyType.SetUnderlying(NewInterface(BuiltinPkg, []*Field{}, false)) ResumeCheckSize() if base.Flag.G == 0 { ComparableType.Sym().Def = nil - AnyType.Sym().Def = nil } Types[TUNSAFEPTR] = defBasic(TUNSAFEPTR, UnsafePkg, "Pointer") From 46ba32a2ca304b0b73979736d6fb8013529e9172 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Tue, 14 Dec 2021 12:17:53 -0500 Subject: [PATCH 481/752] doc/go1.18: remove residual TODOs There doesn't seem anything that still needs to de done there. Updates #47694. Change-Id: I7909f566638332f3904d20a34f61d371af1d2da2 Reviewed-on: https://go-review.googlesource.com/c/go/+/371754 Trust: Cherry Mui Reviewed-by: Jeremy Faller Trust: Jeremy Faller Reviewed-by: Alex Rakoczy --- doc/go1.18.html | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 67af3e6a90..5ab40280b5 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -411,12 +411,6 @@ Do not send CLs removing the interior tags from such phrases. types and netip.AddrPort.

    -

    TODO

    - -

    - TODO: complete this section -

    -

    Minor changes to the library

    @@ -425,10 +419,6 @@ Do not send CLs removing the interior tags from such phrases. in mind.

    -

    - TODO: complete this section -

    -
    bufio

    From becaeea1199b875bc24800fa88f2f4fea119bf78 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Tue, 14 Dec 2021 12:24:08 -0500 Subject: [PATCH 482/752] api: promote next to go1.18 Change-Id: Ifc61e67413e5e56afbd0d4954f0150303d1a3a27 Reviewed-on: https://go-review.googlesource.com/c/go/+/371755 Trust: Cherry Mui Run-TryBot: Cherry Mui Reviewed-by: Russ Cox Reviewed-by: Alex Rakoczy TryBot-Result: Gopher Robot --- api/go1.18.txt | 238 +++++++++++++++++++++++++++++++++++++++++++++++++ api/next.txt | 47 ---------- 2 files changed, 238 insertions(+), 47 deletions(-) create mode 100644 api/go1.18.txt diff --git a/api/go1.18.txt b/api/go1.18.txt new file mode 100644 index 0000000000..afcb31c638 --- /dev/null +++ b/api/go1.18.txt @@ -0,0 +1,238 @@ +pkg bufio, method (*Writer) AvailableBuffer() []uint8 +pkg bufio, method (ReadWriter) AvailableBuffer() []uint8 +pkg bytes, func Cut([]uint8, []uint8) ([]uint8, []uint8, bool) +pkg constraints, type Complex interface {} +pkg constraints, type Float interface {} +pkg constraints, type Integer interface {} +pkg constraints, type Ordered interface {} +pkg constraints, type Signed interface {} +pkg constraints, type Unsigned interface {} +pkg crypto/tls, method (*Conn) NetConn() net.Conn +pkg debug/buildinfo, func Read(io.ReaderAt) (*debug.BuildInfo, error) +pkg debug/buildinfo, func ReadFile(string) (*debug.BuildInfo, error) +pkg debug/buildinfo, type BuildInfo = debug.BuildInfo +pkg debug/elf, const R_PPC64_RELATIVE = 22 +pkg debug/elf, const R_PPC64_RELATIVE R_PPC64 +pkg debug/plan9obj, var ErrNoSymbols error +pkg go/ast, method (*IndexListExpr) End() token.Pos +pkg go/ast, method (*IndexListExpr) Pos() token.Pos +pkg go/ast, type FuncType struct, TypeParams *FieldList +pkg go/ast, type IndexListExpr struct +pkg go/ast, type IndexListExpr struct, Indices []Expr +pkg go/ast, type IndexListExpr struct, Lbrack token.Pos +pkg go/ast, type IndexListExpr struct, Rbrack token.Pos +pkg go/ast, type IndexListExpr struct, X Expr +pkg go/ast, type TypeSpec struct, TypeParams *FieldList +pkg go/constant, method (Kind) String() string +pkg go/token, const TILDE = 88 +pkg go/token, const TILDE Token +pkg go/types, func Instantiate(*Context, Type, []Type, bool) (Type, error) +pkg go/types, func NewContext() *Context +pkg go/types, func NewSignatureType(*Var, []*TypeParam, []*TypeParam, *Tuple, *Tuple, bool) *Signature +pkg go/types, func NewTerm(bool, Type) *Term +pkg go/types, func NewTypeParam(*TypeName, Type) *TypeParam +pkg go/types, func NewUnion([]*Term) *Union +pkg go/types, method (*ArgumentError) Error() string +pkg go/types, method (*ArgumentError) Unwrap() error +pkg go/types, method (*Interface) IsComparable() bool +pkg go/types, method (*Interface) IsImplicit() bool +pkg go/types, method (*Interface) IsMethodSet() bool +pkg go/types, method (*Interface) MarkImplicit() +pkg go/types, method (*Named) Origin() *Named +pkg go/types, method (*Named) SetTypeParams([]*TypeParam) +pkg go/types, method (*Named) TypeArgs() *TypeList +pkg go/types, method (*Named) TypeParams() *TypeParamList +pkg go/types, method (*Signature) RecvTypeParams() *TypeParamList +pkg go/types, method (*Signature) TypeParams() *TypeParamList +pkg go/types, method (*Term) String() string +pkg go/types, method (*Term) Tilde() bool +pkg go/types, method (*Term) Type() Type +pkg go/types, method (*TypeList) At(int) Type +pkg go/types, method (*TypeList) Len() int +pkg go/types, method (*TypeList) String() string +pkg go/types, method (*TypeParam) Constraint() Type +pkg go/types, method (*TypeParam) Index() int +pkg go/types, method (*TypeParam) Obj() *TypeName +pkg go/types, method (*TypeParam) SetConstraint(Type) +pkg go/types, method (*TypeParam) String() string +pkg go/types, method (*TypeParam) Underlying() Type +pkg go/types, method (*TypeParamList) At(int) *TypeParam +pkg go/types, method (*TypeParamList) Len() int +pkg go/types, method (*Union) Len() int +pkg go/types, method (*Union) String() string +pkg go/types, method (*Union) Term(int) *Term +pkg go/types, method (*Union) Underlying() Type +pkg go/types, type ArgumentError struct +pkg go/types, type ArgumentError struct, Err error +pkg go/types, type ArgumentError struct, Index int +pkg go/types, type Config struct, Context *Context +pkg go/types, type Config struct, GoVersion string +pkg go/types, type Context struct +pkg go/types, type Info struct, Instances map[*ast.Ident]Instance +pkg go/types, type Instance struct +pkg go/types, type Instance struct, Type Type +pkg go/types, type Instance struct, TypeArgs *TypeList +pkg go/types, type Term struct +pkg go/types, type TypeList struct +pkg go/types, type TypeParam struct +pkg go/types, type TypeParamList struct +pkg go/types, type Union struct +pkg net, func TCPAddrFromAddrPort(netip.AddrPort) *TCPAddr +pkg net, func UDPAddrFromAddrPort(netip.AddrPort) *UDPAddr +pkg net, method (*Resolver) LookupNetIP(context.Context, string, string) ([]netip.Addr, error) +pkg net, method (*TCPAddr) AddrPort() netip.AddrPort +pkg net, method (*UDPAddr) AddrPort() netip.AddrPort +pkg net, method (*UDPConn) ReadFromUDPAddrPort([]uint8) (int, netip.AddrPort, error) +pkg net, method (*UDPConn) ReadMsgUDPAddrPort([]uint8, []uint8) (int, int, int, netip.AddrPort, error) +pkg net, method (*UDPConn) WriteMsgUDPAddrPort([]uint8, []uint8, netip.AddrPort) (int, int, error) +pkg net, method (*UDPConn) WriteToUDPAddrPort([]uint8, netip.AddrPort) (int, error) +pkg net/http, func MaxBytesHandler(Handler, int64) Handler +pkg net/http, method (*Cookie) Valid() error +pkg net/netip, func AddrFrom16([16]uint8) Addr +pkg net/netip, func AddrFrom4([4]uint8) Addr +pkg net/netip, func AddrFromSlice([]uint8) (Addr, bool) +pkg net/netip, func AddrPortFrom(Addr, uint16) AddrPort +pkg net/netip, func IPv4Unspecified() Addr +pkg net/netip, func IPv6LinkLocalAllNodes() Addr +pkg net/netip, func IPv6Unspecified() Addr +pkg net/netip, func MustParseAddr(string) Addr +pkg net/netip, func MustParseAddrPort(string) AddrPort +pkg net/netip, func MustParsePrefix(string) Prefix +pkg net/netip, func ParseAddr(string) (Addr, error) +pkg net/netip, func ParseAddrPort(string) (AddrPort, error) +pkg net/netip, func ParsePrefix(string) (Prefix, error) +pkg net/netip, func PrefixFrom(Addr, int) Prefix +pkg net/netip, method (*Addr) UnmarshalBinary([]uint8) error +pkg net/netip, method (*Addr) UnmarshalText([]uint8) error +pkg net/netip, method (*AddrPort) UnmarshalBinary([]uint8) error +pkg net/netip, method (*AddrPort) UnmarshalText([]uint8) error +pkg net/netip, method (*Prefix) UnmarshalBinary([]uint8) error +pkg net/netip, method (*Prefix) UnmarshalText([]uint8) error +pkg net/netip, method (Addr) AppendTo([]uint8) []uint8 +pkg net/netip, method (Addr) As16() [16]uint8 +pkg net/netip, method (Addr) As4() [4]uint8 +pkg net/netip, method (Addr) AsSlice() []uint8 +pkg net/netip, method (Addr) BitLen() int +pkg net/netip, method (Addr) Compare(Addr) int +pkg net/netip, method (Addr) Is4() bool +pkg net/netip, method (Addr) Is4In6() bool +pkg net/netip, method (Addr) Is6() bool +pkg net/netip, method (Addr) IsGlobalUnicast() bool +pkg net/netip, method (Addr) IsInterfaceLocalMulticast() bool +pkg net/netip, method (Addr) IsLinkLocalMulticast() bool +pkg net/netip, method (Addr) IsLinkLocalUnicast() bool +pkg net/netip, method (Addr) IsLoopback() bool +pkg net/netip, method (Addr) IsMulticast() bool +pkg net/netip, method (Addr) IsPrivate() bool +pkg net/netip, method (Addr) IsUnspecified() bool +pkg net/netip, method (Addr) IsValid() bool +pkg net/netip, method (Addr) Less(Addr) bool +pkg net/netip, method (Addr) MarshalBinary() ([]uint8, error) +pkg net/netip, method (Addr) MarshalText() ([]uint8, error) +pkg net/netip, method (Addr) Next() Addr +pkg net/netip, method (Addr) Prefix(int) (Prefix, error) +pkg net/netip, method (Addr) Prev() Addr +pkg net/netip, method (Addr) String() string +pkg net/netip, method (Addr) StringExpanded() string +pkg net/netip, method (Addr) Unmap() Addr +pkg net/netip, method (Addr) WithZone(string) Addr +pkg net/netip, method (Addr) Zone() string +pkg net/netip, method (AddrPort) Addr() Addr +pkg net/netip, method (AddrPort) AppendTo([]uint8) []uint8 +pkg net/netip, method (AddrPort) IsValid() bool +pkg net/netip, method (AddrPort) MarshalBinary() ([]uint8, error) +pkg net/netip, method (AddrPort) MarshalText() ([]uint8, error) +pkg net/netip, method (AddrPort) Port() uint16 +pkg net/netip, method (AddrPort) String() string +pkg net/netip, method (Prefix) Addr() Addr +pkg net/netip, method (Prefix) AppendTo([]uint8) []uint8 +pkg net/netip, method (Prefix) Bits() int +pkg net/netip, method (Prefix) Contains(Addr) bool +pkg net/netip, method (Prefix) IsSingleIP() bool +pkg net/netip, method (Prefix) IsValid() bool +pkg net/netip, method (Prefix) MarshalBinary() ([]uint8, error) +pkg net/netip, method (Prefix) MarshalText() ([]uint8, error) +pkg net/netip, method (Prefix) Masked() Prefix +pkg net/netip, method (Prefix) Overlaps(Prefix) bool +pkg net/netip, method (Prefix) String() string +pkg net/netip, type Addr struct +pkg net/netip, type AddrPort struct +pkg net/netip, type Prefix struct +pkg reflect, const Pointer = 22 +pkg reflect, const Pointer Kind +pkg reflect, func PointerTo(Type) Type +pkg reflect, method (*MapIter) Reset(Value) +pkg reflect, method (Value) CanComplex() bool +pkg reflect, method (Value) CanFloat() bool +pkg reflect, method (Value) CanInt() bool +pkg reflect, method (Value) CanUint() bool +pkg reflect, method (Value) FieldByIndexErr([]int) (Value, error) +pkg reflect, method (Value) SetIterKey(*MapIter) +pkg reflect, method (Value) SetIterValue(*MapIter) +pkg reflect, method (Value) UnsafePointer() unsafe.Pointer +pkg runtime/debug, method (*BuildInfo) MarshalText() ([]uint8, error) +pkg runtime/debug, method (*BuildInfo) UnmarshalText([]uint8) error +pkg runtime/debug, type BuildInfo struct, GoVersion string +pkg runtime/debug, type BuildInfo struct, Settings []BuildSetting +pkg runtime/debug, type BuildSetting struct +pkg runtime/debug, type BuildSetting struct, Key string +pkg runtime/debug, type BuildSetting struct, Value string +pkg strings, func Clone(string) string +pkg strings, func Cut(string, string) (string, string, bool) +pkg sync, method (*Mutex) TryLock() bool +pkg sync, method (*RWMutex) TryLock() bool +pkg sync, method (*RWMutex) TryRLock() bool +pkg syscall (freebsd-386), type SysProcAttr struct, Pdeathsig Signal +pkg syscall (freebsd-386-cgo), type SysProcAttr struct, Pdeathsig Signal +pkg syscall (freebsd-amd64), type SysProcAttr struct, Pdeathsig Signal +pkg syscall (freebsd-amd64-cgo), type SysProcAttr struct, Pdeathsig Signal +pkg syscall (freebsd-arm), type SysProcAttr struct, Pdeathsig Signal +pkg syscall (freebsd-arm-cgo), type SysProcAttr struct, Pdeathsig Signal +pkg syscall (windows-386), func SyscallN(uintptr, ...uintptr) (uintptr, uintptr, Errno) +pkg syscall (windows-amd64), func SyscallN(uintptr, ...uintptr) (uintptr, uintptr, Errno) +pkg testing, func MainStart(testDeps, []InternalTest, []InternalBenchmark, []InternalFuzzTarget, []InternalExample) *M +pkg testing, method (*F) Add(...interface{}) +pkg testing, method (*F) Cleanup(func()) +pkg testing, method (*F) Error(...interface{}) +pkg testing, method (*F) Errorf(string, ...interface{}) +pkg testing, method (*F) Fail() +pkg testing, method (*F) FailNow() +pkg testing, method (*F) Failed() bool +pkg testing, method (*F) Fatal(...interface{}) +pkg testing, method (*F) Fatalf(string, ...interface{}) +pkg testing, method (*F) Fuzz(interface{}) +pkg testing, method (*F) Helper() +pkg testing, method (*F) Log(...interface{}) +pkg testing, method (*F) Logf(string, ...interface{}) +pkg testing, method (*F) Name() string +pkg testing, method (*F) Setenv(string, string) +pkg testing, method (*F) Skip(...interface{}) +pkg testing, method (*F) SkipNow() +pkg testing, method (*F) Skipf(string, ...interface{}) +pkg testing, method (*F) Skipped() bool +pkg testing, method (*F) TempDir() string +pkg testing, type F struct +pkg testing, type InternalFuzzTarget struct +pkg testing, type InternalFuzzTarget struct, Fn func(*F) +pkg testing, type InternalFuzzTarget struct, Name string +pkg text/template/parse, const NodeBreak = 21 +pkg text/template/parse, const NodeBreak NodeType +pkg text/template/parse, const NodeContinue = 22 +pkg text/template/parse, const NodeContinue NodeType +pkg text/template/parse, method (*BreakNode) Copy() Node +pkg text/template/parse, method (*BreakNode) String() string +pkg text/template/parse, method (*ContinueNode) Copy() Node +pkg text/template/parse, method (*ContinueNode) String() string +pkg text/template/parse, method (BreakNode) Position() Pos +pkg text/template/parse, method (BreakNode) Type() NodeType +pkg text/template/parse, method (ContinueNode) Position() Pos +pkg text/template/parse, method (ContinueNode) Type() NodeType +pkg text/template/parse, type BreakNode struct +pkg text/template/parse, type BreakNode struct, Line int +pkg text/template/parse, type BreakNode struct, embedded NodeType +pkg text/template/parse, type BreakNode struct, embedded Pos +pkg text/template/parse, type ContinueNode struct +pkg text/template/parse, type ContinueNode struct, Line int +pkg text/template/parse, type ContinueNode struct, embedded NodeType +pkg text/template/parse, type ContinueNode struct, embedded Pos +pkg unicode/utf8, func AppendRune([]uint8, int32) []uint8 diff --git a/api/next.txt b/api/next.txt index cc4120b7ab..e69de29bb2 100644 --- a/api/next.txt +++ b/api/next.txt @@ -1,47 +0,0 @@ -pkg debug/buildinfo, func Read(io.ReaderAt) (*debug.BuildInfo, error) -pkg debug/buildinfo, func ReadFile(string) (*debug.BuildInfo, error) -pkg debug/buildinfo, type BuildInfo = debug.BuildInfo -pkg runtime/debug, method (*BuildInfo) MarshalText() ([]byte, error) -pkg runtime/debug, method (*BuildInfo) UnmarshalText() ([]byte, error) -pkg runtime/debug, type BuildInfo struct, GoVersion string -pkg runtime/debug, type BuildInfo struct, Settings []BuildSetting -pkg runtime/debug, type BuildSetting struct -pkg runtime/debug, type BuildSetting struct, Key string -pkg runtime/debug, type BuildSetting struct, Value string -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 -pkg testing, func RunFuzzing(func(string, string) (bool, error), []InternalFuzzTarget) bool -pkg testing, method (*B) Setenv(string, string) -pkg testing, method (*F) Add(...interface{}) -pkg testing, method (*F) Cleanup(func()) -pkg testing, method (*F) Error(...interface{}) -pkg testing, method (*F) Errorf(string, ...interface{}) -pkg testing, method (*F) Fail() -pkg testing, method (*F) FailNow() -pkg testing, method (*F) Failed() bool -pkg testing, method (*F) Fatal(...interface{}) -pkg testing, method (*F) Fatalf(string, ...interface{}) -pkg testing, method (*F) Fuzz(interface{}) -pkg testing, method (*F) Helper() -pkg testing, method (*F) Log(...interface{}) -pkg testing, method (*F) Logf(string, ...interface{}) -pkg testing, method (*F) Name() string -pkg testing, method (*F) Setenv(string, string) -pkg testing, method (*F) Skip(...interface{}) -pkg testing, method (*F) SkipNow() -pkg testing, method (*F) Skipf(string, ...interface{}) -pkg testing, method (*F) Skipped() bool -pkg testing, method (*F) TempDir() string -pkg testing, method (*T) Setenv(string, string) -pkg testing, method (FuzzResult) String() string -pkg testing, type F struct -pkg testing, type FuzzResult struct -pkg testing, type FuzzResult struct, Crasher entry -pkg testing, type FuzzResult struct, Error error -pkg testing, type FuzzResult struct, N int -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 net/http, method (*Cookie) Valid() error From 265fbaa94b8614cbd861711d7f7c6d278dc1ddba Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Mon, 13 Dec 2021 13:49:30 -0500 Subject: [PATCH 483/752] doc: update go1.18 release notes with a blurb about workspace mode For #47694 Change-Id: I79cdbdc66ea9942b597f29c9a4f428075f053466 Reviewed-on: https://go-review.googlesource.com/c/go/+/371295 Trust: Michael Matloob Run-TryBot: Michael Matloob TryBot-Result: Gopher Robot Reviewed-by: Bryan Mills --- doc/go1.18.html | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 5ab40280b5..e5222b7fcc 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -258,6 +258,17 @@ Do not send CLs removing the interior tags from such phrases. option -fsanitize=address).

    +

    + The go command now supports a "Workspace" mode. If a + go.work file is found in the working directory or a + parent directory, or one is specified using the -workfile + flag, it will put the go command into workspace mode. + In workspace mode, the go.work file will be used to + determine the set of main modules used as the roots for module + resolution, instead of using the normally-found go.mod + file to specify the single main module. +

    +

    gofmt

    From d407a8c3c49f11980f224d204147eff8fcb087f4 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Mon, 13 Dec 2021 14:28:17 -0500 Subject: [PATCH 484/752] testing: retry spurious errors from RemoveAll for temp directories This works around what appears to be either a kernel bug or a Go runtime or syscall bug affecting certain Windows versions (possibly all pre-2016?). The retry loop is a simplified version of the one used in cmd/go/internal/robustio. We use the same 2-second arbitrary timeout as was used in that package, since it seems to be reliable in practice on the affected builders. (If it proves to be too short, we can lengthen it, within reason, in a followup CL.) Since this puts a higher-level workaround in place, we can also revert the lower-level workaround added to a specific test in CL 345670. This addresses the specific occurrences of the bug for users of (*testing.T).TempDir, but does not fix the underlying bug for Go users outside the "testing" package (which remains open as #25965). Fixes #50051 Updates #48012 Updates #25965 Change-Id: I35be7125f32f05c8350787f5ca9a22974b8d0770 Reviewed-on: https://go-review.googlesource.com/c/go/+/371296 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Patrik Nyblom Trust: Patrik Nyblom Run-TryBot: Patrik Nyblom --- src/runtime/syscall_windows_test.go | 1 + src/testing/testing.go | 32 ++++++++++++++++++++++++++++- src/testing/testing_other.go | 13 ++++++++++++ src/testing/testing_windows.go | 18 ++++++++++++++++ 4 files changed, 63 insertions(+), 1 deletion(-) create mode 100644 src/testing/testing_other.go create mode 100644 src/testing/testing_windows.go diff --git a/src/runtime/syscall_windows_test.go b/src/runtime/syscall_windows_test.go index 101e94107c..dcd390ff9d 100644 --- a/src/runtime/syscall_windows_test.go +++ b/src/runtime/syscall_windows_test.go @@ -770,6 +770,7 @@ func TestSyscallN(t *testing.T) { for arglen := 0; arglen <= runtime.MaxArgs; arglen++ { arglen := arglen t.Run(fmt.Sprintf("arg-%d", arglen), func(t *testing.T) { + t.Parallel() args := make([]string, arglen) rets := make([]string, arglen+1) params := make([]uintptr, arglen) diff --git a/src/testing/testing.go b/src/testing/testing.go index 7bd13a850c..a8c8122aa7 100644 --- a/src/testing/testing.go +++ b/src/testing/testing.go @@ -1087,7 +1087,7 @@ func (c *common) TempDir() string { c.tempDir, c.tempDirErr = os.MkdirTemp("", pattern) if c.tempDirErr == nil { c.Cleanup(func() { - if err := os.RemoveAll(c.tempDir); err != nil { + if err := removeAll(c.tempDir); err != nil { c.Errorf("TempDir RemoveAll cleanup: %v", err) } }) @@ -1106,6 +1106,36 @@ func (c *common) TempDir() string { return dir } +// removeAll is like os.RemoveAll, but retries Windows "Access is denied." +// errors up to an arbitrary timeout. +// +// Those errors have been known to occur spuriously on at least the +// windows-amd64-2012 builder (https://go.dev/issue/50051), and can only occur +// legitimately if the test leaves behind a temp file that either is still open +// or the test otherwise lacks permission to delete. In the case of legitimate +// failures, a failing test may take a bit longer to fail, but once the test is +// fixed the extra latency will go away. +func removeAll(path string) error { + const arbitraryTimeout = 2 * time.Second + var ( + start time.Time + nextSleep = 1 * time.Millisecond + ) + for { + err := os.RemoveAll(path) + if !isWindowsAccessDenied(err) { + return err + } + if start.IsZero() { + start = time.Now() + } else if d := time.Since(start) + nextSleep; d >= arbitraryTimeout { + return err + } + time.Sleep(nextSleep) + nextSleep += time.Duration(rand.Int63n(int64(nextSleep))) + } +} + // Setenv calls os.Setenv(key, value) and uses Cleanup to // restore the environment variable to its original value // after the test. diff --git a/src/testing/testing_other.go b/src/testing/testing_other.go new file mode 100644 index 0000000000..29496d81bc --- /dev/null +++ b/src/testing/testing_other.go @@ -0,0 +1,13 @@ +// 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. + +//go:build !windows + +package testing + +// isWindowsAccessDenied reports whether err is ERROR_ACCESS_DENIED, +// which is defined only on Windows. +func isWindowsAccessDenied(err error) bool { + return false +} diff --git a/src/testing/testing_windows.go b/src/testing/testing_windows.go new file mode 100644 index 0000000000..bc76cb80cc --- /dev/null +++ b/src/testing/testing_windows.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. + +//go:build windows + +package testing + +import ( + "errors" + "syscall" +) + +// isWindowsAccessDenied reports whether err is ERROR_ACCESS_DENIED, +// which is defined only on Windows. +func isWindowsAccessDenied(err error) bool { + return errors.Is(err, syscall.ERROR_ACCESS_DENIED) +} From 0f05ed3b7821db1d73954aa9e7fd49e5a19ec12a Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Fri, 10 Dec 2021 21:17:12 -0500 Subject: [PATCH 485/752] os: enable TestClosedPipeRace* on FreeBSD This test has worked since CL 165801 (committed March 12, 2019), so stop skipping it. With this, we check that Close makes concurrent I/O operations on pipes return Errclosed on all platforms. Updates #19093. Change-Id: Ic090c70996c115abf80d8f9b93ca2aeaf347c9d8 Reviewed-on: https://go-review.googlesource.com/c/go/+/371016 Trust: Austin Clements Reviewed-by: Ian Lance Taylor Run-TryBot: Austin Clements TryBot-Result: Gopher Robot --- src/os/pipe_test.go | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/os/pipe_test.go b/src/os/pipe_test.go index ab6d1ce2b6..20716bce1e 100644 --- a/src/os/pipe_test.go +++ b/src/os/pipe_test.go @@ -150,11 +150,6 @@ func TestStdPipeHelper(t *testing.T) { } func testClosedPipeRace(t *testing.T, read bool) { - switch runtime.GOOS { - case "freebsd": - t.Skip("FreeBSD does not use the poller; issue 19093") - } - limit := 1 if !read { // Get the amount we have to write to overload a pipe From fc8ae9860a820e2d5179fc3b15b247e0545f2a28 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Tue, 14 Dec 2021 16:15:30 -0500 Subject: [PATCH 486/752] doc/go1.18: move debug/buildinfo to core library section It is a new package and seems a major change. Updates #47694. Change-Id: If854e494e28bcd1e79c99e59119755b9cb6793d6 Reviewed-on: https://go-review.googlesource.com/c/go/+/371816 Trust: Cherry Mui Reviewed-by: Bryan Mills --- doc/go1.18.html | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index e5222b7fcc..e156f21eb2 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -393,6 +393,18 @@ Do not send CLs removing the interior tags from such phrases. generic functions.

    +

    New debug/buildinfo package

    + +

    + The new debug/buildinfo package + provides access to module versions, version control information, and build + flags embedded in executable files built by the go command. + The same information is also available via + runtime/debug.ReadBuildInfo + for the currently running binary and via go + version -m on the command line. +

    +

    New net/netip package

    @@ -484,19 +496,6 @@ Do not send CLs removing the interior tags from such phrases.

    -
    debug/buildinfo
    -
    -

    - This new package provides access to module versions, version control - information, and build flags embedded in executable files built by - the go command. The same information is also available via - runtime/debug.ReadBuildInfo - for the currently running binary and via go - version -m on the command line. -

    -
    -
    -
    go/ast

    From 1540239f48f6beaa1cae6b34d00d74860366da7d Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 14 Dec 2021 13:27:57 -0800 Subject: [PATCH 487/752] doc/go1.18: add caution about use of generics in production Per https://groups.google.com/g/golang-dev/c/iuB22_G9Kbo/m/7B1jd1I3BQAJ. For #47694 Change-Id: I033cdadb2067e432f7c307d1546b4c5d0cfd5d8c Reviewed-on: https://go-review.googlesource.com/c/go/+/371954 Trust: Ian Lance Taylor Reviewed-by: Robert Griesemer --- doc/go1.18.html | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index e156f21eb2..64481a1466 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -32,10 +32,25 @@ Do not send CLs removing the interior tags from such phrases. Type Parameters Proposal. This includes major - but fully backward-compatible - changes to the language. +

    + +

    + These new language changes required a large amount of new code that + has not had significant testing in production settings. That will + only happen as more people write and use generic code. We believe + that this feature is well implemented and high quality. However, + unlike most aspects of Go, we can't back up that belief with real + world experience. Therefore, while we encourage the use of generics + where it makes sense, please use appropriate caution when deploying + generic code in production. +

    + +

    The following is a list of the most visible changes. For a more comprehensive overview, see the proposal. For details see the language spec.

    +
    • The syntax for From af05064f978729f3b066e1d627633c11c5e267e2 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 14 Dec 2021 11:33:10 -0500 Subject: [PATCH 488/752] go/types: externalize union type sets Move calculated type sets for unions into a map, rather than storing them on the Union type. Type sets for unions only matter during calculation of interface type sets, and to a lesser extent inside of Identical. The latter should not be encountered during type checking, as Identical uses the precomputed interface type set when comparing interfaces, and unions do not arise outside of interface types. Removing the tset field from Union potentially frees up memory, and eliminates a source of races via calls to NewUnion and Identical. It also sets the stage for recording Unions for every subexpression of union terms, which preserves an existing invariant that BinaryExprs and UnaryExprs should have a recorded type. Updates #50093 Change-Id: I5956fa59be6b0907c3a71faeba9fa5dd8aae0d65 Reviewed-on: https://go-review.googlesource.com/c/go/+/371756 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/go/types/check.go | 2 ++ src/go/types/predicates.go | 7 +++++-- src/go/types/sizeof_test.go | 2 +- src/go/types/subst.go | 2 +- src/go/types/typeset.go | 28 +++++++++++++++++++--------- src/go/types/union.go | 7 +++---- 6 files changed, 31 insertions(+), 17 deletions(-) diff --git a/src/go/types/check.go b/src/go/types/check.go index 2dd38e2e1e..bad4d5c9cd 100644 --- a/src/go/types/check.go +++ b/src/go/types/check.go @@ -136,6 +136,7 @@ type Checker struct { imports []*PkgName // list of imported packages dotImportMap map[dotImportKey]*PkgName // maps dot-imported objects to the package they were dot-imported through recvTParamMap map[*ast.Ident]*TypeParam // maps blank receiver type parameters to their type + unionTypeSets map[*Union]*_TypeSet // computed type sets for union types mono monoGraph // graph for detecting non-monomorphizable instantiation loops firstErr error // first error encountered @@ -323,6 +324,7 @@ func (check *Checker) checkFiles(files []*ast.File) (err error) { check.pkgPathMap = nil check.seenPkgMap = nil check.recvTParamMap = nil + check.unionTypeSets = nil check.defTypes = nil check.ctxt = nil diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go index 22ccdd7744..1202db4049 100644 --- a/src/go/types/predicates.go +++ b/src/go/types/predicates.go @@ -289,8 +289,11 @@ func identical(x, y Type, cmpTags bool, p *ifacePair) bool { case *Union: if y, _ := y.(*Union); y != nil { - xset := computeUnionTypeSet(nil, token.NoPos, x) - yset := computeUnionTypeSet(nil, token.NoPos, y) + // TODO(rfindley): can this be reached during type checking? If so, + // consider passing a type set map. + unionSets := make(map[*Union]*_TypeSet) + xset := computeUnionTypeSet(nil, unionSets, token.NoPos, x) + yset := computeUnionTypeSet(nil, unionSets, token.NoPos, y) return xset.terms.equal(yset.terms) } diff --git a/src/go/types/sizeof_test.go b/src/go/types/sizeof_test.go index 69571d1159..24cbc22839 100644 --- a/src/go/types/sizeof_test.go +++ b/src/go/types/sizeof_test.go @@ -26,7 +26,7 @@ func TestSizeof(t *testing.T) { {Pointer{}, 8, 16}, {Tuple{}, 12, 24}, {Signature{}, 28, 56}, - {Union{}, 16, 32}, + {Union{}, 12, 24}, {Interface{}, 44, 88}, {Map{}, 16, 32}, {Chan{}, 12, 24}, diff --git a/src/go/types/subst.go b/src/go/types/subst.go index 169540365b..b7e3b12779 100644 --- a/src/go/types/subst.go +++ b/src/go/types/subst.go @@ -130,7 +130,7 @@ func (subst *subster) typ(typ Type) Type { // term list substitution may introduce duplicate terms (unlikely but possible). // This is ok; lazy type set computation will determine the actual type set // in normal form. - return &Union{terms, nil} + return &Union{terms} } case *Interface: diff --git a/src/go/types/typeset.go b/src/go/types/typeset.go index d39483f254..0f2897b8c6 100644 --- a/src/go/types/typeset.go +++ b/src/go/types/typeset.go @@ -201,6 +201,16 @@ func computeInterfaceTypeSet(check *Checker, pos token.Pos, ityp *Interface) *_T // reason. ityp.tset = &_TypeSet{terms: allTermlist} // TODO(gri) is this sufficient? + var unionSets map[*Union]*_TypeSet + if check != nil { + if check.unionTypeSets == nil { + check.unionTypeSets = make(map[*Union]*_TypeSet) + } + unionSets = check.unionTypeSets + } else { + unionSets = make(map[*Union]*_TypeSet) + } + // Methods of embedded interfaces are collected unchanged; i.e., the identity // of a method I.m's Func Object of an interface I is the same as that of // the method m in an interface that embeds interface I. On the other hand, @@ -288,7 +298,7 @@ func computeInterfaceTypeSet(check *Checker, pos token.Pos, ityp *Interface) *_T check.errorf(atPos(pos), _InvalidIfaceEmbed, "embedding interface element %s requires go1.18 or later", u) continue } - tset := computeUnionTypeSet(check, pos, u) + tset := computeUnionTypeSet(check, unionSets, pos, u) if tset == &invalidTypeSet { continue // ignore invalid unions } @@ -356,13 +366,13 @@ var invalidTypeSet _TypeSet // computeUnionTypeSet may be called with check == nil. // The result is &invalidTypeSet if the union overflows. -func computeUnionTypeSet(check *Checker, pos token.Pos, utyp *Union) *_TypeSet { - if utyp.tset != nil { - return utyp.tset +func computeUnionTypeSet(check *Checker, unionSets map[*Union]*_TypeSet, pos token.Pos, utyp *Union) *_TypeSet { + if tset, _ := unionSets[utyp]; tset != nil { + return tset } // avoid infinite recursion (see also computeInterfaceTypeSet) - utyp.tset = new(_TypeSet) + unionSets[utyp] = new(_TypeSet) var allTerms termlist for _, t := range utyp.terms { @@ -389,11 +399,11 @@ func computeUnionTypeSet(check *Checker, pos token.Pos, utyp *Union) *_TypeSet { if check != nil { check.errorf(atPos(pos), _InvalidUnion, "cannot handle more than %d union terms (implementation limitation)", maxTermCount) } - utyp.tset = &invalidTypeSet - return utyp.tset + unionSets[utyp] = &invalidTypeSet + return unionSets[utyp] } } - utyp.tset.terms = allTerms + unionSets[utyp].terms = allTerms - return utyp.tset + return unionSets[utyp] } diff --git a/src/go/types/union.go b/src/go/types/union.go index 1437bd4624..9dd67a0db4 100644 --- a/src/go/types/union.go +++ b/src/go/types/union.go @@ -14,8 +14,7 @@ import ( // A Union represents a union of terms embedded in an interface. type Union struct { - terms []*Term // list of syntactical terms (not a canonicalized termlist) - tset *_TypeSet // type set described by this union, computed lazily + terms []*Term // list of syntactical terms (not a canonicalized termlist) } // NewUnion returns a new Union type with the given terms. @@ -24,7 +23,7 @@ func NewUnion(terms []*Term) *Union { if len(terms) == 0 { panic("empty union") } - return &Union{terms, nil} + return &Union{terms} } func (u *Union) Len() int { return len(u.terms) } @@ -110,7 +109,7 @@ func parseUnion(check *Checker, uexpr ast.Expr) Type { } }) - u := &Union{terms, nil} + u := &Union{terms} check.recordTypeAndValue(uexpr, typexpr, u, nil) return u } From 8108444eaa7ee45a74b2f2da6d21dd1d2b0c0352 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 14 Dec 2021 12:48:31 -0500 Subject: [PATCH 489/752] go/types: record types for union subexpressions Prior to unions, unary and binary expressions always had a recorded type. Preserve this by recording a type for all unary and binary expressions encountered while parsing a union type. Updates #50093 Change-Id: I5ba20f37854760596350d91ea325dc98e67e115a Reviewed-on: https://go-review.googlesource.com/c/go/+/371757 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/go/types/api.go | 6 ----- src/go/types/api_test.go | 13 ++++++++++ src/go/types/union.go | 55 +++++++++++++++++++++++++++------------- 3 files changed, 51 insertions(+), 23 deletions(-) diff --git a/src/go/types/api.go b/src/go/types/api.go index c4d81c1491..51d58c49aa 100644 --- a/src/go/types/api.go +++ b/src/go/types/api.go @@ -197,12 +197,6 @@ type Info struct { // identifier z in a variable declaration 'var z int' is found // only in the Defs map, and identifiers denoting packages in // qualified identifiers are collected in the Uses map. - // - // For binary expressions representing unions in constraint - // position or type elements in interfaces, a union type is - // recorded for the top-level expression only. For instance, - // given the constraint a|b|c, the union type for (a|b)|c - // is recorded, but not the union type for a|b. Types map[ast.Expr]TypeAndValue // Instances maps identifiers denoting parameterized types or functions to diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go index 1ee9806fd0..e55255d75e 100644 --- a/src/go/types/api_test.go +++ b/src/go/types/api_test.go @@ -379,10 +379,23 @@ func TestTypesInfo(t *testing.T) { {genericPkg + `u1a; func _[_ interface{~int}]() {}`, `~int`, `~int`}, {genericPkg + `u2a; func _[_ interface{int|string}]() {}`, `int | string`, `int|string`}, {genericPkg + `u3a; func _[_ interface{int|string|~bool}]() {}`, `int | string | ~bool`, `int|string|~bool`}, + {genericPkg + `u3b; func _[_ interface{int|string|~bool}]() {}`, `int | string`, `int|string`}, + {genericPkg + `u3b; func _[_ interface{int|string|~bool}]() {}`, `~bool`, `~bool`}, + {genericPkg + `u3b; func _[_ interface{int|string|~float64|~bool}]() {}`, `int | string | ~float64`, `int|string|~float64`}, {genericPkg + `u0b; func _[_ int]() {}`, `int`, `int`}, {genericPkg + `u1b; func _[_ ~int]() {}`, `~int`, `~int`}, {genericPkg + `u2b; func _[_ int|string]() {}`, `int | string`, `int|string`}, {genericPkg + `u3b; func _[_ int|string|~bool]() {}`, `int | string | ~bool`, `int|string|~bool`}, + {genericPkg + `u3b; func _[_ int|string|~bool]() {}`, `int | string`, `int|string`}, + {genericPkg + `u3b; func _[_ int|string|~bool]() {}`, `~bool`, `~bool`}, + {genericPkg + `u3b; func _[_ int|string|~float64|~bool]() {}`, `int | string | ~float64`, `int|string|~float64`}, + {genericPkg + `u0b; type _ interface{int}`, `int`, `int`}, + {genericPkg + `u1b; type _ interface{~int}`, `~int`, `~int`}, + {genericPkg + `u2b; type _ interface{int|string}`, `int | string`, `int|string`}, + {genericPkg + `u3b; type _ interface{int|string|~bool}`, `int | string | ~bool`, `int|string|~bool`}, + {genericPkg + `u3b; type _ interface{int|string|~bool}`, `int | string`, `int|string`}, + {genericPkg + `u3b; type _ interface{int|string|~bool}`, `~bool`, `~bool`}, + {genericPkg + `u3b; type _ interface{int|string|~float64|~bool}`, `int | string | ~float64`, `int|string|~float64`}, } for _, test := range tests { diff --git a/src/go/types/union.go b/src/go/types/union.go index 9dd67a0db4..7cd5b2a88b 100644 --- a/src/go/types/union.go +++ b/src/go/types/union.go @@ -51,23 +51,37 @@ const maxTermCount = 100 // parseUnion parses uexpr as a union of expressions. // The result is a Union type, or Typ[Invalid] for some errors. func parseUnion(check *Checker, uexpr ast.Expr) Type { - tlist := flattenUnion(nil, uexpr) + blist, tlist := flattenUnion(nil, uexpr) + assert(len(blist) == len(tlist)-1) var terms []*Term - for _, x := range tlist { - tilde, typ := parseTilde(check, x) - if len(tlist) == 1 && !tilde { + + var u Type + for i, x := range tlist { + term := parseTilde(check, x) + if len(tlist) == 1 && !term.tilde { // Single type. Ok to return early because all relevant // checks have been performed in parseTilde (no need to // run through term validity check below). - return typ // typ already recorded through check.typ in parseTilde + return term.typ // typ already recorded through check.typ in parseTilde } if len(terms) >= maxTermCount { - check.errorf(x, _InvalidUnion, "cannot handle more than %d union terms (implementation limitation)", maxTermCount) - check.recordTypeAndValue(uexpr, typexpr, Typ[Invalid], nil) - return Typ[Invalid] + if u != Typ[Invalid] { + check.errorf(x, _InvalidUnion, "cannot handle more than %d union terms (implementation limitation)", maxTermCount) + u = Typ[Invalid] + } + } else { + terms = append(terms, term) + u = &Union{terms} } - terms = append(terms, NewTerm(tilde, typ)) + + if i > 0 { + check.recordTypeAndValue(blist[i-1], typexpr, u, nil) + } + } + + if u == Typ[Invalid] { + return u } // Check validity of terms. @@ -109,17 +123,17 @@ func parseUnion(check *Checker, uexpr ast.Expr) Type { } }) - u := &Union{terms} - check.recordTypeAndValue(uexpr, typexpr, u, nil) return u } -func parseTilde(check *Checker, x ast.Expr) (tilde bool, typ Type) { +func parseTilde(check *Checker, tx ast.Expr) *Term { + x := tx + var tilde bool if op, _ := x.(*ast.UnaryExpr); op != nil && op.Op == token.TILDE { x = op.X tilde = true } - typ = check.typ(x) + typ := check.typ(x) // Embedding stand-alone type parameters is not permitted (issue #47127). // We don't need this restriction anymore if we make the underlying type of a type // parameter its constraint interface: if we embed a lone type parameter, we will @@ -129,7 +143,11 @@ func parseTilde(check *Checker, x ast.Expr) (tilde bool, typ Type) { check.error(x, _MisplacedTypeParam, "cannot embed a type parameter") typ = Typ[Invalid] } - return + term := NewTerm(tilde, typ) + if tilde { + check.recordTypeAndValue(tx, typexpr, &Union{[]*Term{term}}, nil) + } + return term } // overlappingTerm reports the index of the term x in terms which is @@ -150,10 +168,13 @@ func overlappingTerm(terms []*Term, y *Term) int { return -1 } -func flattenUnion(list []ast.Expr, x ast.Expr) []ast.Expr { +// flattenUnion walks a union type expression of the form A | B | C | ..., +// extracting both the binary exprs (blist) and leaf types (tlist). +func flattenUnion(list []ast.Expr, x ast.Expr) (blist, tlist []ast.Expr) { if o, _ := x.(*ast.BinaryExpr); o != nil && o.Op == token.OR { - list = flattenUnion(list, o.X) + blist, tlist = flattenUnion(list, o.X) + blist = append(blist, o) x = o.Y } - return append(list, x) + return blist, append(tlist, x) } From 38c067d178111d48a5ce96feccae1a7abe28ff59 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Olivier=20Mengu=C3=A9?= Date: Tue, 14 Dec 2021 23:05:03 +0100 Subject: [PATCH 490/752] doc: fix typo in 1.18 release notes for package testing In release notes for Go 1.18, fix typo in changes for package testing to correctly document the change in CL 343883. Change-Id: I40d92858ed3f74554a094466c06771f83dd81942 Reviewed-on: https://go-review.googlesource.com/c/go/+/371616 Reviewed-by: Ian Lance Taylor Trust: Cherry Mui --- doc/go1.18.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 64481a1466..c2568468ac 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -853,7 +853,7 @@ Do not send CLs removing the interior tags from such phrases. The precedence of / in the argument for -run and -bench has been increased. A/B|C/D used to be treated as A/(B|C)/D and is now treated as - (A/B)/(C/D). + (A/B)|(C/D).

      From dc5a8f9647257584a17efef219edc7d494b9a5bc Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Tue, 14 Dec 2021 15:39:14 -0800 Subject: [PATCH 491/752] doc/go1.18: fix an unclosed anchor Change-Id: I432bcc6ff917d008598b2f37c6e826f588a3d6d6 Reviewed-on: https://go-review.googlesource.com/c/go/+/372074 Reviewed-by: Dmitri Shuralyov Trust: Brad Fitzpatrick --- doc/go1.18.html | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index c2568468ac..59a307a438 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -116,7 +116,7 @@ Do not send CLs removing the interior tags from such phrases.

      The Go 1.18 compiler now reports an overflow when passing a rune constant expression - such as '1' << 32 as an argument to the predeclared functions + such as '1' << 32 as an argument to the predeclared functions print and println, consistent with the behavior of user-defined functions. Before Go 1.18, the compiler did not report an error in such cases but silently accepted such constant arguments if they fit into an @@ -442,10 +442,10 @@ Do not send CLs removing the interior tags from such phrases. methods that parallel existing methods, but return netip.AddrPort instead of the heavier-weight net.IP or - *net.UDPAddr types. + *net.UDPAddr types. The net package also now includes functions and methods to convert between the existing - TCPAddr/UDPAddr + TCPAddr/UDPAddr types and netip.AddrPort.

      From c948823cb7fc898eafb798ad15655663755d0bc9 Mon Sep 17 00:00:00 2001 From: MoZhonghua Date: Fri, 12 Nov 2021 08:08:25 +0000 Subject: [PATCH 492/752] runtime/cgo: fix signature of crosscall_amd64 in comment In CL 289192, crosscall_amd64() was changed to recieve 3 arguments, but the comment was not updated. Change-Id: Iba36c27aa5189e50f3fcc2a50291fecb2ef722c1 GitHub-Last-Rev: e7c041f00c562fdfeec84f1f3ea341713dcc7bf5 GitHub-Pull-Request: golang/go#49539 Reviewed-on: https://go-review.googlesource.com/c/go/+/363442 Reviewed-by: Ian Lance Taylor Reviewed-by: Cherry Mui --- src/runtime/cgo/gcc_amd64.S | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/runtime/cgo/gcc_amd64.S b/src/runtime/cgo/gcc_amd64.S index d75f864666..46699d1d9c 100644 --- a/src/runtime/cgo/gcc_amd64.S +++ b/src/runtime/cgo/gcc_amd64.S @@ -12,7 +12,7 @@ #endif /* - * void crosscall_amd64(void (*fn)(void)) + * void crosscall_amd64(void (*fn)(void), void (*setg_gcc)(void*), void *g) * * Calling into the 6c tool chain, where all registers are caller save. * Called from standard x86-64 ABI, where %rbx, %rbp, %r12-%r15 From 9d0ca262bbfa5561910f75e7b7d937b615d69393 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 14 Dec 2021 16:09:36 -0800 Subject: [PATCH 493/752] doc/go1.18: mention that embedding a type parameter is forbidden For #47694 Change-Id: Ibf38eabcb78abc563fcf77e2b566175a18c06fa3 Reviewed-on: https://go-review.googlesource.com/c/go/+/372114 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- doc/go1.18.html | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 59a307a438..9cb3cae20d 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -97,6 +97,12 @@ Do not send CLs removing the interior tags from such phrases. The Go compiler cannot currently handle type declarations inside generic functions or methods. We hope to provide support for this feature in Go 1.19.
      • +
    • + Embedding a type parameter, or a pointer to a type parameter, as + an unnamed field in a struct type is not permitted. Similarly + embedding a type parameter in an interface type is not permitted. + Whether these will ever be permitted is unclear at present. +

    From b5c0dbaafc548bd432c14935ae242ce1433180e8 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Tue, 14 Dec 2021 17:07:24 -0500 Subject: [PATCH 494/752] net: eliminate arbitrary timeout in TestVariousDeadlines When we set a timeout, we don't actually have a guarantee one how long the OS will take to notice it. Moreover, if the test deadlocks completely (for example, due to a deadline never taking effect), it would be more useful to get a full goroutine dump instead of the current "client stuck in Dial+Copy" failure message. For #37883 For #41863 Change-Id: I9f712ef1c620f97a5ab69baac45deb71134b99bc Reviewed-on: https://go-review.googlesource.com/c/go/+/371994 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Ian Lance Taylor TryBot-Result: Gopher Robot --- src/net/timeout_test.go | 34 +++++++++++----------------------- 1 file changed, 11 insertions(+), 23 deletions(-) diff --git a/src/net/timeout_test.go b/src/net/timeout_test.go index 032770dd83..3c6aa27cc1 100644 --- a/src/net/timeout_test.go +++ b/src/net/timeout_test.go @@ -947,35 +947,23 @@ func testVariousDeadlines(t *testing.T) { name := fmt.Sprintf("%v %d/%d", timeout, run, numRuns) t.Log(name) - tooSlow := time.NewTimer(5 * time.Second) - defer tooSlow.Stop() - c, err := Dial(ls.Listener.Addr().Network(), ls.Listener.Addr().String()) if err != nil { t.Fatal(err) } - ch := make(chan result, 1) - go func() { - t0 := time.Now() - if err := c.SetDeadline(t0.Add(timeout)); err != nil { - t.Error(err) - } - n, err := io.Copy(io.Discard, c) - dt := time.Since(t0) - c.Close() - ch <- result{n, err, dt} - }() + t0 := time.Now() + if err := c.SetDeadline(t0.Add(timeout)); err != nil { + t.Error(err) + } + n, err := io.Copy(io.Discard, c) + dt := time.Since(t0) + c.Close() - select { - case res := <-ch: - if nerr, ok := res.err.(Error); ok && nerr.Timeout() { - t.Logf("%v: good timeout after %v; %d bytes", name, res.d, res.n) - } else { - t.Fatalf("%v: Copy = %d, %v; want timeout", name, res.n, res.err) - } - case <-tooSlow.C: - t.Fatalf("%v: client stuck in Dial+Copy", name) + if nerr, ok := err.(Error); ok && nerr.Timeout() { + t.Logf("%v: good timeout after %v; %d bytes", name, dt, n) + } else { + t.Fatalf("%v: Copy = %d, %v; want timeout", name, n, err) } } } From b1c7703f266a2d72f80f3b55eff822ad7980ce31 Mon Sep 17 00:00:00 2001 From: Hana Date: Wed, 15 Dec 2021 08:40:30 -0500 Subject: [PATCH 495/752] doc/go1.18: discuss embedded build info compatibility Fixes #50085 Change-Id: I9be8ddb983fb4fe598becbb0b93bb5b7e1f8438f Reviewed-on: https://go-review.googlesource.com/c/go/+/372214 Trust: Hyang-Ah Hana Kim Run-TryBot: Hyang-Ah Hana Kim TryBot-Result: Gopher Robot Reviewed-by: Bryan Mills --- doc/go1.18.html | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 9cb3cae20d..2ec5fae8c7 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -250,6 +250,15 @@ Do not send CLs removing the interior tags from such phrases. package.

    +

    + The underlying data format of the embedded build information can change with + new go releases, so an older version of go may not handle the + build information produced with a newer version of go. + To read the version information from a binary built with go 1.18, + use the go version command and the + debug/buildinfo package from go 1.18+. +

    +

    If the main module's go.mod file specifies go 1.17 From 567b177949d0819169c10ba6a07ff60554eb5285 Mon Sep 17 00:00:00 2001 From: ichxxx Date: Wed, 15 Dec 2021 18:52:21 +0000 Subject: [PATCH 496/752] all: fix typo in comment Remove duplicate 'the' Change-Id: I3ed81c8d9c488662387e45580a3bcd462448ba44 GitHub-Last-Rev: 86443993b9b58c6fce4e09e283604c32ccc44cec GitHub-Pull-Request: golang/go#50017 Reviewed-on: https://go-review.googlesource.com/c/go/+/372394 Reviewed-by: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Ian Lance Taylor --- src/bufio/bufio_test.go | 2 +- src/cmd/compile/internal/noder/reader.go | 2 +- src/cmd/compile/internal/types/universe.go | 2 +- src/cmd/compile/internal/types2/assignments.go | 2 +- src/cmd/compile/internal/types2/typeset.go | 2 +- src/cmd/go/internal/modfetch/cache.go | 2 +- src/cmd/go/internal/modload/buildlist.go | 2 +- src/cmd/go/testdata/script/list_cgo_compiled_importmap.txt | 2 +- src/go/types/assignments.go | 2 +- src/go/types/typeset.go | 2 +- src/testing/fuzz.go | 2 +- 11 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/bufio/bufio_test.go b/src/bufio/bufio_test.go index 4dddfa9085..ff3396e946 100644 --- a/src/bufio/bufio_test.go +++ b/src/bufio/bufio_test.go @@ -657,7 +657,7 @@ func TestWriterAppend(t *testing.T) { } // While not recommended, it is valid to append to a shifted buffer. - // This forces Write to copy the the input. + // This forces Write to copy the input. if rn.Intn(8) == 0 && cap(b) > 0 { b = b[1:1:cap(b)] } diff --git a/src/cmd/compile/internal/noder/reader.go b/src/cmd/compile/internal/noder/reader.go index 0bc9135999..5d17c534c1 100644 --- a/src/cmd/compile/internal/noder/reader.go +++ b/src/cmd/compile/internal/noder/reader.go @@ -2029,7 +2029,7 @@ func InlineCall(call *ir.CallExpr, fn *ir.Func, inlIndex int) *ir.InlinedCallExp // Quirk: If deadcode elimination turned a non-empty function into // an empty one, we need to set the position for the empty block - // left behind to the the inlined position for src.NoXPos, so that + // left behind to the inlined position for src.NoXPos, so that // an empty string gets added into the DWARF file name listing at // the appropriate index. if quirksMode() && len(body) == 1 { diff --git a/src/cmd/compile/internal/types/universe.go b/src/cmd/compile/internal/types/universe.go index 54b04bda22..55ed7bd6d0 100644 --- a/src/cmd/compile/internal/types/universe.go +++ b/src/cmd/compile/internal/types/universe.go @@ -152,7 +152,7 @@ func makeErrorInterface() *Type { return NewInterface(NoPkg, []*Field{method}, false) } -// makeComparableInterface makes the the predefined "comparable" interface in the +// makeComparableInterface makes the predefined "comparable" interface in the // built-in package. It has a unique name, but no methods. func makeComparableInterface() *Type { return NewInterface(NoPkg, nil, false) diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go index 0a85d8eb39..668eeac00e 100644 --- a/src/cmd/compile/internal/types2/assignments.go +++ b/src/cmd/compile/internal/types2/assignments.go @@ -317,7 +317,7 @@ func (check *Checker) assignError(rhs []syntax.Expr, nvars, nvals int) { } // If returnStmt != nil, initVars is called to type-check the assignment -// of return expressions, and returnStmt is the the return statement. +// of return expressions, and returnStmt is the return statement. func (check *Checker) initVars(lhs []*Var, orig_rhs []syntax.Expr, returnStmt syntax.Stmt) { rhs, commaOk := check.exprList(orig_rhs, len(lhs) == 2 && returnStmt == nil) diff --git a/src/cmd/compile/internal/types2/typeset.go b/src/cmd/compile/internal/types2/typeset.go index eaf614da64..cbb454aa6a 100644 --- a/src/cmd/compile/internal/types2/typeset.go +++ b/src/cmd/compile/internal/types2/typeset.go @@ -167,7 +167,7 @@ func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *_ } // If the interface is not fully set up yet, the type set will - // not be complete, which may lead to errors when using the the + // not be complete, which may lead to errors when using the // type set (e.g. missing method). Don't compute a partial type // set (and don't store it!), so that we still compute the full // type set eventually. Instead, return the top type set and diff --git a/src/cmd/go/internal/modfetch/cache.go b/src/cmd/go/internal/modfetch/cache.go index c682447900..b0dae1cb3d 100644 --- a/src/cmd/go/internal/modfetch/cache.go +++ b/src/cmd/go/internal/modfetch/cache.go @@ -642,7 +642,7 @@ func rewriteVersionList(dir string) (err error) { // Lock listfile when writing to it to try to avoid corruption to the file. // Under rare circumstances, for instance, if the system loses power in the // middle of a write it is possible for corrupt data to be written. This is - // not a problem for the go command itself, but may be an issue if the the + // not a problem for the go command itself, but may be an issue if the // cache is being served by a GOPROXY HTTP server. This will be corrected // the next time a new version of the module is fetched and the file is rewritten. // TODO(matloob): golang.org/issue/43313 covers adding a go mod verify diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go index 45be51f1c6..38ba150002 100644 --- a/src/cmd/go/internal/modload/buildlist.go +++ b/src/cmd/go/internal/modload/buildlist.go @@ -352,7 +352,7 @@ func readModGraph(ctx context.Context, pruning modPruning, roots []module.Versio if pruning == unpruned { if _, dup := loadingUnpruned.LoadOrStore(m, nil); dup { // m has already been enqueued for loading. Since unpruned loading may - // follow cycles in the the requirement graph, we need to return early + // follow cycles in the requirement graph, we need to return early // to avoid making the load queue infinitely long. return } diff --git a/src/cmd/go/testdata/script/list_cgo_compiled_importmap.txt b/src/cmd/go/testdata/script/list_cgo_compiled_importmap.txt index 3d68ef3055..30effb104b 100644 --- a/src/cmd/go/testdata/script/list_cgo_compiled_importmap.txt +++ b/src/cmd/go/testdata/script/list_cgo_compiled_importmap.txt @@ -12,7 +12,7 @@ env CGO_ENABLED=1 env GOFLAGS=-tags=netcgo # Force net to use cgo even on Windows. -# "runtime/cgo [runtime.test]" appears in the the test dependencies of "runtime", +# "runtime/cgo [runtime.test]" appears in the test dependencies of "runtime", # because "runtime/cgo" itself depends on "runtime" go list -deps -test -compiled -f '{{if eq .ImportPath "net [runtime.test]"}}{{printf "%q" .Imports}}{{end}}' runtime diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go index a556e5e017..fa05a10920 100644 --- a/src/go/types/assignments.go +++ b/src/go/types/assignments.go @@ -313,7 +313,7 @@ func (check *Checker) assignError(rhs []ast.Expr, nvars, nvals int) { } // If returnStmt != nil, initVars is called to type-check the assignment -// of return expressions, and returnStmt is the the return statement. +// of return expressions, and returnStmt is the return statement. func (check *Checker) initVars(lhs []*Var, origRHS []ast.Expr, returnStmt ast.Stmt) { rhs, commaOk := check.exprList(origRHS, len(lhs) == 2 && returnStmt == nil) diff --git a/src/go/types/typeset.go b/src/go/types/typeset.go index 0f2897b8c6..96f740e5cf 100644 --- a/src/go/types/typeset.go +++ b/src/go/types/typeset.go @@ -165,7 +165,7 @@ func computeInterfaceTypeSet(check *Checker, pos token.Pos, ityp *Interface) *_T } // If the interface is not fully set up yet, the type set will - // not be complete, which may lead to errors when using the the + // not be complete, which may lead to errors when using the // type set (e.g. missing method). Don't compute a partial type // set (and don't store it!), so that we still compute the full // type set eventually. Instead, return the top type set and diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go index 4a5def1ab4..17a8753ae6 100644 --- a/src/testing/fuzz.go +++ b/src/testing/fuzz.go @@ -63,7 +63,7 @@ type InternalFuzzTarget struct { // for an example, and see the F.Fuzz and F.Add method documentation for // details. // -// *F methods can only be called before (*F).Fuzz. Once the the test is +// *F methods can only be called before (*F).Fuzz. Once the test is // executing the fuzz target, only (*T) methods can be used. The only *F methods // that are allowed in the (*F).Fuzz function are (*F).Failed and (*F).Name. type F struct { From d5fefbb4980aaf46ac25344615c660136c365b9f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20=C4=8Cajka?= Date: Mon, 13 Dec 2021 13:28:15 +0100 Subject: [PATCH 497/752] misc/cgo/testshared: pass -x flag only to commands supporting it Running testshared with the -testx flag leads to: ./testshared.test -testx -testwork + mkdir -p /tmp/shared_test125221103 shared_test.go:79: executing go env -x GOROOT failed exit status 2: flag provided but not defined: -x usage: go env [-json] [-u] [-w] [var ...] Run 'go help env' for details. panic: executing go env -x GOROOT failed exit status 2: flag provided but not defined: -x usage: go env [-json] [-u] [-w] [var ...] Run 'go help env' for details. Change-Id: Id299979487c021e9ad1d57f5f7088d935830a6a3 Reviewed-on: https://go-review.googlesource.com/c/go/+/371614 Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor Trust: Cherry Mui --- misc/cgo/testshared/shared_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/misc/cgo/testshared/shared_test.go b/misc/cgo/testshared/shared_test.go index d5d018f151..7b8cc66c3a 100644 --- a/misc/cgo/testshared/shared_test.go +++ b/misc/cgo/testshared/shared_test.go @@ -56,7 +56,7 @@ func runWithEnv(t *testing.T, msg string, env []string, args ...string) { // t.Fatalf if the command fails. func goCmd(t *testing.T, args ...string) string { newargs := []string{args[0]} - if *testX { + if *testX && args[0] != "env" { newargs = append(newargs, "-x") } newargs = append(newargs, args[1:]...) From 83fc0978e5d953ed058ca30bcfb8ddbc9ebdd88d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jakub=20=C4=8Cajka?= Date: Mon, 13 Dec 2021 15:57:25 +0100 Subject: [PATCH 498/752] misc/cgo/testshared: increase size limit in size check Recently in Fedora we switched binutils ld's separate-code on. This led to increased size of binaries, especially on 64k aligned arches. For example trivial test binary size grew from 80k to 211k on ppc64le tripping the size check(RHBZ#2030308). Therefore adjusting the size limit. Change-Id: Ic722d90c338739c0b285f40b12ba4d675e9626a2 Reviewed-on: https://go-review.googlesource.com/c/go/+/371634 Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor Reviewed-by: Cherry Mui --- misc/cgo/testshared/shared_test.go | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/misc/cgo/testshared/shared_test.go b/misc/cgo/testshared/shared_test.go index 7b8cc66c3a..b78083bc80 100644 --- a/misc/cgo/testshared/shared_test.go +++ b/misc/cgo/testshared/shared_test.go @@ -462,7 +462,9 @@ func TestTrivialExecutable(t *testing.T) { run(t, "trivial executable", "../../bin/trivial") AssertIsLinkedTo(t, "../../bin/trivial", soname) AssertHasRPath(t, "../../bin/trivial", gorootInstallDir) - checkSize(t, "../../bin/trivial", 100000) // it is 19K on linux/amd64, 100K should be enough + // It is 19K on linux/amd64, with separate-code in binutils ld and 64k being most common alignment + // 4*64k should be enough, but this might need revision eventually. + checkSize(t, "../../bin/trivial", 256000) } // Build a trivial program in PIE mode that links against the shared runtime and check it runs. @@ -471,7 +473,9 @@ func TestTrivialExecutablePIE(t *testing.T) { run(t, "trivial executable", "./trivial.pie") AssertIsLinkedTo(t, "./trivial.pie", soname) AssertHasRPath(t, "./trivial.pie", gorootInstallDir) - checkSize(t, "./trivial.pie", 100000) // it is 19K on linux/amd64, 100K should be enough + // It is 19K on linux/amd64, with separate-code in binutils ld and 64k being most common alignment + // 4*64k should be enough, but this might need revision eventually. + checkSize(t, "./trivial.pie", 256000) } // Check that the file size does not exceed a limit. From bc0aba971705722b6798746b2003908166ee007b Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Wed, 15 Dec 2021 12:34:34 -0500 Subject: [PATCH 499/752] cmd/compile: correct type identity comparison with "any" The builtin "any" type should only be identical to an unnamed empty interface type, not a defined empty interface type. Fixes #50169. Change-Id: Ie5bb88868497cb795de1fd0276133ba9812edfe4 Reviewed-on: https://go-review.googlesource.com/c/go/+/372217 Trust: Cherry Mui Trust: Dan Scales Reviewed-by: Dan Scales Reviewed-by: Matthew Dempsky Run-TryBot: Cherry Mui TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types/identity.go | 7 ++++--- test/fixedbugs/issue50169.go | 24 ++++++++++++++++++++++ 2 files changed, 28 insertions(+), 3 deletions(-) create mode 100644 test/fixedbugs/issue50169.go diff --git a/src/cmd/compile/internal/types/identity.go b/src/cmd/compile/internal/types/identity.go index a164b84da9..60a0f2e7c5 100644 --- a/src/cmd/compile/internal/types/identity.go +++ b/src/cmd/compile/internal/types/identity.go @@ -59,12 +59,13 @@ func identical(t1, t2 *Type, flags int, assumedEqual map[typePair]struct{}) bool case TINT32: return (t1 == Types[TINT32] || t1 == RuneType) && (t2 == Types[TINT32] || t2 == RuneType) case TINTER: - // Make sure named any type matches any empty interface + // Make sure named any type matches any unnamed empty interface // (but not a shape type, if identStrict). + isUnnamedEface := func(t *Type) bool { return t.IsEmptyInterface() && t.Sym() == nil } if flags&identStrict != 0 { - return t1 == AnyType && t2.IsEmptyInterface() && !t2.HasShape() || t2 == AnyType && t1.IsEmptyInterface() && !t1.HasShape() + return t1 == AnyType && isUnnamedEface(t2) && !t2.HasShape() || t2 == AnyType && isUnnamedEface(t1) && !t1.HasShape() } - return t1 == AnyType && t2.IsEmptyInterface() || t2 == AnyType && t1.IsEmptyInterface() + return t1 == AnyType && isUnnamedEface(t2) || t2 == AnyType && isUnnamedEface(t1) default: return false } diff --git a/test/fixedbugs/issue50169.go b/test/fixedbugs/issue50169.go new file mode 100644 index 0000000000..30d2713ec9 --- /dev/null +++ b/test/fixedbugs/issue50169.go @@ -0,0 +1,24 @@ +// 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 main + +func main() { + var x Value + NewScanner().Scan(x) +} + +type Value any + +type Scanner interface{ Scan(any) error } + +func NewScanner() Scanner { + return &t{} +} + +type t struct{} + +func (*t) Scan(interface{}) error { return nil } From 4cda05d41a8585c79bfe00f867ed3513672e69fa Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 15 Dec 2021 11:24:56 -0800 Subject: [PATCH 500/752] cmd/compile/internal/types2: externalize union type sets This is a port of CL 371756 from go/types to types2 with minor adjustments due to different error handling or AST. Updates #50093 Change-Id: Iab6a4634f8fc917bf99df439d31098624085f52a Reviewed-on: https://go-review.googlesource.com/c/go/+/372474 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/check.go | 2 ++ src/cmd/compile/internal/types2/predicates.go | 7 +++-- .../compile/internal/types2/sizeof_test.go | 2 +- src/cmd/compile/internal/types2/subst.go | 2 +- src/cmd/compile/internal/types2/typeset.go | 28 +++++++++++++------ src/cmd/compile/internal/types2/union.go | 7 ++--- 6 files changed, 31 insertions(+), 17 deletions(-) diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go index aacbb25b3b..22a921d0d7 100644 --- a/src/cmd/compile/internal/types2/check.go +++ b/src/cmd/compile/internal/types2/check.go @@ -129,6 +129,7 @@ type Checker struct { imports []*PkgName // list of imported packages dotImportMap map[dotImportKey]*PkgName // maps dot-imported objects to the package they were dot-imported through recvTParamMap map[*syntax.Name]*TypeParam // maps blank receiver type parameters to their type + unionTypeSets map[*Union]*_TypeSet // computed type sets for union types mono monoGraph // graph for detecting non-monomorphizable instantiation loops firstErr error // first error encountered @@ -330,6 +331,7 @@ func (check *Checker) checkFiles(files []*syntax.File) (err error) { check.pkgPathMap = nil check.seenPkgMap = nil check.recvTParamMap = nil + check.unionTypeSets = nil check.defTypes = nil check.ctxt = nil diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go index cf2993f68b..d982866f8e 100644 --- a/src/cmd/compile/internal/types2/predicates.go +++ b/src/cmd/compile/internal/types2/predicates.go @@ -287,8 +287,11 @@ func identical(x, y Type, cmpTags bool, p *ifacePair) bool { case *Union: if y, _ := y.(*Union); y != nil { - xset := computeUnionTypeSet(nil, nopos, x) - yset := computeUnionTypeSet(nil, nopos, y) + // TODO(rfindley): can this be reached during type checking? If so, + // consider passing a type set map. + unionSets := make(map[*Union]*_TypeSet) + xset := computeUnionTypeSet(nil, unionSets, nopos, x) + yset := computeUnionTypeSet(nil, unionSets, nopos, y) return xset.terms.equal(yset.terms) } diff --git a/src/cmd/compile/internal/types2/sizeof_test.go b/src/cmd/compile/internal/types2/sizeof_test.go index 99b846b80b..8db2d60e80 100644 --- a/src/cmd/compile/internal/types2/sizeof_test.go +++ b/src/cmd/compile/internal/types2/sizeof_test.go @@ -27,7 +27,7 @@ func TestSizeof(t *testing.T) { {Pointer{}, 8, 16}, {Tuple{}, 12, 24}, {Signature{}, 28, 56}, - {Union{}, 16, 32}, + {Union{}, 12, 24}, {Interface{}, 44, 88}, {Map{}, 16, 32}, {Chan{}, 12, 24}, diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go index 516f248127..4108f6aa85 100644 --- a/src/cmd/compile/internal/types2/subst.go +++ b/src/cmd/compile/internal/types2/subst.go @@ -130,7 +130,7 @@ func (subst *subster) typ(typ Type) Type { // term list substitution may introduce duplicate terms (unlikely but possible). // This is ok; lazy type set computation will determine the actual type set // in normal form. - return &Union{terms, nil} + return &Union{terms} } case *Interface: diff --git a/src/cmd/compile/internal/types2/typeset.go b/src/cmd/compile/internal/types2/typeset.go index cbb454aa6a..0d8d02662b 100644 --- a/src/cmd/compile/internal/types2/typeset.go +++ b/src/cmd/compile/internal/types2/typeset.go @@ -199,6 +199,16 @@ func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *_ // reason. ityp.tset = &_TypeSet{terms: allTermlist} // TODO(gri) is this sufficient? + var unionSets map[*Union]*_TypeSet + if check != nil { + if check.unionTypeSets == nil { + check.unionTypeSets = make(map[*Union]*_TypeSet) + } + unionSets = check.unionTypeSets + } else { + unionSets = make(map[*Union]*_TypeSet) + } + // Methods of embedded interfaces are collected unchanged; i.e., the identity // of a method I.m's Func Object of an interface I is the same as that of // the method m in an interface that embeds interface I. On the other hand, @@ -290,7 +300,7 @@ func computeInterfaceTypeSet(check *Checker, pos syntax.Pos, ityp *Interface) *_ check.versionErrorf(pos, "go1.18", "embedding interface element %s", u) continue } - tset := computeUnionTypeSet(check, pos, u) + tset := computeUnionTypeSet(check, unionSets, pos, u) if tset == &invalidTypeSet { continue // ignore invalid unions } @@ -358,13 +368,13 @@ var invalidTypeSet _TypeSet // computeUnionTypeSet may be called with check == nil. // The result is &invalidTypeSet if the union overflows. -func computeUnionTypeSet(check *Checker, pos syntax.Pos, utyp *Union) *_TypeSet { - if utyp.tset != nil { - return utyp.tset +func computeUnionTypeSet(check *Checker, unionSets map[*Union]*_TypeSet, pos syntax.Pos, utyp *Union) *_TypeSet { + if tset, _ := unionSets[utyp]; tset != nil { + return tset } // avoid infinite recursion (see also computeInterfaceTypeSet) - utyp.tset = new(_TypeSet) + unionSets[utyp] = new(_TypeSet) var allTerms termlist for _, t := range utyp.terms { @@ -391,11 +401,11 @@ func computeUnionTypeSet(check *Checker, pos syntax.Pos, utyp *Union) *_TypeSet if check != nil { check.errorf(pos, "cannot handle more than %d union terms (implementation limitation)", maxTermCount) } - utyp.tset = &invalidTypeSet - return utyp.tset + unionSets[utyp] = &invalidTypeSet + return unionSets[utyp] } } - utyp.tset.terms = allTerms + unionSets[utyp].terms = allTerms - return utyp.tset + return unionSets[utyp] } diff --git a/src/cmd/compile/internal/types2/union.go b/src/cmd/compile/internal/types2/union.go index 97581fe863..98dd6cedc7 100644 --- a/src/cmd/compile/internal/types2/union.go +++ b/src/cmd/compile/internal/types2/union.go @@ -11,8 +11,7 @@ import "cmd/compile/internal/syntax" // A Union represents a union of terms embedded in an interface. type Union struct { - terms []*Term // list of syntactical terms (not a canonicalized termlist) - tset *_TypeSet // type set described by this union, computed lazily + terms []*Term // list of syntactical terms (not a canonicalized termlist) } // NewUnion returns a new Union type with the given terms. @@ -21,7 +20,7 @@ func NewUnion(terms []*Term) *Union { if len(terms) == 0 { panic("empty union") } - return &Union{terms, nil} + return &Union{terms} } func (u *Union) Len() int { return len(u.terms) } @@ -107,7 +106,7 @@ func parseUnion(check *Checker, uexpr syntax.Expr) Type { } }) - u := &Union{terms, nil} + u := &Union{terms} check.recordTypeAndValue(uexpr, typexpr, u, nil) return u } From 07ed86c57bb2aa5656ad7ab8df9c8b5faf089cbd Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 15 Dec 2021 11:42:58 -0800 Subject: [PATCH 501/752] cmd/compile/internal/types2: record types for union subexpressions This is a port of CL 371757 from go/types to types2, with minor adjustments for different error handling and AST. It also names the added API test cases more consistently. The same renaming was applied to the respective go/types file. Updates #50093 Change-Id: Iaa132106a197a207f831525432e62e9d452b17c9 Reviewed-on: https://go-review.googlesource.com/c/go/+/372475 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/api.go | 6 --- src/cmd/compile/internal/types2/api_test.go | 15 ++++++ src/cmd/compile/internal/types2/union.go | 55 ++++++++++++++------- src/go/types/api_test.go | 22 +++++---- 4 files changed, 65 insertions(+), 33 deletions(-) diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go index ed5bced643..4ea3989c39 100644 --- a/src/cmd/compile/internal/types2/api.go +++ b/src/cmd/compile/internal/types2/api.go @@ -202,12 +202,6 @@ type Info struct { // identifier z in a variable declaration 'var z int' is found // only in the Defs map, and identifiers denoting packages in // qualified identifiers are collected in the Uses map. - // - // For binary expressions representing unions in constraint - // position or type elements in interfaces, a union type is - // recorded for the top-level expression only. For instance, - // given the constraint a|b|c, the union type for (a|b)|c - // is recorded, but not the union type for a|b. Types map[syntax.Expr]TypeAndValue // Instances maps identifiers denoting parameterized types or functions to diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go index fc8b5cd4ee..dee7ffbaf7 100644 --- a/src/cmd/compile/internal/types2/api_test.go +++ b/src/cmd/compile/internal/types2/api_test.go @@ -348,10 +348,25 @@ func TestTypesInfo(t *testing.T) { {`package u1a; func _[_ interface{~int}]() {}`, `~int`, `~int`}, {`package u2a; func _[_ interface{int|string}]() {}`, `int | string`, `int|string`}, {`package u3a; func _[_ interface{int|string|~bool}]() {}`, `int | string | ~bool`, `int|string|~bool`}, + {`package u3a; func _[_ interface{int|string|~bool}]() {}`, `int | string`, `int|string`}, + {`package u3a; func _[_ interface{int|string|~bool}]() {}`, `~bool`, `~bool`}, + {`package u3a; func _[_ interface{int|string|~float64|~bool}]() {}`, `int | string | ~float64`, `int|string|~float64`}, + {`package u0b; func _[_ int]() {}`, `int`, `int`}, {`package u1b; func _[_ ~int]() {}`, `~int`, `~int`}, {`package u2b; func _[_ int|string]() {}`, `int | string`, `int|string`}, {`package u3b; func _[_ int|string|~bool]() {}`, `int | string | ~bool`, `int|string|~bool`}, + {`package u3b; func _[_ int|string|~bool]() {}`, `int | string`, `int|string`}, + {`package u3b; func _[_ int|string|~bool]() {}`, `~bool`, `~bool`}, + {`package u3b; func _[_ int|string|~float64|~bool]() {}`, `int | string | ~float64`, `int|string|~float64`}, + + {`package u0c; type _ interface{int}`, `int`, `int`}, + {`package u1c; type _ interface{~int}`, `~int`, `~int`}, + {`package u2c; type _ interface{int|string}`, `int | string`, `int|string`}, + {`package u3c; type _ interface{int|string|~bool}`, `int | string | ~bool`, `int|string|~bool`}, + {`package u3c; type _ interface{int|string|~bool}`, `int | string`, `int|string`}, + {`package u3c; type _ interface{int|string|~bool}`, `~bool`, `~bool`}, + {`package u3c; type _ interface{int|string|~float64|~bool}`, `int | string | ~float64`, `int|string|~float64`}, } for _, test := range tests { diff --git a/src/cmd/compile/internal/types2/union.go b/src/cmd/compile/internal/types2/union.go index 98dd6cedc7..6f66260af4 100644 --- a/src/cmd/compile/internal/types2/union.go +++ b/src/cmd/compile/internal/types2/union.go @@ -48,23 +48,37 @@ const maxTermCount = 100 // parseUnion parses uexpr as a union of expressions. // The result is a Union type, or Typ[Invalid] for some errors. func parseUnion(check *Checker, uexpr syntax.Expr) Type { - tlist := flattenUnion(nil, uexpr) + blist, tlist := flattenUnion(nil, uexpr) + assert(len(blist) == len(tlist)-1) var terms []*Term - for _, x := range tlist { - tilde, typ := parseTilde(check, x) - if len(tlist) == 1 && !tilde { + + var u Type + for i, x := range tlist { + term := parseTilde(check, x) + if len(tlist) == 1 && !term.tilde { // Single type. Ok to return early because all relevant // checks have been performed in parseTilde (no need to // run through term validity check below). - return typ // typ already recorded through check.typ in parseTilde + return term.typ // typ already recorded through check.typ in parseTilde } if len(terms) >= maxTermCount { - check.errorf(x, "cannot handle more than %d union terms (implementation limitation)", maxTermCount) - check.recordTypeAndValue(uexpr, typexpr, Typ[Invalid], nil) - return Typ[Invalid] + if u != Typ[Invalid] { + check.errorf(x, "cannot handle more than %d union terms (implementation limitation)", maxTermCount) + u = Typ[Invalid] + } + } else { + terms = append(terms, term) + u = &Union{terms} } - terms = append(terms, NewTerm(tilde, typ)) + + if i > 0 { + check.recordTypeAndValue(blist[i-1], typexpr, u, nil) + } + } + + if u == Typ[Invalid] { + return u } // Check validity of terms. @@ -106,17 +120,17 @@ func parseUnion(check *Checker, uexpr syntax.Expr) Type { } }) - u := &Union{terms} - check.recordTypeAndValue(uexpr, typexpr, u, nil) return u } -func parseTilde(check *Checker, x syntax.Expr) (tilde bool, typ Type) { +func parseTilde(check *Checker, tx syntax.Expr) *Term { + x := tx + var tilde bool if op, _ := x.(*syntax.Operation); op != nil && op.Op == syntax.Tilde { x = op.X tilde = true } - typ = check.typ(x) + typ := check.typ(x) // Embedding stand-alone type parameters is not permitted (issue #47127). // We don't need this restriction anymore if we make the underlying type of a type // parameter its constraint interface: if we embed a lone type parameter, we will @@ -126,7 +140,11 @@ func parseTilde(check *Checker, x syntax.Expr) (tilde bool, typ Type) { check.error(x, "cannot embed a type parameter") typ = Typ[Invalid] } - return + term := NewTerm(tilde, typ) + if tilde { + check.recordTypeAndValue(tx, typexpr, &Union{[]*Term{term}}, nil) + } + return term } // overlappingTerm reports the index of the term x in terms which is @@ -147,10 +165,13 @@ func overlappingTerm(terms []*Term, y *Term) int { return -1 } -func flattenUnion(list []syntax.Expr, x syntax.Expr) []syntax.Expr { +// flattenUnion walks a union type expression of the form A | B | C | ..., +// extracting both the binary exprs (blist) and leaf types (tlist). +func flattenUnion(list []syntax.Expr, x syntax.Expr) (blist, tlist []syntax.Expr) { if o, _ := x.(*syntax.Operation); o != nil && o.Op == syntax.Or { - list = flattenUnion(list, o.X) + blist, tlist = flattenUnion(list, o.X) + blist = append(blist, o) x = o.Y } - return append(list, x) + return blist, append(tlist, x) } diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go index e55255d75e..6a1bf26984 100644 --- a/src/go/types/api_test.go +++ b/src/go/types/api_test.go @@ -379,9 +379,10 @@ func TestTypesInfo(t *testing.T) { {genericPkg + `u1a; func _[_ interface{~int}]() {}`, `~int`, `~int`}, {genericPkg + `u2a; func _[_ interface{int|string}]() {}`, `int | string`, `int|string`}, {genericPkg + `u3a; func _[_ interface{int|string|~bool}]() {}`, `int | string | ~bool`, `int|string|~bool`}, - {genericPkg + `u3b; func _[_ interface{int|string|~bool}]() {}`, `int | string`, `int|string`}, - {genericPkg + `u3b; func _[_ interface{int|string|~bool}]() {}`, `~bool`, `~bool`}, - {genericPkg + `u3b; func _[_ interface{int|string|~float64|~bool}]() {}`, `int | string | ~float64`, `int|string|~float64`}, + {genericPkg + `u3a; func _[_ interface{int|string|~bool}]() {}`, `int | string`, `int|string`}, + {genericPkg + `u3a; func _[_ interface{int|string|~bool}]() {}`, `~bool`, `~bool`}, + {genericPkg + `u3a; func _[_ interface{int|string|~float64|~bool}]() {}`, `int | string | ~float64`, `int|string|~float64`}, + {genericPkg + `u0b; func _[_ int]() {}`, `int`, `int`}, {genericPkg + `u1b; func _[_ ~int]() {}`, `~int`, `~int`}, {genericPkg + `u2b; func _[_ int|string]() {}`, `int | string`, `int|string`}, @@ -389,13 +390,14 @@ func TestTypesInfo(t *testing.T) { {genericPkg + `u3b; func _[_ int|string|~bool]() {}`, `int | string`, `int|string`}, {genericPkg + `u3b; func _[_ int|string|~bool]() {}`, `~bool`, `~bool`}, {genericPkg + `u3b; func _[_ int|string|~float64|~bool]() {}`, `int | string | ~float64`, `int|string|~float64`}, - {genericPkg + `u0b; type _ interface{int}`, `int`, `int`}, - {genericPkg + `u1b; type _ interface{~int}`, `~int`, `~int`}, - {genericPkg + `u2b; type _ interface{int|string}`, `int | string`, `int|string`}, - {genericPkg + `u3b; type _ interface{int|string|~bool}`, `int | string | ~bool`, `int|string|~bool`}, - {genericPkg + `u3b; type _ interface{int|string|~bool}`, `int | string`, `int|string`}, - {genericPkg + `u3b; type _ interface{int|string|~bool}`, `~bool`, `~bool`}, - {genericPkg + `u3b; type _ interface{int|string|~float64|~bool}`, `int | string | ~float64`, `int|string|~float64`}, + + {genericPkg + `u0c; type _ interface{int}`, `int`, `int`}, + {genericPkg + `u1c; type _ interface{~int}`, `~int`, `~int`}, + {genericPkg + `u2c; type _ interface{int|string}`, `int | string`, `int|string`}, + {genericPkg + `u3c; type _ interface{int|string|~bool}`, `int | string | ~bool`, `int|string|~bool`}, + {genericPkg + `u3c; type _ interface{int|string|~bool}`, `int | string`, `int|string`}, + {genericPkg + `u3c; type _ interface{int|string|~bool}`, `~bool`, `~bool`}, + {genericPkg + `u3c; type _ interface{int|string|~float64|~bool}`, `int | string | ~float64`, `int|string|~float64`}, } for _, test := range tests { From 58e8e26924ed113a8d5f4187c36ca6ef13f29fb2 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 15 Dec 2021 11:39:18 -0500 Subject: [PATCH 502/752] net: skip Lookup tests of external hosts on builders with flaky networks For #50191 Change-Id: Ic1059127e756d69ea9b75cf5805669ec43fedd5c Reviewed-on: https://go-review.googlesource.com/c/go/+/372216 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/net/lookup_test.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index d71a18c684..063d650c60 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -352,6 +352,7 @@ var lookupCNAMETests = []struct { func TestLookupCNAME(t *testing.T) { mustHaveExternalNetwork(t) + testenv.SkipFlakyNet(t) if !supportsIPv4() || !*testIPv4 { t.Skip("IPv4 is required") @@ -390,6 +391,7 @@ var lookupGoogleHostTests = []struct { func TestLookupGoogleHost(t *testing.T) { mustHaveExternalNetwork(t) + testenv.SkipFlakyNet(t) if !supportsIPv4() || !*testIPv4 { t.Skip("IPv4 is required") @@ -442,6 +444,7 @@ var lookupGoogleIPTests = []struct { func TestLookupGoogleIP(t *testing.T) { mustHaveExternalNetwork(t) + testenv.SkipFlakyNet(t) if !supportsIPv4() || !*testIPv4 { t.Skip("IPv4 is required") @@ -632,6 +635,7 @@ func TestLookupDotsWithRemoteSource(t *testing.T) { testenv.SkipFlaky(t, 27992) } mustHaveExternalNetwork(t) + testenv.SkipFlakyNet(t) if !supportsIPv4() || !*testIPv4 { t.Skip("IPv4 is required") @@ -656,7 +660,6 @@ func TestLookupDotsWithRemoteSource(t *testing.T) { func testDots(t *testing.T, mode string) { names, err := LookupAddr("8.8.8.8") // Google dns server if err != nil { - testenv.SkipFlakyNet(t) t.Errorf("LookupAddr(8.8.8.8): %v (mode=%v)", err, mode) } else { for _, name := range names { @@ -669,7 +672,6 @@ func testDots(t *testing.T, mode string) { cname, err := LookupCNAME("www.mit.edu") if err != nil { - testenv.SkipFlakyNet(t) t.Errorf("LookupCNAME(www.mit.edu, mode=%v): %v", mode, err) } else if !strings.HasSuffix(cname, ".") { t.Errorf("LookupCNAME(www.mit.edu) = %v, want cname ending in . with trailing dot (mode=%v)", cname, mode) @@ -677,7 +679,6 @@ func testDots(t *testing.T, mode string) { mxs, err := LookupMX("google.com") if err != nil { - testenv.SkipFlakyNet(t) t.Errorf("LookupMX(google.com): %v (mode=%v)", err, mode) } else { for _, mx := range mxs { @@ -690,7 +691,6 @@ func testDots(t *testing.T, mode string) { nss, err := LookupNS("google.com") if err != nil { - testenv.SkipFlakyNet(t) t.Errorf("LookupNS(google.com): %v (mode=%v)", err, mode) } else { for _, ns := range nss { @@ -703,7 +703,6 @@ func testDots(t *testing.T, mode string) { cname, srvs, err := LookupSRV("xmpp-server", "tcp", "google.com") if err != nil { - testenv.SkipFlakyNet(t) t.Errorf("LookupSRV(xmpp-server, tcp, google.com): %v (mode=%v)", err, mode) } else { if !hasSuffixFold(cname, ".google.com.") { @@ -925,6 +924,7 @@ func TestNilResolverLookup(t *testing.T) { // canceled lookups (see golang.org/issue/24178 for details). func TestLookupHostCancel(t *testing.T) { mustHaveExternalNetwork(t) + testenv.SkipFlakyNet(t) t.Parallel() // Executes 600ms worth of sequential sleeps. const ( From c9ffcca7848e2c59a75f97801617322bb054c3fd Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 15 Dec 2021 10:46:11 -0500 Subject: [PATCH 503/752] net: increase timing slop in TimeoutFluctuation tests on NetBSD and OpenBSD Decrease the slop everywhere else, since NetBSD and OpenBSD seem to be the only ones that miss by that much. For #50189 Updates #36108 Change-Id: I22ac39cc7c254e40358fcd933b5a6016629602c3 Reviewed-on: https://go-review.googlesource.com/c/go/+/372215 Trust: Bryan Mills Reviewed-by: Ian Lance Taylor --- src/net/timeout_test.go | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-) diff --git a/src/net/timeout_test.go b/src/net/timeout_test.go index 3c6aa27cc1..d1cfbf853c 100644 --- a/src/net/timeout_test.go +++ b/src/net/timeout_test.go @@ -644,10 +644,20 @@ const ( // timeoutUpperBound returns the maximum time that we expect a timeout of // duration d to take to return the caller. func timeoutUpperBound(d time.Duration) time.Duration { - // In https://storage.googleapis.com/go-build-log/1e637cd3/openbsd-amd64-68_3585d3e7.log, - // we observed that an openbsd-amd64-68 builder took 636ms for a 512ms timeout - // (24.2% overhead). - return d * 4 / 3 + switch runtime.GOOS { + case "openbsd", "netbsd": + // NetBSD and OpenBSD seem to be unable to reliably hit deadlines even when + // the absolute durations are long. + // In https://build.golang.org/log/c34f8685d020b98377dd4988cd38f0c5bd72267e, + // we observed that an openbsd-amd64-68 builder took 4.090948779s for a + // 2.983020682s timeout (37.1% overhead). + // (See https://go.dev/issue/50189 for further detail.) + // Give them lots of slop to compensate. + return d * 3 / 2 + } + // Other platforms seem to hit their deadlines more reliably, + // at least when they are long enough to cover scheduling jitter. + return d * 11 / 10 } // nextTimeout returns the next timeout to try after an operation took the given From 6e7c6912186b6c91fff332ef473409a8e960c519 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Mon, 13 Dec 2021 15:10:31 -0800 Subject: [PATCH 504/752] test: add simpler test for issue 50109 Thanks to the simpler test case for issue 50109. I'm keeping the old test case in place, since it's not too complex, and may be useful for testing other things as well. Updates #50109 Change-Id: I80cdbd1da473d0cc4dcbd68e45bab7ddb6f9263e Reviewed-on: https://go-review.googlesource.com/c/go/+/371515 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: roger peppe --- test/typeparam/issue50109b.go | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 test/typeparam/issue50109b.go diff --git a/test/typeparam/issue50109b.go b/test/typeparam/issue50109b.go new file mode 100644 index 0000000000..1d89efca88 --- /dev/null +++ b/test/typeparam/issue50109b.go @@ -0,0 +1,29 @@ +// run -gcflags=-G=3 + +// 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() { + F[any]() +} + +func F[T any]() I[T] { + return (*S1[T])(nil) +} + +type I[T any] interface{} + +type S1[T any] struct { + *S2[T] +} + +type S2[T any] struct { + S3 *S3[T] +} + +type S3[T any] struct { + x int +} From d107aa2cd1fdc596b9275a127e6c35cc5f8d32bb Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 15 Dec 2021 13:04:54 -0800 Subject: [PATCH 505/752] cmd/compile: upgrade ssa to do (int or float) -> complex Generic instantiations can produce conversions from constant literal ints or floats to complex values. We could constant literals during instantiation, but it is just as easy to upgrade the code generator to do the conversions. Fixes #50193 Change-Id: I24bdc09226c8e868f6282e0e4057ba6c3ad5c41a Reviewed-on: https://go-review.googlesource.com/c/go/+/372514 Trust: Keith Randall Run-TryBot: Keith Randall Trust: Dan Scales Reviewed-by: Dan Scales Reviewed-by: Cherry Mui TryBot-Result: Gopher Robot --- src/cmd/compile/internal/ssagen/ssa.go | 57 +++++++++++++++----------- test/typeparam/issue50193.go | 32 +++++++++++++++ test/typeparam/issue50193.out | 6 +++ 3 files changed, 70 insertions(+), 25 deletions(-) create mode 100644 test/typeparam/issue50193.go create mode 100644 test/typeparam/issue50193.out diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go index 265ef1aab3..0b54925696 100644 --- a/src/cmd/compile/internal/ssagen/ssa.go +++ b/src/cmd/compile/internal/ssagen/ssa.go @@ -2446,6 +2446,38 @@ func (s *state) conv(n ir.Node, v *ssa.Value, ft, tt *types.Type) *ssa.Value { return s.newValue1(op, tt, v) } + if ft.IsComplex() && tt.IsComplex() { + var op ssa.Op + if ft.Size() == tt.Size() { + switch ft.Size() { + case 8: + op = ssa.OpRound32F + case 16: + op = ssa.OpRound64F + default: + s.Fatalf("weird complex conversion %v -> %v", ft, tt) + } + } else if ft.Size() == 8 && tt.Size() == 16 { + op = ssa.OpCvt32Fto64F + } else if ft.Size() == 16 && tt.Size() == 8 { + op = ssa.OpCvt64Fto32F + } else { + s.Fatalf("weird complex conversion %v -> %v", ft, tt) + } + ftp := types.FloatForComplex(ft) + ttp := types.FloatForComplex(tt) + return s.newValue2(ssa.OpComplexMake, tt, + s.newValueOrSfCall1(op, ttp, s.newValue1(ssa.OpComplexReal, ftp, v)), + s.newValueOrSfCall1(op, ttp, s.newValue1(ssa.OpComplexImag, ftp, v))) + } + + if tt.IsComplex() { // and ft is not complex + // Needed for generics support - can't happen in normal Go code. + et := types.FloatForComplex(tt) + v = s.conv(n, v, ft, et) + return s.newValue2(ssa.OpComplexMake, tt, v, s.zeroVal(et)) + } + if ft.IsFloat() || tt.IsFloat() { conv, ok := fpConvOpToSSA[twoTypes{s.concreteEtype(ft), s.concreteEtype(tt)}] if s.config.RegSize == 4 && Arch.LinkArch.Family != sys.MIPS && !s.softFloat { @@ -2519,31 +2551,6 @@ func (s *state) conv(n ir.Node, v *ssa.Value, ft, tt *types.Type) *ssa.Value { return nil } - if ft.IsComplex() && tt.IsComplex() { - var op ssa.Op - if ft.Size() == tt.Size() { - switch ft.Size() { - case 8: - op = ssa.OpRound32F - case 16: - op = ssa.OpRound64F - default: - s.Fatalf("weird complex conversion %v -> %v", ft, tt) - } - } else if ft.Size() == 8 && tt.Size() == 16 { - op = ssa.OpCvt32Fto64F - } else if ft.Size() == 16 && tt.Size() == 8 { - op = ssa.OpCvt64Fto32F - } else { - s.Fatalf("weird complex conversion %v -> %v", ft, tt) - } - ftp := types.FloatForComplex(ft) - ttp := types.FloatForComplex(tt) - return s.newValue2(ssa.OpComplexMake, tt, - s.newValueOrSfCall1(op, ttp, s.newValue1(ssa.OpComplexReal, ftp, v)), - s.newValueOrSfCall1(op, ttp, s.newValue1(ssa.OpComplexImag, ftp, v))) - } - s.Fatalf("unhandled OCONV %s -> %s", ft.Kind(), tt.Kind()) return nil } diff --git a/test/typeparam/issue50193.go b/test/typeparam/issue50193.go new file mode 100644 index 0000000000..8dc488244e --- /dev/null +++ b/test/typeparam/issue50193.go @@ -0,0 +1,32 @@ +// run -gcflags=-G=3 + +// 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 ( + "constraints" + "fmt" +) + +func zero[T constraints.Complex]() T { + return T(0) +} +func pi[T constraints.Complex]() T { + return T(3.14) +} +func sqrtN1[T constraints.Complex]() T { + return T(-1i) +} + +func main() { + fmt.Println(zero[complex128]()) + fmt.Println(pi[complex128]()) + fmt.Println(sqrtN1[complex128]()) + fmt.Println(zero[complex64]()) + fmt.Println(pi[complex64]()) + fmt.Println(sqrtN1[complex64]()) +} + diff --git a/test/typeparam/issue50193.out b/test/typeparam/issue50193.out new file mode 100644 index 0000000000..68186222c7 --- /dev/null +++ b/test/typeparam/issue50193.out @@ -0,0 +1,6 @@ +(0+0i) +(3.14+0i) +(0-1i) +(0+0i) +(3.14+0i) +(0-1i) From 7f2314530e7cb4a11c6df4f7bd51187f5cffe2a5 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 13 Dec 2021 20:11:07 -0800 Subject: [PATCH 506/752] cmd/compile: don't re-typecheck while importing The imported code is already typechecked. NodAddrAt typechecks its argument, which is unnecessary here and leads to errors when typechecking unexported field references in other packages' code. Mark the node is question as already typechecked, so we don't retypecheck it. Fixes #50148 Change-Id: I9789e3e7dd4d58ec095675e27b1c98389f7a0c44 Reviewed-on: https://go-review.googlesource.com/c/go/+/371554 Trust: Keith Randall Run-TryBot: Keith Randall Trust: Dan Scales Reviewed-by: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/typecheck/iimport.go | 7 ++++++- test/typeparam/structinit.dir/a.go | 15 +++++++++++++++ test/typeparam/structinit.dir/b.go | 12 ++++++++++++ test/typeparam/structinit.dir/main.go | 11 +++++++++++ test/typeparam/structinit.go | 7 +++++++ 5 files changed, 51 insertions(+), 1 deletion(-) create mode 100644 test/typeparam/structinit.dir/a.go create mode 100644 test/typeparam/structinit.dir/b.go create mode 100644 test/typeparam/structinit.dir/main.go create mode 100644 test/typeparam/structinit.go diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go index 09f87df580..bc34d3933a 100644 --- a/src/cmd/compile/internal/typecheck/iimport.go +++ b/src/cmd/compile/internal/typecheck/iimport.go @@ -1630,11 +1630,16 @@ func (r *importReader) node() ir.Node { return n case ir.OADDR, ir.OPTRLIT: - n := NodAddrAt(r.pos(), r.expr()) if go117ExportTypes { + pos := r.pos() + expr := r.expr() + expr.SetTypecheck(1) // we do this for all nodes after importing, but do it now so markAddrOf can see it. + n := NodAddrAt(pos, expr) n.SetOp(op) n.SetType(r.typ()) + return n } + n := NodAddrAt(r.pos(), r.expr()) return n case ir.ODEREF: diff --git a/test/typeparam/structinit.dir/a.go b/test/typeparam/structinit.dir/a.go new file mode 100644 index 0000000000..c76d1551ad --- /dev/null +++ b/test/typeparam/structinit.dir/a.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. + +package a + +type S[T any] struct { +} + +func (b *S[T]) build() *X[T] { + return &X[T]{f:0} +} +type X[T any] struct { + f int +} diff --git a/test/typeparam/structinit.dir/b.go b/test/typeparam/structinit.dir/b.go new file mode 100644 index 0000000000..40a929bcae --- /dev/null +++ b/test/typeparam/structinit.dir/b.go @@ -0,0 +1,12 @@ +// 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" + +func B() { + var x a.S[int] + _ = x +} diff --git a/test/typeparam/structinit.dir/main.go b/test/typeparam/structinit.dir/main.go new file mode 100644 index 0000000000..c564171879 --- /dev/null +++ b/test/typeparam/structinit.dir/main.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. + +package main + +import "./b" + +func main() { + b.B() +} diff --git a/test/typeparam/structinit.go b/test/typeparam/structinit.go new file mode 100644 index 0000000000..76930e5e4f --- /dev/null +++ b/test/typeparam/structinit.go @@ -0,0 +1,7 @@ +// rundir -G=3 + +// 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 From 1d3a5b4aeac319acd51b32e1d47a9c316d9ce2aa Mon Sep 17 00:00:00 2001 From: zhouguangyuan Date: Thu, 16 Dec 2021 22:18:26 +0800 Subject: [PATCH 507/752] reflect: fix name of type parameter Fixes #50208 Change-Id: Ib0aff56341adb98ff6831c5badd1603ebf002b79 Reviewed-on: https://go-review.googlesource.com/c/go/+/372774 Reviewed-by: Keith Randall Run-TryBot: Keith Randall TryBot-Result: Gopher Robot Trust: Cherry Mui --- src/reflect/all_test.go | 14 ++++++++++++++ src/reflect/type.go | 9 ++++++++- 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/src/reflect/all_test.go b/src/reflect/all_test.go index 9c8434c22c..866f38e687 100644 --- a/src/reflect/all_test.go +++ b/src/reflect/all_test.go @@ -7768,3 +7768,17 @@ func TestMethodCallValueCodePtr(t *testing.T) { t.Errorf("methodValueCall code pointer mismatched, want: %v, got: %v", want, got) } } + +type A struct{} +type B[T any] struct{} + +func TestIssue50208(t *testing.T) { + want1 := "B[reflect_test.A]" + if got := TypeOf(new(B[A])).Elem().Name(); got != want1 { + t.Errorf("name of type parameter mismatched, want:%s, got:%s", want1, got) + } + want2 := "B[reflect_test.B[reflect_test.A]]" + if got := TypeOf(new(B[B[A]])).Elem().Name(); got != want2 { + t.Errorf("name of type parameter mismatched, want:%s, got:%s", want2, got) + } +} diff --git a/src/reflect/type.go b/src/reflect/type.go index 6217291a3f..4e03dc3382 100644 --- a/src/reflect/type.go +++ b/src/reflect/type.go @@ -915,7 +915,14 @@ func (t *rtype) Name() string { } s := t.String() i := len(s) - 1 - for i >= 0 && s[i] != '.' { + sqBrackets := 0 + for i >= 0 && (s[i] != '.' || sqBrackets != 0) { + switch s[i] { + case ']': + sqBrackets++ + case '[': + sqBrackets-- + } i-- } return s[i+1:] From ea26ce7cec7ed19b7e859dbb0e7e4354a9679911 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Thu, 9 Dec 2021 14:52:49 -0500 Subject: [PATCH 508/752] cmd/go: examine dependencies of main modules in workspace mode To make sure that we properly pull in everything in all, because different main modules can interfere with each others' pruning. Fixes #49763 Change-Id: I0756993d8ae9919ccb27ec460d579d348c38ec3b Reviewed-on: https://go-review.googlesource.com/c/go/+/370663 Trust: Michael Matloob Run-TryBot: Michael Matloob Reviewed-by: Bryan Mills TryBot-Result: Gopher Robot --- src/cmd/go/internal/modload/buildlist.go | 46 +++++ src/cmd/go/testdata/script/work_prune_all.txt | 176 ++++++++++++++++++ 2 files changed, 222 insertions(+) create mode 100644 src/cmd/go/testdata/script/work_prune_all.txt diff --git a/src/cmd/go/internal/modload/buildlist.go b/src/cmd/go/internal/modload/buildlist.go index 38ba150002..6f9072c8c4 100644 --- a/src/cmd/go/internal/modload/buildlist.go +++ b/src/cmd/go/internal/modload/buildlist.go @@ -386,6 +386,52 @@ func readModGraph(ctx context.Context, pruning modPruning, roots []module.Versio } <-loadQueue.Idle() + // Reload any dependencies of the main modules which are not + // at their selected versions at workspace mode, because the + // requirements don't accurately reflect the transitive imports. + if pruning == workspace { + // hasDepsInAll contains the set of modules that need to be loaded + // at workspace pruning because any of their dependencies may + // provide packages in all. + hasDepsInAll := make(map[string]bool) + seen := map[module.Version]bool{} + for _, m := range roots { + hasDepsInAll[m.Path] = true + seen[m] = true + } + // This loop will terminate because it will call enqueue on each version of + // each dependency of the modules in hasDepsInAll at most once (and only + // calls enqueue on successively increasing versions of each dependency). + for { + needsEnqueueing := map[module.Version]bool{} + for p := range hasDepsInAll { + m := module.Version{Path: p, Version: mg.g.Selected(p)} + reqs, ok := mg.g.RequiredBy(m) + if !ok { + needsEnqueueing[m] = true + continue + } + for _, r := range reqs { + s := module.Version{Path: r.Path, Version: mg.g.Selected(r.Path)} + if cmpVersion(s.Version, r.Version) > 0 && !seen[s] { + needsEnqueueing[s] = true + } + } + } + // add all needs enqueueing to paths we care about + if len(needsEnqueueing) == 0 { + break + } + + for p := range needsEnqueueing { + enqueue(p, workspace) + seen[p] = true + hasDepsInAll[p.Path] = true + } + <-loadQueue.Idle() + } + } + if hasError { return mg, mg.findError() } diff --git a/src/cmd/go/testdata/script/work_prune_all.txt b/src/cmd/go/testdata/script/work_prune_all.txt new file mode 100644 index 0000000000..a7ad9c04af --- /dev/null +++ b/src/cmd/go/testdata/script/work_prune_all.txt @@ -0,0 +1,176 @@ +# This test makes sure workspace mode's handling of the module graph +# is compatible with module pruning. The graph we load from either of +# the workspace modules should be the same, even if their graphs +# don't overlap. +# +# This is the module graph in the test: +# +# example.com/p -> example.com/q v1.0.0 +# example.com/a -> example.com/b v1.0.0 -> example.com/q v1.1.0 -> example.com/w v1.0.0 -> example.com/x v1.0.0 -> example.com/y v1.0.0 +# |-> example.com/z v1.0.0 |-> example.com/z v1.1.0 +# |-> example.com/q v1.0.5 -> example.com/r v1.0.0 +# If we didn't load the whole graph and didn't load the dependencies of b +# when loading p, we would end up loading q v1.0.0, rather than v1.1.0, +# which is selected by MVS. + +go list -m all +stdout 'example.com/w v1.0.0' +stdout 'example.com/q v1.1.0' +stdout 'example.com/z v1.1.0' +stdout 'example.com/x v1.0.0' +! stdout 'example.com/r' +! stdout 'example.com/y' + +-- go.work -- +go 1.18 + +use ( + ./a + ./p +) + +replace example.com/b v1.0.0 => ./b +replace example.com/q v1.0.0 => ./q1_0_0 +replace example.com/q v1.0.5 => ./q1_0_5 +replace example.com/q v1.1.0 => ./q1_1_0 +replace example.com/r v1.0.0 => ./r +replace example.com/w v1.0.0 => ./w +replace example.com/x v1.0.0 => ./x +replace example.com/y v1.0.0 => ./y +replace example.com/z v1.0.0 => ./z1_0_0 +replace example.com/z v1.1.0 => ./z1_1_0 + +-- a/go.mod -- +module example.com/a + +go 1.18 + +require example.com/b v1.0.0 +require example.com/z v1.0.0 +-- a/foo.go -- +package main + +import "example.com/b" + +func main() { + b.B() +} +-- b/go.mod -- +module example.com/b + +go 1.18 + +require example.com/q v1.1.0 +-- b/b.go -- +package b + +func B() { +} +-- p/go.mod -- +module example.com/p + +go 1.18 + +require example.com/q v1.0.0 + +replace example.com/q v1.0.0 => ../q1_0_0 +replace example.com/q v1.1.0 => ../q1_1_0 +-- p/main.go -- +package main + +import "example.com/q" + +func main() { + q.PrintVersion() +} +-- q1_0_0/go.mod -- +module example.com/q + +go 1.18 +-- q1_0_0/q.go -- +package q + +import "fmt" + +func PrintVersion() { + fmt.Println("version 1.0.0") +} +-- q1_0_5/go.mod -- +module example.com/q + +go 1.18 + +require example.com/r v1.0.0 +-- q1_0_5/q.go -- +package q + +import _ "example.com/r" +-- q1_1_0/go.mod -- +module example.com/q + +require example.com/w v1.0.0 +require example.com/z v1.1.0 + +go 1.18 +-- q1_1_0/q.go -- +package q + +import _ "example.com/w" +import _ "example.com/z" + +import "fmt" + +func PrintVersion() { + fmt.Println("version 1.1.0") +} +-- r/go.mod -- +module example.com/r + +go 1.18 + +require example.com/r v1.0.0 +-- r/r.go -- +package r +-- w/go.mod -- +module example.com/w + +go 1.18 + +require example.com/x v1.0.0 +-- w/w.go -- +package w +-- w/w_test.go -- +package w + +import _ "example.com/x" +-- x/go.mod -- +module example.com/x + +go 1.18 +-- x/x.go -- +package x +-- x/x_test.go -- +package x +import _ "example.com/y" +-- y/go.mod -- +module example.com/y + +go 1.18 +-- y/y.go -- +package y +-- z1_0_0/go.mod -- +module example.com/z + +go 1.18 + +require example.com/q v1.0.5 +-- z1_0_0/z.go -- +package z + +import _ "example.com/q" +-- z1_1_0/go.mod -- +module example.com/z + +go 1.18 +-- z1_1_0/z.go -- +package z From ae695cd93fc7d2aadeb3636002fd77f35bfa0710 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Thu, 16 Dec 2021 15:15:32 -0500 Subject: [PATCH 509/752] cmd/go: add missing cgo condition in TestScript/mod_list_compiled_concurrent Updates #50205 Change-Id: I60d2e32c2cd84599f4a0126e4da4f1d61bd29b51 Reviewed-on: https://go-review.googlesource.com/c/go/+/372799 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/cmd/go/testdata/script/mod_list_compiled_concurrent.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/src/cmd/go/testdata/script/mod_list_compiled_concurrent.txt b/src/cmd/go/testdata/script/mod_list_compiled_concurrent.txt index b08713dcfd..896bbab9fc 100644 --- a/src/cmd/go/testdata/script/mod_list_compiled_concurrent.txt +++ b/src/cmd/go/testdata/script/mod_list_compiled_concurrent.txt @@ -1,6 +1,7 @@ env GO111MODULE=on [short] skip +[!cgo] skip # Regression test for golang.org/issue/29667: # spurious 'failed to cache compiled Go files' errors. From d93677ad7e40d66c2ec5c5e75c984533db00b5ee Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Thu, 16 Dec 2021 10:22:37 -0500 Subject: [PATCH 510/752] net/http/pprof: skip TestDeltaProfile on openbsd/arm It is observed to be flaky on the only openbsd/arm builder. Skipping on that platform until someone can investigate. For #50218 Change-Id: Id3a6dc12b93b3cec67870d8d81bd608c4589c952 Reviewed-on: https://go-review.googlesource.com/c/go/+/372794 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Hyang-Ah Hana Kim TryBot-Result: Gopher Robot --- src/net/http/pprof/pprof_test.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/net/http/pprof/pprof_test.go b/src/net/http/pprof/pprof_test.go index 84757e401a..1a4d653a62 100644 --- a/src/net/http/pprof/pprof_test.go +++ b/src/net/http/pprof/pprof_test.go @@ -8,6 +8,7 @@ import ( "bytes" "fmt" "internal/profile" + "internal/testenv" "io" "net/http" "net/http/httptest" @@ -152,6 +153,10 @@ func mutexHog(duration time.Duration, hogger func(mu1, mu2 *sync.Mutex, start ti } func TestDeltaProfile(t *testing.T) { + if runtime.GOOS == "openbsd" && runtime.GOARCH == "arm" { + testenv.SkipFlaky(t, 50218) + } + rate := runtime.SetMutexProfileFraction(1) defer func() { runtime.SetMutexProfileFraction(rate) From d01cd8fa1dc6110cbb301fd711fe43ea744cb5c9 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 3 Dec 2021 10:33:02 -0500 Subject: [PATCH 511/752] misc/cgo/testcarchive: log command output more consistently Also check that executables exist immediately after building them in parallel tests. The parallel tests in this package occasionally fail with "no such file or directory", implying that either the build command failed to actually write out the binary or something concurrently deleted it. This is purely a shot in the dark, but I'm hoping that perhaps the stderr output from one of these commands will shed some light on the underlying failure mode. For #49693 Change-Id: I2e768190c56053550879b89a3ac88c027d4741dd Reviewed-on: https://go-review.googlesource.com/c/go/+/369034 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Ian Lance Taylor TryBot-Result: Gopher Robot --- misc/cgo/testcarchive/carchive_test.go | 118 ++++++++++++++++--------- 1 file changed, 76 insertions(+), 42 deletions(-) diff --git a/misc/cgo/testcarchive/carchive_test.go b/misc/cgo/testcarchive/carchive_test.go index a2b43bb72d..c5193e3f19 100644 --- a/misc/cgo/testcarchive/carchive_test.go +++ b/misc/cgo/testcarchive/carchive_test.go @@ -10,6 +10,7 @@ import ( "debug/elf" "flag" "fmt" + "io/fs" "log" "os" "os/exec" @@ -245,6 +246,29 @@ func testInstall(t *testing.T, exe, libgoa, libgoh string, buildcmd ...string) { var badLineRegexp = regexp.MustCompile(`(?m)^#line [0-9]+ "/.*$`) +// checkIsExecutable verifies that exe exists and has execute permission. +// +// (https://golang.org/issue/49693 notes failures with "no such file or +// directory", so we want to double-check that the executable actually exists +// immediately after we build it in order to better understand that failure +// mode.) +func checkIsExecutable(t *testing.T, exe string) { + t.Helper() + fi, err := os.Stat(exe) + if err != nil { + t.Fatal(err) + } + if runtime.GOOS == "windows" { + // os.File doesn't check the "execute" permission on Windows files + // and as a result doesn't set that bit in a file's permissions. + // Assume that if the file exists it is “executable enough”. + return + } + if fi.Mode()&0111 == 0 { + t.Fatalf("%s is not executable: %0o", exe, fi.Mode()&fs.ModePerm) + } +} + // checkLineComments checks that the export header generated by // -buildmode=c-archive doesn't have any absolute paths in the #line // comments. We don't want those paths because they are unhelpful for @@ -310,7 +334,7 @@ func TestEarlySignalHandler(t *testing.T) { defer func() { os.Remove("libgo2.a") os.Remove("libgo2.h") - os.Remove("testp") + os.Remove("testp" + exeSuffix) os.RemoveAll(filepath.Join(GOPATH, "pkg")) }() } @@ -350,7 +374,7 @@ func TestSignalForwarding(t *testing.T) { defer func() { os.Remove("libgo2.a") os.Remove("libgo2.h") - os.Remove("testp") + os.Remove("testp" + exeSuffix) os.RemoveAll(filepath.Join(GOPATH, "pkg")) }() } @@ -374,7 +398,7 @@ func TestSignalForwarding(t *testing.T) { cmd = exec.Command(bin[0], append(bin[1:], "1")...) out, err := cmd.CombinedOutput() - t.Logf("%s", out) + t.Logf("%v\n%s", cmd.Args, out) expectSignal(t, err, syscall.SIGSEGV) // SIGPIPE is never forwarded on darwin. See golang.org/issue/33384. @@ -383,7 +407,9 @@ func TestSignalForwarding(t *testing.T) { cmd = exec.Command(bin[0], append(bin[1:], "3")...) out, err = cmd.CombinedOutput() - t.Logf("%s", out) + if len(out) > 0 { + t.Logf("%s", out) + } expectSignal(t, err, syscall.SIGPIPE) } } @@ -400,7 +426,7 @@ func TestSignalForwardingExternal(t *testing.T) { defer func() { os.Remove("libgo2.a") os.Remove("libgo2.h") - os.Remove("testp") + os.Remove("testp" + exeSuffix) os.RemoveAll(filepath.Join(GOPATH, "pkg")) }() } @@ -517,7 +543,7 @@ func TestOsSignal(t *testing.T) { defer func() { os.Remove("libgo3.a") os.Remove("libgo3.h") - os.Remove("testp") + os.Remove("testp" + exeSuffix) os.RemoveAll(filepath.Join(GOPATH, "pkg")) }() } @@ -554,7 +580,7 @@ func TestSigaltstack(t *testing.T) { defer func() { os.Remove("libgo4.a") os.Remove("libgo4.h") - os.Remove("testp") + os.Remove("testp" + exeSuffix) os.RemoveAll(filepath.Join(GOPATH, "pkg")) }() } @@ -747,8 +773,9 @@ func TestSIGPROF(t *testing.T) { } cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo6.a", "./libgo6") - if out, err := cmd.CombinedOutput(); err != nil { - t.Logf("%s", out) + out, err := cmd.CombinedOutput() + t.Logf("%v\n%s", cmd.Args, out) + if err != nil { t.Fatal(err) } checkLineComments(t, "libgo6.h") @@ -757,15 +784,18 @@ func TestSIGPROF(t *testing.T) { if runtime.Compiler == "gccgo" { ccArgs = append(ccArgs, "-lgo") } - if out, err := exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput(); err != nil { - t.Logf("%s", out) + out, err = exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput() + t.Logf("%v\n%s", ccArgs, out) + if err != nil { t.Fatal(err) } + checkIsExecutable(t, "./testp6"+exeSuffix) argv := cmdToRun("./testp6") cmd = exec.Command(argv[0], argv[1:]...) - if out, err := cmd.CombinedOutput(); err != nil { - t.Logf("%s", out) + out, err = cmd.CombinedOutput() + t.Logf("%v\n%s", argv, out) + if err != nil { t.Fatal(err) } } @@ -788,9 +818,8 @@ func TestCompileWithoutShared(t *testing.T) { } cmd := exec.Command("go", "build", "-buildmode=c-archive", "-gcflags=-shared=false", "-o", "libgo2.a", "./libgo2") - t.Log(cmd.Args) out, err := cmd.CombinedOutput() - t.Logf("%s", out) + t.Logf("%v\n%s", cmd.Args, out) if err != nil { t.Fatal(err) } @@ -804,23 +833,22 @@ func TestCompileWithoutShared(t *testing.T) { if runtime.Compiler == "gccgo" { ccArgs = append(ccArgs, "-lgo") } - t.Log(ccArgs) out, err = exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput() + t.Logf("%v\n%s", ccArgs, out) // If -no-pie unrecognized, try -nopie if this is possibly clang if err != nil && bytes.Contains(out, []byte("unknown")) && !strings.Contains(cc[0], "gcc") { ccArgs = append(cc, "-o", exe, "-nopie", "main5.c", "libgo2.a") - t.Log(ccArgs) out, err = exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput() + t.Logf("%v\n%s", ccArgs, out) } // Don't use either -no-pie or -nopie if err != nil && bytes.Contains(out, []byte("unrecognized")) { - ccArgs := append(cc, "-o", exe, "main5.c", "libgo2.a") - t.Log(ccArgs) + ccArgs = append(cc, "-o", exe, "main5.c", "libgo2.a") out, err = exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput() + t.Logf("%v\n%s", ccArgs, out) } - t.Logf("%s", out) if err != nil { t.Fatal(err) } @@ -829,17 +857,15 @@ func TestCompileWithoutShared(t *testing.T) { } binArgs := append(cmdToRun(exe), "1") - t.Log(binArgs) out, err = exec.Command(binArgs[0], binArgs[1:]...).CombinedOutput() - t.Logf("%s", out) + t.Logf("%v\n%s", binArgs, out) expectSignal(t, err, syscall.SIGSEGV) // SIGPIPE is never forwarded on darwin. See golang.org/issue/33384. if runtime.GOOS != "darwin" && runtime.GOOS != "ios" { binArgs := append(cmdToRun(exe), "3") - t.Log(binArgs) out, err = exec.Command(binArgs[0], binArgs[1:]...).CombinedOutput() - t.Logf("%s", out) + t.Logf("%v\n%s", binArgs, out) expectSignal(t, err, syscall.SIGPIPE) } } @@ -894,8 +920,9 @@ func TestManyCalls(t *testing.T) { } cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo7.a", "./libgo7") - if out, err := cmd.CombinedOutput(); err != nil { - t.Logf("%s", out) + out, err := cmd.CombinedOutput() + t.Logf("%v\n%s", cmd.Args, out) + if err != nil { t.Fatal(err) } checkLineComments(t, "libgo7.h") @@ -904,16 +931,18 @@ func TestManyCalls(t *testing.T) { if runtime.Compiler == "gccgo" { ccArgs = append(ccArgs, "-lgo") } - if out, err := exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput(); err != nil { - t.Logf("%s", out) + out, err = exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput() + t.Logf("%v\n%s", ccArgs, out) + if err != nil { t.Fatal(err) } + checkIsExecutable(t, "./testp7"+exeSuffix) argv := cmdToRun("./testp7") cmd = exec.Command(argv[0], argv[1:]...) - var sb strings.Builder - cmd.Stdout = &sb - cmd.Stderr = &sb + sb := new(strings.Builder) + cmd.Stdout = sb + cmd.Stderr = sb if err := cmd.Start(); err != nil { t.Fatal(err) } @@ -926,8 +955,9 @@ func TestManyCalls(t *testing.T) { ) defer timer.Stop() - if err := cmd.Wait(); err != nil { - t.Log(sb.String()) + err = cmd.Wait() + t.Logf("%v\n%s", cmd.Args, sb) + if err != nil { t.Error(err) } } @@ -949,23 +979,26 @@ func TestPreemption(t *testing.T) { } cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo8.a", "./libgo8") - if out, err := cmd.CombinedOutput(); err != nil { - t.Logf("%s", out) + out, err := cmd.CombinedOutput() + t.Logf("%v\n%s", cmd.Args, out) + if err != nil { t.Fatal(err) } checkLineComments(t, "libgo8.h") ccArgs := append(cc, "-o", "testp8"+exeSuffix, "main8.c", "libgo8.a") - if out, err := exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput(); err != nil { - t.Logf("%s", out) + out, err = exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput() + t.Logf("%v\n%s", ccArgs, out) + if err != nil { t.Fatal(err) } + checkIsExecutable(t, "./testp8"+exeSuffix) argv := cmdToRun("./testp8") cmd = exec.Command(argv[0], argv[1:]...) - var sb strings.Builder - cmd.Stdout = &sb - cmd.Stderr = &sb + sb := new(strings.Builder) + cmd.Stdout = sb + cmd.Stderr = sb if err := cmd.Start(); err != nil { t.Fatal(err) } @@ -978,8 +1011,9 @@ func TestPreemption(t *testing.T) { ) defer timer.Stop() - if err := cmd.Wait(); err != nil { - t.Log(sb.String()) + err = cmd.Wait() + t.Logf("%v\n%s", cmd.Args, sb) + if err != nil { t.Error(err) } } From b1a53ece68d46e4fb59c74d2bc529060861f5dbf Mon Sep 17 00:00:00 2001 From: Andre Marianiello Date: Tue, 14 Dec 2021 22:50:28 +0000 Subject: [PATCH 512/752] cmd/go/internal/vcs: prevent Git signatures from breaking commit time parsing When a user has showSignature=true set in their Git config and the commit in question has a signature, the git-show command will output information about that signature. When this happens, the logic that tries to parsing a timestamp from the git-show output chokes on this signature information and the build stamping fails. This change prevents commit signature information from being displayed even if showSignature=true, preventing this issue. Change-Id: I98d0a6fdd1e90dd1b91e0394713b6eb286a69d1a GitHub-Last-Rev: 610706e23e33a037b9abede2ba0a926c0f336814 GitHub-Pull-Request: golang/go#49790 Reviewed-on: https://go-review.googlesource.com/c/go/+/367034 Trust: Cherry Mui Reviewed-by: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot --- src/cmd/go/internal/vcs/vcs.go | 2 +- .../script/version_buildvcs_git_gpg.txt | 105 ++++++++++++++++++ 2 files changed, 106 insertions(+), 1 deletion(-) create mode 100644 src/cmd/go/testdata/script/version_buildvcs_git_gpg.txt diff --git a/src/cmd/go/internal/vcs/vcs.go b/src/cmd/go/internal/vcs/vcs.go index 313dc62b78..36404533c5 100644 --- a/src/cmd/go/internal/vcs/vcs.go +++ b/src/cmd/go/internal/vcs/vcs.go @@ -309,7 +309,7 @@ func gitStatus(vcsGit *Cmd, rootDir string) (Status, error) { // uncommitted files and skip tagging revision / committime. var rev string var commitTime time.Time - out, err = vcsGit.runOutputVerboseOnly(rootDir, "show -s --format=%H:%ct") + out, err = vcsGit.runOutputVerboseOnly(rootDir, "show -s --no-show-signature --format=%H:%ct") if err != nil && !uncommitted { return Status{}, err } else if err == nil { diff --git a/src/cmd/go/testdata/script/version_buildvcs_git_gpg.txt b/src/cmd/go/testdata/script/version_buildvcs_git_gpg.txt new file mode 100644 index 0000000000..6d429c5a52 --- /dev/null +++ b/src/cmd/go/testdata/script/version_buildvcs_git_gpg.txt @@ -0,0 +1,105 @@ +# This test checks that VCS information is stamped into Go binaries even when +# the current commit is signed and the use has configured git to display commit +# signatures. + +[!exec:git] skip +[!exec:gpg] skip +[short] skip +env GOBIN=$GOPATH/bin +env GNUPGHOME=$WORK/.gpupg +mkdir $GNUPGHOME +chmod 0700 $GNUPGHOME + +# Create GPG key +exec gpg --batch --passphrase '' --quick-generate-key gopher@golang.org +exec gpg --list-secret-keys --with-colons gopher@golang.org +cp stdout keyinfo.txt +go run extract_key_id.go keyinfo.txt +cp stdout keyid.txt + +# Initialize repo +cd repo/ +exec git init +exec git config user.email gopher@golang.org +exec git config user.name 'J.R. Gopher' +exec git config --add log.showSignature true +go run ../configure_signing_key.go ../keyid.txt + +# Create signed commit +cd a +exec git add -A +exec git commit -m 'initial commit' --gpg-sign +exec git log + +# Verify commit signature does not interfere with versioning +go install +go version -m $GOBIN/a +stdout '^\tbuild\tgitrevision\t' +stdout '^\tbuild\tgitcommittime\t' +stdout '^\tbuild\tgituncommitted\tfalse$' + +-- repo/README -- +Far out in the uncharted backwaters of the unfashionable end of the western +spiral arm of the Galaxy lies a small, unregarded yellow sun. +-- repo/a/go.mod -- +module example.com/a + +go 1.18 +-- repo/a/a.go -- +package main + +func main() {} + +-- extract_key_id.go -- +package main + +import "fmt" +import "io/ioutil" +import "os" +import "strings" + +func main() { + err := run(os.Args[1]) + if err != nil { + panic(err) + } +} + +func run(keyInfoFilePath string) error { + contents, err := ioutil.ReadFile(keyInfoFilePath) + if err != nil { + return err + } + lines := strings.Split(string(contents), "\n") + for _, line := range lines { + fields := strings.Split(line, ":") + if fields[0] == "sec" { + fmt.Print(fields[4]) + return nil + } + } + return fmt.Errorf("key ID not found in: %s", keyInfoFilePath) +} + +-- configure_signing_key.go -- +package main + +import "io/ioutil" +import "os" +import "os/exec" + +func main() { + err := run(os.Args[1]) + if err != nil { + panic(err) + } +} + +func run(keyIdFilePath string) error { + keyId, err := ioutil.ReadFile(keyIdFilePath) + if err != nil { + return err + } + gitCmd := exec.Command("git", "config", "user.signingKey", string(keyId)) + return gitCmd.Run() +} From 1387b5e91d76ba6727a7434c06f7c368d6c53d5c Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Thu, 16 Dec 2021 13:24:40 -0800 Subject: [PATCH 513/752] cmd/compile: only avoid escaping package paths for "go.shape" We have code that intends to avoid escaping the package path for built-in packages. But it is hard to determine which packages are built-in from a general rule, and we really only want to avoid escaping for the "go.shape" package (since that gives ugly shape type names). So, fix the code to only avoid escaping the package path specifically for the "go.shape" package. Fixes #50200 Change-Id: Ibaedd7690b99a173007c608c5dfa783ef82b326d Reviewed-on: https://go-review.googlesource.com/c/go/+/372934 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: Keith Randall Reviewed-by: Cherry Mui --- src/cmd/compile/internal/types/pkg.go | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/cmd/compile/internal/types/pkg.go b/src/cmd/compile/internal/types/pkg.go index 0b822a450c..b159eb5eeb 100644 --- a/src/cmd/compile/internal/types/pkg.go +++ b/src/cmd/compile/internal/types/pkg.go @@ -9,7 +9,6 @@ import ( "cmd/internal/objabi" "fmt" "sort" - "strings" "sync" ) @@ -49,9 +48,11 @@ func NewPkg(path, name string) *Pkg { p := new(Pkg) p.Path = path p.Name = name - if strings.HasPrefix(path, "go.") && !strings.Contains(path, "/") { - // Special compiler-internal packages don't need to be escaped. - // This particularly helps with the go.shape package. + if path == "go.shape" { + // Don't escape "go.shape", since it's not needed (it's a builtin + // package), and we don't want escape codes showing up in shape type + // names, which also appear in names of function/method + // instantiations. p.Prefix = path } else { p.Prefix = objabi.PathToPrefix(path) From 0c24038d22a83c0da5feb3d700b13445f47b24c9 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Wed, 15 Dec 2021 15:07:22 -0500 Subject: [PATCH 514/752] cmd/go: update go work docs Change-Id: If28cc02a5a6f9bf2c7f2550de77ca0b31c1b35ee Reviewed-on: https://go-review.googlesource.com/c/go/+/372494 Trust: Michael Matloob Run-TryBot: Michael Matloob Reviewed-by: Bryan Mills --- src/cmd/go/alldocs.go | 100 +++++++++++++++++++++------- src/cmd/go/internal/workcmd/init.go | 20 +++--- src/cmd/go/internal/workcmd/sync.go | 25 +++++-- src/cmd/go/internal/workcmd/use.go | 18 +++-- src/cmd/go/internal/workcmd/work.go | 54 ++++++++++++--- 5 files changed, 158 insertions(+), 59 deletions(-) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index 6703792054..d90321414a 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -1372,21 +1372,53 @@ // // Go workspace provides access to operations on workspaces. // -// Note that support for workspaces is built into many other commands, -// not just 'go work'. +// Note that support for workspaces is built into many other commands, not +// just 'go work'. // -// See 'go help modules' for information about Go's module system of -// which workspaces are a part. +// See 'go help modules' for information about Go's module system of which +// workspaces are a part. // // A workspace is specified by a go.work file that specifies a set of -// module directories with the "use" directive. These modules are used -// as root modules by the go command for builds and related operations. -// A workspace that does not specify modules to be used cannot be used -// to do builds from local modules. +// module directories with the "use" directive. These modules are used as +// root modules by the go command for builds and related operations. A +// workspace that does not specify modules to be used cannot be used to do +// builds from local modules. // -// To determine whether the go command is operating in workspace mode, -// use the "go env GOWORK" command. This will specify the workspace -// file being used. +// go.work files are line-oriented. Each line holds a single directive, +// made up of a keyword followed by aruments. For example: +// +// go 1.18 +// +// use ../foo/bar +// use ./baz +// +// replace example.com/foo v1.2.3 => example.com/bar v1.4.5 +// +// The leading keyword can be factored out of adjacent lines to create a block, +// like in Go imports. +// +// use ( +// ../foo/bar +// ./baz +// ) +// +// The use directive specifies a module to be included in the workspace's +// set of main modules. The argument to the use directive is the directory +// containing the module's go.mod file. +// +// The go directive specifies the version of Go the file was written at. It +// is possible there may be future changes in the semantics of workspaces +// that could be controlled by this version, but for now the version +// specified has no effect. +// +// The replace directive has the same syntax as the replace directive in a +// go.mod file and takes precedence over replaces in go.mod files. It is +// primarily intended to override conflicting replaces in different workspace +// modules. +// +// To determine whether the go command is operating in workspace mode, use +// the "go env GOWORK" command. This will specify the workspace file being +// used. // // Usage: // @@ -1478,24 +1510,39 @@ // // go work init [moddirs] // -// Init initializes and writes a new go.work file in the current -// directory, in effect creating a new workspace at the current directory. +// Init initializes and writes a new go.work file in the +// current directory, in effect creating a new workspace at the current +// directory. // -// go work init optionally accepts paths to the workspace modules as arguments. -// If the argument is omitted, an empty workspace with no modules will be created. +// go work init optionally accepts paths to the workspace modules as +// arguments. If the argument is omitted, an empty workspace with no +// modules will be created. // -// See the workspaces design proposal at -// https://go.googlesource.com/proposal/+/master/design/45713-workspace.md for -// more information. +// Each argument path is added to a use directive in the go.work file. The +// current go version will also be listed in the go.work file. // // // Sync workspace build list to modules // // Usage: // -// go work sync [moddirs] +// go work sync // -// go work sync +// Sync syncs the workspace's build list back to the +// workspace's modules +// +// The workspace's build list is the set of versions of all the +// (transitive) dependency modules used to do builds in the workspace. go +// work sync generates that build list using the Minimal Version Selection +// algorithm, and then syncs those versions back to each of modules +// specified in the workspace (with use directives). +// +// The syncing is done by sequentially upgrading each of the dependency +// modules specified in a workspace module to the version in the build list +// if the dependency module's version is not already the same as the build +// list's version. Note that Minimal Version Selection guarantees that the +// build list's version of each module is always the same or higher than +// that in each workspace module. // // // Add modules to workspace file @@ -1504,10 +1551,17 @@ // // go work use [-r] [moddirs] // -// Use provides a command-line interface for adding directories, -// optionally recursively, to a go.work file. +// Use provides a command-line interface for adding +// directories, optionally recursively, to a go.work file. // -// The -r flag searches recursively for modules in the argument directories. +// A use directive will be added to the go.work file for each argument +// directory listed on the command line go.work file, if it exists on disk, +// or removed from the go.work file if it does not exist on disk. +// +// The -r flag searches recursively for modules in the argument +// directories, and the use command operates as if each of the directories +// were specified as arguments: namely, use directives will be added for +// directories that exist, and removed for directories that do not exist. // // // Compile and run Go program diff --git a/src/cmd/go/internal/workcmd/init.go b/src/cmd/go/internal/workcmd/init.go index 2297ac20d0..cefecee832 100644 --- a/src/cmd/go/internal/workcmd/init.go +++ b/src/cmd/go/internal/workcmd/init.go @@ -13,22 +13,20 @@ import ( "path/filepath" ) -// TODO(#49232) Add more documentation below. Though this is -// enough for those trying workspaces out, there should be more through -// documentation before Go 1.18 is released. - var cmdInit = &base.Command{ UsageLine: "go work init [moddirs]", Short: "initialize workspace file", - Long: `Init initializes and writes a new go.work file in the current -directory, in effect creating a new workspace at the current directory. + Long: `Init initializes and writes a new go.work file in the +current directory, in effect creating a new workspace at the current +directory. -go work init optionally accepts paths to the workspace modules as arguments. -If the argument is omitted, an empty workspace with no modules will be created. +go work init optionally accepts paths to the workspace modules as +arguments. If the argument is omitted, an empty workspace with no +modules will be created. + +Each argument path is added to a use directive in the go.work file. The +current go version will also be listed in the go.work file. -See the workspaces design proposal at -https://go.googlesource.com/proposal/+/master/design/45713-workspace.md for -more information. `, Run: runInit, } diff --git a/src/cmd/go/internal/workcmd/sync.go b/src/cmd/go/internal/workcmd/sync.go index 5f33e057f6..a10d15a3b7 100644 --- a/src/cmd/go/internal/workcmd/sync.go +++ b/src/cmd/go/internal/workcmd/sync.go @@ -15,15 +15,26 @@ import ( "golang.org/x/mod/module" ) -// TODO(#49232) Add more documentation below. Though this is -// enough for those trying workspaces out, there should be more thorough -// documentation before Go 1.18 is released. - var cmdSync = &base.Command{ - UsageLine: "go work sync [moddirs]", + UsageLine: "go work sync", Short: "sync workspace build list to modules", - Long: `go work sync`, - Run: runSync, + Long: `Sync syncs the workspace's build list back to the +workspace's modules + +The workspace's build list is the set of versions of all the +(transitive) dependency modules used to do builds in the workspace. go +work sync generates that build list using the Minimal Version Selection +algorithm, and then syncs those versions back to each of modules +specified in the workspace (with use directives). + +The syncing is done by sequentially upgrading each of the dependency +modules specified in a workspace module to the version in the build list +if the dependency module's version is not already the same as the build +list's version. Note that Minimal Version Selection guarantees that the +build list's version of each module is always the same or higher than +that in each workspace module. +`, + Run: runSync, } func init() { diff --git a/src/cmd/go/internal/workcmd/use.go b/src/cmd/go/internal/workcmd/use.go index 97c493685a..852e5b910c 100644 --- a/src/cmd/go/internal/workcmd/use.go +++ b/src/cmd/go/internal/workcmd/use.go @@ -16,17 +16,21 @@ import ( "path/filepath" ) -// TODO(#49232) Add more documentation below. Though this is -// enough for those trying workspaces out, there should be more thorough -// documentation before Go 1.18 is released. - var cmdUse = &base.Command{ UsageLine: "go work use [-r] [moddirs]", Short: "add modules to workspace file", - Long: `Use provides a command-line interface for adding directories, -optionally recursively, to a go.work file. + Long: `Use provides a command-line interface for adding +directories, optionally recursively, to a go.work file. -The -r flag searches recursively for modules in the argument directories.`, +A use directive will be added to the go.work file for each argument +directory listed on the command line go.work file, if it exists on disk, +or removed from the go.work file if it does not exist on disk. + +The -r flag searches recursively for modules in the argument +directories, and the use command operates as if each of the directories +were specified as arguments: namely, use directives will be added for +directories that exist, and removed for directories that do not exist. +`, } var useR = cmdUse.Flag.Bool("r", false, "") diff --git a/src/cmd/go/internal/workcmd/work.go b/src/cmd/go/internal/workcmd/work.go index 3ddbfbe772..5bb0a2e8ba 100644 --- a/src/cmd/go/internal/workcmd/work.go +++ b/src/cmd/go/internal/workcmd/work.go @@ -14,21 +14,53 @@ var CmdWork = &base.Command{ Short: "workspace maintenance", Long: `Go workspace provides access to operations on workspaces. -Note that support for workspaces is built into many other commands, -not just 'go work'. +Note that support for workspaces is built into many other commands, not +just 'go work'. -See 'go help modules' for information about Go's module system of -which workspaces are a part. +See 'go help modules' for information about Go's module system of which +workspaces are a part. A workspace is specified by a go.work file that specifies a set of -module directories with the "use" directive. These modules are used -as root modules by the go command for builds and related operations. -A workspace that does not specify modules to be used cannot be used -to do builds from local modules. +module directories with the "use" directive. These modules are used as +root modules by the go command for builds and related operations. A +workspace that does not specify modules to be used cannot be used to do +builds from local modules. -To determine whether the go command is operating in workspace mode, -use the "go env GOWORK" command. This will specify the workspace -file being used. +go.work files are line-oriented. Each line holds a single directive, +made up of a keyword followed by aruments. For example: + + go 1.18 + + use ../foo/bar + use ./baz + + replace example.com/foo v1.2.3 => example.com/bar v1.4.5 + +The leading keyword can be factored out of adjacent lines to create a block, +like in Go imports. + + use ( + ../foo/bar + ./baz + ) + +The use directive specifies a module to be included in the workspace's +set of main modules. The argument to the use directive is the directory +containing the module's go.mod file. + +The go directive specifies the version of Go the file was written at. It +is possible there may be future changes in the semantics of workspaces +that could be controlled by this version, but for now the version +specified has no effect. + +The replace directive has the same syntax as the replace directive in a +go.mod file and takes precedence over replaces in go.mod files. It is +primarily intended to override conflicting replaces in different workspace +modules. + +To determine whether the go command is operating in workspace mode, use +the "go env GOWORK" command. This will specify the workspace file being +used. `, Commands: []*base.Command{ From 33a1a93a92804205eca89e2bb113ca68c1de5a4f Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 8 Dec 2021 20:32:29 -0800 Subject: [PATCH 515/752] cmd/compile/internal/syntax: fix parsing of type parameter lists The parser cannot distinguish a type parameter list of the form [P *T ] or [P (T)] where T is not a type literal from an array length specification P*T (product) or P(T) (constant-valued function call) and thus interprets these forms as the start of array types. This ambiguity must be resolved explicitly by placing *T inside an interface, adding a trailing comma, or by leaving parentheses away where possible. This CL adjusts the parser such that these forms are interpreted as (the beginning) of type parameter lists if the token after P*T or P(T) is a comma, or if T is a type literal. This CL also adjusts the printer to print a comma if necessary to avoid this ambiguity, and adds additional printer tests. Fixes #49482 Change-Id: I36328e2a7d9439c39ba0349837c445542549e84e Reviewed-on: https://go-review.googlesource.com/c/go/+/370774 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/syntax/parser.go | 149 ++++++++++++++---- src/cmd/compile/internal/syntax/printer.go | 55 ++++--- .../compile/internal/syntax/printer_test.go | 77 +++++---- .../internal/syntax/testdata/issue49482.go2 | 31 ++++ 4 files changed, 227 insertions(+), 85 deletions(-) create mode 100644 src/cmd/compile/internal/syntax/testdata/issue49482.go2 diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go index 770175fe54..40c5eca408 100644 --- a/src/cmd/compile/internal/syntax/parser.go +++ b/src/cmd/compile/internal/syntax/parser.go @@ -588,44 +588,81 @@ func (p *parser) typeDecl(group *Group) Decl { d.Name = p.name() if p.allowGenerics() && p.tok == _Lbrack { // d.Name "[" ... - // array/slice or type parameter list + // array/slice type or type parameter list pos := p.pos() p.next() switch p.tok { case _Name: - // d.Name "[" name ... - // array or type parameter list - name := p.name() - // Index or slice expressions are never constant and thus invalid - // array length expressions. Thus, if we see a "[" following name - // we can safely assume that "[" name starts a type parameter list. - var x Expr // x != nil means x is the array length expression + // We may have an array type or a type parameter list. + // In either case we expect an expression x (which may + // just be a name, or a more complex expression) which + // we can analyze further. + // + // A type parameter list may have a type bound starting + // with a "[" as in: P []E. In that case, simply parsing + // an expression would lead to an error: P[] is invalid. + // But since index or slice expressions are never constant + // and thus invalid array length expressions, if we see a + // "[" following a name it must be the start of an array + // or slice constraint. Only if we don't see a "[" do we + // need to parse a full expression. + var x Expr = p.name() if p.tok != _Lbrack { - // d.Name "[" name ... - // If we reach here, the next token is not a "[", and we need to - // parse the expression starting with name. If that expression is - // just that name, not followed by a "]" (in which case we might - // have the array length "[" name "]"), we can also safely assume - // a type parameter list. + // To parse the expression starting with name, expand + // the call sequence we would get by passing in name + // to parser.expr, and pass in name to parser.pexpr. p.xnest++ - // To parse the expression starting with name, expand the call - // sequence we would get by passing in name to parser.expr, and - // pass in name to parser.pexpr. - x = p.binaryExpr(p.pexpr(name, false), 0) + x = p.binaryExpr(p.pexpr(x, false), 0) p.xnest-- - if x == name && p.tok != _Rbrack { - x = nil + } + + // analyze the cases + var pname *Name // pname != nil means pname is the type parameter name + var ptype Expr // ptype != nil means ptype is the type parameter type; pname != nil in this case + switch t := x.(type) { + case *Name: + // Unless we see a "]", we are at the start of a type parameter list. + if p.tok != _Rbrack { + // d.Name "[" name ... + pname = t + // no ptype + } + case *Operation: + // If we have an expression of the form name*T, and T is a (possibly + // parenthesized) type literal or the next token is a comma, we are + // at the start of a type parameter list. + if name, _ := t.X.(*Name); name != nil { + if t.Op == Mul && (isTypeLit(t.Y) || p.tok == _Comma) { + // d.Name "[" name "*" t.Y + // d.Name "[" name "*" t.Y "," + t.X, t.Y = t.Y, nil // convert t into unary *t.Y + pname = name + ptype = t + } + } + case *CallExpr: + // If we have an expression of the form name(T), and T is a (possibly + // parenthesized) type literal or the next token is a comma, we are + // at the start of a type parameter list. + if name, _ := t.Fun.(*Name); name != nil { + if len(t.ArgList) == 1 && !t.HasDots && (isTypeLit(t.ArgList[0]) || p.tok == _Comma) { + // d.Name "[" name "(" t.ArgList[0] ")" + // d.Name "[" name "(" t.ArgList[0] ")" "," + pname = name + ptype = t.ArgList[0] + } } } - if x == nil { - // d.Name "[" name ... - // type parameter list - d.TParamList = p.paramList(name, _Rbrack, true) + + if pname != nil { + // d.Name "[" pname ... + // d.Name "[" pname ptype ... + // d.Name "[" pname ptype "," ... + d.TParamList = p.paramList(pname, ptype, _Rbrack, true) d.Alias = p.gotAssign() d.Type = p.typeOrNil() } else { - // d.Name "[" x "]" ... - // x is the array length expression + // d.Name "[" x ... d.Type = p.arrayType(pos, x) } case _Rbrack: @@ -650,6 +687,21 @@ func (p *parser) typeDecl(group *Group) Decl { return d } +// isTypeLit reports whether x is a (possibly parenthesized) type literal. +func isTypeLit(x Expr) bool { + switch x := x.(type) { + case *ArrayType, *StructType, *FuncType, *InterfaceType, *SliceType, *MapType, *ChanType: + return true + case *Operation: + // *T may be a pointer dereferenciation. + // Only consider *T as type literal if T is a type literal. + return x.Op == Mul && x.Y == nil && isTypeLit(x.X) + case *ParenExpr: + return isTypeLit(x.X) + } + return false +} + // VarSpec = IdentifierList ( Type [ "=" ExpressionList ] | "=" ExpressionList ) . func (p *parser) varDecl(group *Group) Decl { if trace { @@ -689,7 +741,7 @@ func (p *parser) funcDeclOrNil() *FuncDecl { f.Pragma = p.takePragma() if p.got(_Lparen) { - rcvr := p.paramList(nil, _Rparen, false) + rcvr := p.paramList(nil, nil, _Rparen, false) switch len(rcvr) { case 0: p.error("method has no receiver") @@ -1369,12 +1421,12 @@ func (p *parser) funcType(context string) ([]*Field, *FuncType) { p.syntaxError("empty type parameter list") p.next() } else { - tparamList = p.paramList(nil, _Rbrack, true) + tparamList = p.paramList(nil, nil, _Rbrack, true) } } p.want(_Lparen) - typ.ParamList = p.paramList(nil, _Rparen, false) + typ.ParamList = p.paramList(nil, nil, _Rparen, false) typ.ResultList = p.funcResult() return tparamList, typ @@ -1392,6 +1444,13 @@ func (p *parser) arrayType(pos Pos, len Expr) Expr { len = p.expr() p.xnest-- } + if p.tok == _Comma { + // Trailing commas are accepted in type parameter + // lists but not in array type declarations. + // Accept for better error handling but complain. + p.syntaxError("unexpected comma; expecting ]") + p.next() + } p.want(_Rbrack) t := new(ArrayType) t.pos = pos @@ -1516,7 +1575,7 @@ func (p *parser) funcResult() []*Field { } if p.got(_Lparen) { - return p.paramList(nil, _Rparen, false) + return p.paramList(nil, nil, _Rparen, false) } pos := p.pos() @@ -1742,7 +1801,7 @@ func (p *parser) methodDecl() *Field { // A type argument list looks like a parameter list with only // types. Parse a parameter list and decide afterwards. - list := p.paramList(nil, _Rbrack, false) + list := p.paramList(nil, nil, _Rbrack, false) if len(list) == 0 { // The type parameter list is not [] but we got nothing // due to other errors (reported by paramList). Treat @@ -1948,17 +2007,41 @@ func (p *parser) paramDeclOrNil(name *Name, follow token) *Field { // ParameterList = ParameterDecl { "," ParameterDecl } . // "(" or "[" has already been consumed. // If name != nil, it is the first name after "(" or "[". +// If typ != nil, name must be != nil, and (name, typ) is the first field in the list. // In the result list, either all fields have a name, or no field has a name. -func (p *parser) paramList(name *Name, close token, requireNames bool) (list []*Field) { +func (p *parser) paramList(name *Name, typ Expr, close token, requireNames bool) (list []*Field) { if trace { defer p.trace("paramList")() } + // p.list won't invoke its function argument if we're at the end of the + // parameter list. If we have a complete field, handle this case here. + if name != nil && typ != nil && p.tok == close { + p.next() + par := new(Field) + par.pos = name.pos + par.Name = name + par.Type = typ + return []*Field{par} + } + var named int // number of parameters that have an explicit name and type var typed int // number of parameters that have an explicit type end := p.list(_Comma, close, func() bool { - par := p.paramDeclOrNil(name, close) + var par *Field + if typ != nil { + if debug && name == nil { + panic("initial type provided without name") + } + par = new(Field) + par.pos = name.pos + par.Name = name + par.Type = typ + } else { + par = p.paramDeclOrNil(name, close) + } name = nil // 1st name was consumed if present + typ = nil // 1st type was consumed if present if par != nil { if debug && par.Name == nil && par.Type == nil { panic("parameter without name or type") diff --git a/src/cmd/compile/internal/syntax/printer.go b/src/cmd/compile/internal/syntax/printer.go index c8d31799af..11190ab287 100644 --- a/src/cmd/compile/internal/syntax/printer.go +++ b/src/cmd/compile/internal/syntax/printer.go @@ -666,9 +666,7 @@ func (p *printer) printRawNode(n Node) { } p.print(n.Name) if n.TParamList != nil { - p.print(_Lbrack) - p.printFieldList(n.TParamList, nil, _Comma) - p.print(_Rbrack) + p.printParameterList(n.TParamList, true) } p.print(blank) if n.Alias { @@ -700,9 +698,7 @@ func (p *printer) printRawNode(n Node) { } p.print(n.Name) if n.TParamList != nil { - p.print(_Lbrack) - p.printFieldList(n.TParamList, nil, _Comma) - p.print(_Rbrack) + p.printParameterList(n.TParamList, true) } p.printSignature(n.Type) if n.Body != nil { @@ -887,38 +883,47 @@ func (p *printer) printDeclList(list []Decl) { } func (p *printer) printSignature(sig *FuncType) { - p.printParameterList(sig.ParamList) + p.printParameterList(sig.ParamList, false) if list := sig.ResultList; list != nil { p.print(blank) if len(list) == 1 && list[0].Name == nil { p.printNode(list[0].Type) } else { - p.printParameterList(list) + p.printParameterList(list, false) } } } -func (p *printer) printParameterList(list []*Field) { - p.print(_Lparen) - if len(list) > 0 { - for i, f := range list { - if i > 0 { - p.print(_Comma, blank) - } - if f.Name != nil { - p.printNode(f.Name) - if i+1 < len(list) { - f1 := list[i+1] - if f1.Name != nil && f1.Type == f.Type { - continue // no need to print type - } +func (p *printer) printParameterList(list []*Field, types bool) { + open, close := _Lparen, _Rparen + if types { + open, close = _Lbrack, _Rbrack + } + p.print(open) + for i, f := range list { + if i > 0 { + p.print(_Comma, blank) + } + if f.Name != nil { + p.printNode(f.Name) + if i+1 < len(list) { + f1 := list[i+1] + if f1.Name != nil && f1.Type == f.Type { + continue // no need to print type } - p.print(blank) } - p.printNode(f.Type) + p.print(blank) + } + p.printNode(unparen(f.Type)) // no need for (extra) parentheses around parameter types + } + // A type parameter list [P *T] where T is not a type literal requires a comma as in [P *T,] + // so that it's not parsed as [P*T]. + if types && len(list) == 1 { + if t, _ := list[0].Type.(*Operation); t != nil && t.Op == Mul && t.Y == nil && !isTypeLit(t.X) { + p.print(_Comma) } } - p.print(_Rparen) + p.print(close) } func (p *printer) printStmtList(list []Stmt, braces bool) { diff --git a/src/cmd/compile/internal/syntax/printer_test.go b/src/cmd/compile/internal/syntax/printer_test.go index 604f1fc1ca..941af0aeb4 100644 --- a/src/cmd/compile/internal/syntax/printer_test.go +++ b/src/cmd/compile/internal/syntax/printer_test.go @@ -53,54 +53,77 @@ func TestPrintError(t *testing.T) { } } -var stringTests = []string{ - "package p", - "package p; type _ int; type T1 = struct{}; type ( _ *struct{}; T2 = float32 )", +var stringTests = [][2]string{ + dup("package p"), + dup("package p; type _ int; type T1 = struct{}; type ( _ *struct{}; T2 = float32 )"), // generic type declarations - "package p; type _[T any] struct{}", - "package p; type _[A, B, C interface{m()}] struct{}", - "package p; type _[T any, A, B, C interface{m()}, X, Y, Z interface{~int}] struct{}", + dup("package p; type _[T any] struct{}"), + dup("package p; type _[A, B, C interface{m()}] struct{}"), + dup("package p; type _[T any, A, B, C interface{m()}, X, Y, Z interface{~int}] struct{}"), + + dup("package p; type _[P *T,] struct{}"), + dup("package p; type _[P *T, _ any] struct{}"), + {"package p; type _[P (*T),] struct{}", "package p; type _[P *T,] struct{}"}, + {"package p; type _[P (*T), _ any] struct{}", "package p; type _[P *T, _ any] struct{}"}, + {"package p; type _[P (T),] struct{}", "package p; type _[P T] struct{}"}, + {"package p; type _[P (T), _ any] struct{}", "package p; type _[P T, _ any] struct{}"}, + + dup("package p; type _[P *struct{}] struct{}"), + {"package p; type _[P (*struct{})] struct{}", "package p; type _[P *struct{}] struct{}"}, + {"package p; type _[P ([]int)] struct{}", "package p; type _[P []int] struct{}"}, + + dup("package p; type _ [P(T)]struct{}"), + dup("package p; type _ [P((T))]struct{}"), + dup("package p; type _ [P * *T]struct{}"), + dup("package p; type _ [P * T]struct{}"), + dup("package p; type _ [P(*T)]struct{}"), + dup("package p; type _ [P(**T)]struct{}"), + dup("package p; type _ [P * T - T]struct{}"), + + // array type declarations + dup("package p; type _ [P * T]struct{}"), + dup("package p; type _ [P * T - T]struct{}"), // generic function declarations - "package p; func _[T any]()", - "package p; func _[A, B, C interface{m()}]()", - "package p; func _[T any, A, B, C interface{m()}, X, Y, Z interface{~int}]()", + dup("package p; func _[T any]()"), + dup("package p; func _[A, B, C interface{m()}]()"), + dup("package p; func _[T any, A, B, C interface{m()}, X, Y, Z interface{~int}]()"), // methods with generic receiver types - "package p; func (R[T]) _()", - "package p; func (*R[A, B, C]) _()", - "package p; func (_ *R[A, B, C]) _()", + dup("package p; func (R[T]) _()"), + dup("package p; func (*R[A, B, C]) _()"), + dup("package p; func (_ *R[A, B, C]) _()"), // type constraint literals with elided interfaces - "package p; func _[P ~int, Q int | string]() {}", - "package p; func _[P struct{f int}, Q *P]() {}", + dup("package p; func _[P ~int, Q int | string]() {}"), + dup("package p; func _[P struct{f int}, Q *P]() {}"), // channels - "package p; type _ chan chan int", - "package p; type _ chan (<-chan int)", - "package p; type _ chan chan<- int", + dup("package p; type _ chan chan int"), + dup("package p; type _ chan (<-chan int)"), + dup("package p; type _ chan chan<- int"), - "package p; type _ <-chan chan int", - "package p; type _ <-chan <-chan int", - "package p; type _ <-chan chan<- int", + dup("package p; type _ <-chan chan int"), + dup("package p; type _ <-chan <-chan int"), + dup("package p; type _ <-chan chan<- int"), - "package p; type _ chan<- chan int", - "package p; type _ chan<- <-chan int", - "package p; type _ chan<- chan<- int", + dup("package p; type _ chan<- chan int"), + dup("package p; type _ chan<- <-chan int"), + dup("package p; type _ chan<- chan<- int"), // TODO(gri) expand } func TestPrintString(t *testing.T) { - for _, want := range stringTests { - ast, err := Parse(nil, strings.NewReader(want), nil, nil, AllowGenerics) + for _, test := range stringTests { + ast, err := Parse(nil, strings.NewReader(test[0]), nil, nil, AllowGenerics) if err != nil { t.Error(err) continue } - if got := String(ast); got != want { - t.Errorf("%q: got %q", want, got) + if got := String(ast); got != test[1] { + t.Errorf("%q: got %q", test[1], got) } } } diff --git a/src/cmd/compile/internal/syntax/testdata/issue49482.go2 b/src/cmd/compile/internal/syntax/testdata/issue49482.go2 new file mode 100644 index 0000000000..1fc303d169 --- /dev/null +++ b/src/cmd/compile/internal/syntax/testdata/issue49482.go2 @@ -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 p + +type ( + // these need a comma to disambiguate + _[P *T,] struct{} + _[P *T, _ any] struct{} + _[P (*T),] struct{} + _[P (*T), _ any] struct{} + _[P (T),] struct{} + _[P (T), _ any] struct{} + + // these parse as name followed by type + _[P *struct{}] struct{} + _[P (*struct{})] struct{} + _[P ([]int)] struct{} + + // array declarations + _ [P(T)]struct{} + _ [P((T))]struct{} + _ [P * *T] struct{} // this could be a name followed by a type but it makes the rules more complicated + _ [P * T]struct{} + _ [P(*T)]struct{} + _ [P(**T)]struct{} + _ [P * T - T]struct{} + _ [P*T-T /* ERROR unexpected comma */ ,]struct{} + _ [10 /* ERROR unexpected comma */ ,]struct{} +) From c3561dd346262414caff570c05f2403f9688aca0 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 15 Dec 2021 19:50:33 -0800 Subject: [PATCH 516/752] cmd/compile/internal/types2: better error message when using comparable in union Fixes #49602. Change-Id: I3499f8a485a2c8ec8afc74c5ef7b20d42c943a05 Reviewed-on: https://go-review.googlesource.com/c/go/+/372674 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- .../types2/testdata/fixedbugs/issue49602.go2 | 19 +++++++++++++++++++ src/cmd/compile/internal/types2/union.go | 11 ++++++++++- 2 files changed, 29 insertions(+), 1 deletion(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue49602.go2 diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49602.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49602.go2 new file mode 100644 index 0000000000..9edbf14a55 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49602.go2 @@ -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 p + +type M interface { + m() +} + +type C interface { + comparable +} + +type _ interface{ + int | M // ERROR cannot use p\.M in union \(p\.M contains methods\) + int | comparable // ERROR cannot use comparable in union + int | C // ERROR cannot use p\.C in union \(p\.C embeds comparable\) +} diff --git a/src/cmd/compile/internal/types2/union.go b/src/cmd/compile/internal/types2/union.go index 6f66260af4..3c0df04ccd 100644 --- a/src/cmd/compile/internal/types2/union.go +++ b/src/cmd/compile/internal/types2/union.go @@ -108,7 +108,16 @@ func parseUnion(check *Checker, uexpr syntax.Expr) Type { // in the beginning. Embedded interfaces with tilde are excluded above. If we reach // here, we must have at least two terms in the union. if f != nil && !f.typeSet().IsTypeSet() { - check.errorf(tlist[i], "cannot use %s in union (interface contains methods)", t) + switch { + case f.typeSet().NumMethods() != 0: + check.errorf(tlist[i], "cannot use %s in union (%s contains methods)", t, t) + case t.typ == universeComparable.Type(): + check.error(tlist[i], "cannot use comparable in union") + case f.typeSet().comparable: + check.errorf(tlist[i], "cannot use %s in union (%s embeds comparable)", t, t) + default: + panic("not a type set but no methods and not comparable") + } continue // don't report another error for t } From 2e6e9df2c1242274b02b584c617947aeed39c398 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 16 Dec 2021 10:50:34 -0800 Subject: [PATCH 517/752] go/types, types2: use compiler error message for undefined operators For #48712. Change-Id: I1596fe8688f093e0e92cf5b8d5501aac8631324e Reviewed-on: https://go-review.googlesource.com/c/go/+/372894 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/expr.go | 12 ++---------- src/go/types/expr.go | 4 ++-- 2 files changed, 4 insertions(+), 12 deletions(-) diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index 5961f32f37..3e3104abb6 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -73,11 +73,7 @@ func init() { func (check *Checker) op(m opPredicates, x *operand, op syntax.Operator) bool { if pred := m[op]; pred != nil { if !pred(x.typ) { - if check.conf.CompilerErrorMessages { - check.errorf(x, invalidOp+"operator %s not defined on %s", op, x) - } else { - check.errorf(x, invalidOp+"operator %s not defined for %s", op, x) - } + check.errorf(x, invalidOp+"operator %s not defined on %s", op, x) return false } } else { @@ -790,11 +786,7 @@ func (check *Checker) comparison(x, y *operand, op syntax.Operator) { if x.isNil() { typ = y.typ } - if check.conf.CompilerErrorMessages { - err = check.sprintf("operator %s not defined on %s", op, typ) - } else { - err = check.sprintf("operator %s not defined for %s", op, typ) - } + err = check.sprintf("operator %s not defined on %s", op, typ) } } else { err = check.sprintf("mismatched types %s and %s", x.typ, y.typ) diff --git a/src/go/types/expr.go b/src/go/types/expr.go index 452e9ab598..8ddfb8de7e 100644 --- a/src/go/types/expr.go +++ b/src/go/types/expr.go @@ -74,7 +74,7 @@ func init() { func (check *Checker) op(m opPredicates, x *operand, op token.Token) bool { if pred := m[op]; pred != nil { if !pred(x.typ) { - check.invalidOp(x, _UndefinedOp, "operator %s not defined for %s", op, x) + check.invalidOp(x, _UndefinedOp, "operator %s not defined on %s", op, x) return false } } else { @@ -745,7 +745,7 @@ func (check *Checker) comparison(x, y *operand, op token.Token) { if x.isNil() { typ = y.typ } - err = check.sprintf("operator %s not defined for %s", op, typ) + err = check.sprintf("operator %s not defined on %s", op, typ) code = _UndefinedOp } } else { From 63077bfcf563e3f2ef96fa51203ed2fad71a371c Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Thu, 16 Dec 2021 10:40:47 -0500 Subject: [PATCH 518/752] os/exec: skip TestContextCancel on netbsd/arm64 For #42061 Change-Id: I3b4c774ad9e375d4bfef1cfb4336c35ed30a6430 Reviewed-on: https://go-review.googlesource.com/c/go/+/372795 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/os/exec/exec_test.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/os/exec/exec_test.go b/src/os/exec/exec_test.go index 92992a6d66..73aa35f1ae 100644 --- a/src/os/exec/exec_test.go +++ b/src/os/exec/exec_test.go @@ -954,6 +954,10 @@ func TestContext(t *testing.T) { } func TestContextCancel(t *testing.T) { + if runtime.GOOS == "netbsd" && runtime.GOARCH == "arm64" { + testenv.SkipFlaky(t, 42061) + } + // To reduce noise in the final goroutine dump, // let other parallel tests complete if possible. t.Parallel() From 55a25aa6ca03143bef38be7f6d618df51c569a66 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Thu, 16 Dec 2021 12:32:39 -0500 Subject: [PATCH 519/752] net: lengthen arbitrary SetDeadline timeout by a few orders of magnitude MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The "someTimeout" constant in the net test is “just to test that net.Conn implementations don't explode when their SetFooDeadline methods are called”. It was set to 10 seconds, which is short enough that it could actually matter on some platforms. Since the point of the constant is just to make sure methods don't explode, we should set it to be at least a couple of orders of magnitude longer than the test: then it is guaranteed not to have any unintended side-effects. Fixes #50227 Change-Id: If97ae7bef5e7f16b336d09ccc37f5ea2ea7e70b3 Reviewed-on: https://go-review.googlesource.com/c/go/+/372796 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/net/conn_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/net/conn_test.go b/src/net/conn_test.go index 3403eddfd3..d168dda08e 100644 --- a/src/net/conn_test.go +++ b/src/net/conn_test.go @@ -17,7 +17,7 @@ import ( // someTimeout is used just to test that net.Conn implementations // don't explode when their SetFooDeadline methods are called. // It isn't actually used for testing timeouts. -const someTimeout = 10 * time.Second +const someTimeout = 1 * time.Hour func TestConnAndListener(t *testing.T) { for i, network := range []string{"tcp", "unix", "unixpacket"} { From 2bdf34f3e86693264938d791a673a97011420eb2 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 15 Dec 2021 20:03:11 -0800 Subject: [PATCH 520/752] spec: clarify that comparable cannot be a union element For #49602. Change-Id: I0d3ff8f087dffb3409918494147fd1dceff7514d Reviewed-on: https://go-review.googlesource.com/c/go/+/372694 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index cb57aa301c..ed98f5375f 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1,6 +1,6 @@ @@ -1532,7 +1532,9 @@ interface {

    Implementation restriction: A union with more than one term cannot contain interface types -with non-empty method sets. +with non-empty method sets or which +are or embed the predeclared identifier +comparable.

    From 3c495839fe6e711b9161f8efc2d1bd474bf60916 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 16 Dec 2021 10:25:07 -0800 Subject: [PATCH 521/752] spec: describe constraint parsing ambiguity and work-around more precisely The new description matches the implementation (CL 370774). Also, in the section on type constraints, use "defines" instead of "determines" because the constraint interface defines the type set which is precisely the set of acceptable type arguments. For #49482. Change-Id: I6f30f49100e8ba8bec0a0f1b450f88cae54312eb Reviewed-on: https://go-review.googlesource.com/c/go/+/372874 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index ed98f5375f..c0b224f977 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -2604,7 +2604,8 @@ has a corresponding (meta-)type which is called its

    A parsing ambiguity arises when the type parameter list for a parameterized type declares a single type parameter with a type constraint of the form *C -or (C): +or (C) where C is not a (possibly parenthesized) +type literal: 

    @@ -2616,17 +2617,19 @@ type T[P (C)] …
 In these rare cases, the type parameter declaration is indistinguishable from
 the expressions P*C or P(C) and the type declaration
 is parsed as an array type declaration.
-To resolve the ambiguity, embed the constraint in an interface:
+To resolve the ambiguity, embed the constraint in an interface or use a trailing
+comma:
 
    
 
 
     type T[P interface{*C}] …
+type T[P *C,] …
 
    
 
 
    Type constraints
    
 
 
    
-A type constraint is an interface that determines the
+A type constraint is an interface that defines the
 set of permissible type arguments for the respective type parameter and controls the
 operations supported by values of that type parameter.
 
    

From 529939072eef730c82333344f321972874758be8 Mon Sep 17 00:00:00 2001
From: Ian Lance Taylor 
Date: Thu, 16 Dec 2021 17:54:27 -0800
Subject: [PATCH 522/752] doc/go1.18: document union element restriction

For #47694

Change-Id: I9af871a4a45b002e72629904011aac8f076617f1
Reviewed-on: https://go-review.googlesource.com/c/go/+/372974
Trust: Ian Lance Taylor 
Run-TryBot: Ian Lance Taylor 
TryBot-Result: Gopher Robot 
Reviewed-by: Robert Griesemer 
---
 doc/go1.18.html | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/doc/go1.18.html b/doc/go1.18.html
index 2ec5fae8c7..5f6476908a 100644
--- a/doc/go1.18.html
+++ b/doc/go1.18.html
@@ -103,6 +103,11 @@ Do not send CLs removing the interior tags from such phrases.
       embedding a type parameter in an interface type is not permitted.
       Whether these will ever be permitted is unclear at present.
    • +
  • + A union element with more than one term may not contain an + interface type with a non-empty method set. Whether this will + ever be permitted is unclear at present. +

    • From c5fee935bbb8f02406eb653cfed550593755a1a4 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Thu, 16 Dec 2021 14:33:13 -0500 Subject: [PATCH 523/752] cmd/link: force eager binding when using plugins on darwin When building/using plugins on darwin, we need to use flat namespace so the same symbol from the main executable and the plugin can be resolved to the same address. Apparently, when using flat namespace the dynamic linker can hang at forkExec when resolving a lazy binding. Work around it by forcing early bindings. Fixes #38824. Change-Id: I983aa0a0960b15bf3f7871382e8231ee244655f4 Reviewed-on: https://go-review.googlesource.com/c/go/+/372798 Trust: Cherry Mui Reviewed-by: Than McIntosh Reviewed-by: Ian Lance Taylor Run-TryBot: Cherry Mui TryBot-Result: Gopher Robot --- misc/cgo/testplugin/plugin_test.go | 28 +++++++++++++++++ misc/cgo/testplugin/testdata/forkexec/main.go | 30 +++++++++++++++++++ src/cmd/link/internal/ld/lib.go | 5 +++- 3 files changed, 62 insertions(+), 1 deletion(-) create mode 100644 misc/cgo/testplugin/testdata/forkexec/main.go diff --git a/misc/cgo/testplugin/plugin_test.go b/misc/cgo/testplugin/plugin_test.go index a6accc1dfb..10c5db2646 100644 --- a/misc/cgo/testplugin/plugin_test.go +++ b/misc/cgo/testplugin/plugin_test.go @@ -289,3 +289,31 @@ func TestIssue44956(t *testing.T) { goCmd(t, "build", "-o", "issue44956.exe", "./issue44956/main.go") run(t, "./issue44956.exe") } + +func TestForkExec(t *testing.T) { + // Issue 38824: importing the plugin package causes it hang in forkExec on darwin. + + t.Parallel() + goCmd(t, "build", "-o", "forkexec.exe", "./forkexec/main.go") + + var cmd *exec.Cmd + done := make(chan int, 1) + + go func() { + for i := 0; i < 100; i++ { + cmd = exec.Command("./forkexec.exe", "1") + err := cmd.Run() + if err != nil { + t.Errorf("running command failed: %v", err) + break + } + } + done <- 1 + }() + select { + case <-done: + case <-time.After(5 * time.Minute): + cmd.Process.Kill() + t.Fatalf("subprocess hang") + } +} diff --git a/misc/cgo/testplugin/testdata/forkexec/main.go b/misc/cgo/testplugin/testdata/forkexec/main.go new file mode 100644 index 0000000000..3169ff5f04 --- /dev/null +++ b/misc/cgo/testplugin/testdata/forkexec/main.go @@ -0,0 +1,30 @@ +// 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 ( + "os" + "os/exec" + _ "plugin" + "sync" +) + +func main() { + if os.Args[1] != "1" { + return + } + + var wg sync.WaitGroup + for i := 0; i < 8; i++ { + wg.Add(1) + go func() { + defer wg.Done() + // does not matter what we exec, just exec itself + cmd := exec.Command("./forkexec.exe", "0") + cmd.Run() + }() + } + wg.Wait() +} diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go index 9e13db7b71..f1a37e955e 100644 --- a/src/cmd/link/internal/ld/lib.go +++ b/src/cmd/link/internal/ld/lib.go @@ -1269,7 +1269,10 @@ func (ctxt *Link) hostlink() { if ctxt.DynlinkingGo() && buildcfg.GOOS != "ios" { // -flat_namespace is deprecated on iOS. // It is useful for supporting plugins. We don't support plugins on iOS. - argv = append(argv, "-Wl,-flat_namespace") + // -flat_namespace may cause the dynamic linker to hang at forkExec when + // resolving a lazy binding. See issue 38824. + // Force eager resolution to work around. + argv = append(argv, "-Wl,-flat_namespace", "-Wl,-bind_at_load") } if !combineDwarf { argv = append(argv, "-Wl,-S") // suppress STAB (symbolic debugging) symbols From 87b2a54827b5a845e9b29ede9414495e3e869f2e Mon Sep 17 00:00:00 2001 From: clamyang Date: Sun, 19 Dec 2021 03:03:38 +0000 Subject: [PATCH 524/752] runtime: mgc.go typo fix: becuse -> because Change-Id: I5019d5b9520e47a99a6136f615b6c9468073cc3c GitHub-Last-Rev: 1a5392925a0c4e9b2915620fee3efa79ae14af20 GitHub-Pull-Request: golang/go#50239 Reviewed-on: https://go-review.googlesource.com/c/go/+/373055 Reviewed-by: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Trust: Brad Fitzpatrick --- src/runtime/mgc.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go index 8c8f7d936b..44b96154e7 100644 --- a/src/runtime/mgc.go +++ b/src/runtime/mgc.go @@ -1323,7 +1323,7 @@ func gcBgMarkWorker() { // point, signal the main GC goroutine. if incnwait == work.nproc && !gcMarkWorkAvailable(nil) { // We don't need the P-local buffers here, allow - // preemption becuse we may schedule like a regular + // preemption because we may schedule like a regular // goroutine in gcMarkDone (block on locks, etc). releasem(node.m.ptr()) node.m.set(nil) From a2004de0885cc3796fed6dff54678efb8ffa4d01 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 15 Dec 2021 16:13:05 -0800 Subject: [PATCH 525/752] go/types, types2: delay "does not satisfy comparable" error until needed Fixes #49112. Change-Id: I8effbca7bcbb257b18fd4d3d1914fd10d4afaaae Reviewed-on: https://go-review.googlesource.com/c/go/+/372594 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Robert Findley --- .../compile/internal/types2/instantiate.go | 25 ++++++++----------- .../internal/types2/testdata/check/issues.go2 | 6 ++--- .../types2/testdata/fixedbugs/issue47411.go2 | 6 ++--- .../types2/testdata/fixedbugs/issue49112.go2 | 15 +++++++++++ src/go/types/instantiate.go | 25 ++++++++----------- src/go/types/testdata/check/issues.go2 | 6 ++--- .../types/testdata/fixedbugs/issue47411.go2 | 6 ++--- .../types/testdata/fixedbugs/issue49112.go2 | 15 +++++++++++ 8 files changed, 64 insertions(+), 40 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue49112.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue49112.go2 diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go index cda6c7baf4..b2e1087c41 100644 --- a/src/cmd/compile/internal/types2/instantiate.go +++ b/src/cmd/compile/internal/types2/instantiate.go @@ -192,17 +192,7 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { return errorf("cannot implement %s (empty type set)", T) } - // If T is comparable, V must be comparable. - // TODO(gri) the error messages could be better, here - if Ti.IsComparable() && !Comparable(V) { - if Vi != nil && Vi.Empty() { - return errorf("empty interface %s does not implement %s", V, T) - } - return errorf("%s does not implement comparable", V) - } - - // V must implement T (methods) - // - check only if we have methods + // V must implement T's methods, if any. if Ti.NumMethods() > 0 { if m, wrong := check.missingMethod(V, Ti, true); m != nil { // TODO(gri) needs to print updated name to avoid major confusion in error message! @@ -220,10 +210,17 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { } } + // If T is comparable, V must be comparable. + // Remember as a pending error and report only if we don't have a more specific error. + var pending error + if Ti.IsComparable() && !Comparable(V) { + pending = errorf("%s does not implement comparable", V) + } + // V must also be in the set of types of T, if any. // Constraints with empty type sets were already excluded above. if !Ti.typeSet().hasTerms() { - return nil // nothing to do + return pending // nothing to do } // If V is itself an interface, each of its possible types must be in the set @@ -234,7 +231,7 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { // TODO(gri) report which type is missing return errorf("%s does not implement %s", V, T) } - return nil + return pending } // Otherwise, V's type must be included in the iface type set. @@ -262,5 +259,5 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { } } - return nil + return pending } diff --git a/src/cmd/compile/internal/types2/testdata/check/issues.go2 b/src/cmd/compile/internal/types2/testdata/check/issues.go2 index 76f9cc5010..5b6eebd4fd 100644 --- a/src/cmd/compile/internal/types2/testdata/check/issues.go2 +++ b/src/cmd/compile/internal/types2/testdata/check/issues.go2 @@ -58,7 +58,7 @@ func _() { type T1[P interface{~uint}] struct{} func _[P any]() { - _ = T1[P /* ERROR empty interface P does not implement interface{~uint} */ ]{} + _ = T1[P /* ERROR P does not implement interface{~uint} */ ]{} } // This is the original (simplified) program causing the same issue. @@ -74,8 +74,8 @@ func (u T2[U]) Add1() U { return u.s + 1 } -func NewT2[U any]() T2[U /* ERROR empty interface U does not implement Unsigned */ ] { - return T2[U /* ERROR empty interface U does not implement Unsigned */ ]{} +func NewT2[U any]() T2[U /* ERROR U does not implement Unsigned */ ] { + return T2[U /* ERROR U does not implement Unsigned */ ]{} } func _() { diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47411.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47411.go2 index ce5db0a615..3f405baed7 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47411.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47411.go2 @@ -16,11 +16,11 @@ func _[P comparable, _ = f[P] _ = f[Q] _ = f[func( /* ERROR does not implement comparable */ )] - _ = f[R /* ERROR empty interface R does not implement comparable */ ] + _ = f[R /* ERROR R does not implement comparable */ ] _ = g[int] _ = g[P /* ERROR P does not implement interface{interface{comparable; ~int\|~string} */ ] _ = g[Q] - _ = g[func( /* ERROR does not implement comparable */ )] - _ = g[R /* ERROR empty interface R does not implement interface{interface{comparable; ~int\|~string} */ ] + _ = g[func( /* ERROR func\(\) does not implement interface{interface{comparable; ~int\|~string}} */ )] + _ = g[R /* ERROR R does not implement interface{interface{comparable; ~int\|~string} */ ] } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49112.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49112.go2 new file mode 100644 index 0000000000..0efc9066ec --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49112.go2 @@ -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. + +package p + +func f[P int](P) {} + +func _() { + _ = f[int] + _ = f[[ /* ERROR \[\]int does not implement int */ ]int] + + f(0) + f( /* ERROR \[\]int does not implement int */ []int{}) +} diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go index e8748975c9..e6a5cbf8ae 100644 --- a/src/go/types/instantiate.go +++ b/src/go/types/instantiate.go @@ -192,17 +192,7 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { return errorf("cannot implement %s (empty type set)", T) } - // If T is comparable, V must be comparable. - // TODO(gri) the error messages could be better, here - if Ti.IsComparable() && !Comparable(V) { - if Vi != nil && Vi.Empty() { - return errorf("empty interface %s does not implement %s", V, T) - } - return errorf("%s does not implement comparable", V) - } - - // V must implement T (methods) - // - check only if we have methods + // V must implement T's methods, if any. if Ti.NumMethods() > 0 { if m, wrong := check.missingMethod(V, Ti, true); m != nil { // TODO(gri) needs to print updated name to avoid major confusion in error message! @@ -221,10 +211,17 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { } } + // If T is comparable, V must be comparable. + // Remember as a pending error and report only if we don't have a more specific error. + var pending error + if Ti.IsComparable() && !Comparable(V) { + pending = errorf("%s does not implement comparable", V) + } + // V must also be in the set of types of T, if any. // Constraints with empty type sets were already excluded above. if !Ti.typeSet().hasTerms() { - return nil // nothing to do + return pending // nothing to do } // If V is itself an interface, each of its possible types must be in the set @@ -235,7 +232,7 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { // TODO(gri) report which type is missing return errorf("%s does not implement %s", V, T) } - return nil + return pending } // Otherwise, V's type must be included in the iface type set. @@ -263,5 +260,5 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { } } - return nil + return pending } diff --git a/src/go/types/testdata/check/issues.go2 b/src/go/types/testdata/check/issues.go2 index 371856eea3..cec1ccb0cc 100644 --- a/src/go/types/testdata/check/issues.go2 +++ b/src/go/types/testdata/check/issues.go2 @@ -58,7 +58,7 @@ func _() { type T1[P interface{~uint}] struct{} func _[P any]() { - _ = T1[P /* ERROR empty interface P does not implement interface{~uint} */ ]{} + _ = T1[P /* ERROR P does not implement interface{~uint} */ ]{} } // This is the original (simplified) program causing the same issue. @@ -74,8 +74,8 @@ func (u T2[U]) Add1() U { return u.s + 1 } -func NewT2[U any]() T2[U /* ERROR empty interface U does not implement Unsigned */ ] { - return T2[U /* ERROR empty interface U does not implement Unsigned */ ]{} +func NewT2[U any]() T2[U /* ERROR U does not implement Unsigned */ ] { + return T2[U /* ERROR U does not implement Unsigned */ ]{} } func _() { diff --git a/src/go/types/testdata/fixedbugs/issue47411.go2 b/src/go/types/testdata/fixedbugs/issue47411.go2 index d6c34be8db..db5fb32483 100644 --- a/src/go/types/testdata/fixedbugs/issue47411.go2 +++ b/src/go/types/testdata/fixedbugs/issue47411.go2 @@ -16,11 +16,11 @@ func _[P comparable, _ = f[P] _ = f[Q] _ = f[func /* ERROR does not implement comparable */ ()] - _ = f[R /* ERROR empty interface R does not implement comparable */ ] + _ = f[R /* ERROR R does not implement comparable */ ] _ = g[int] _ = g[P /* ERROR P does not implement interface{interface{comparable; ~int\|~string} */ ] _ = g[Q] - _ = g[func /* ERROR does not implement comparable */ ()] - _ = g[R /* ERROR empty interface R does not implement interface{interface{comparable; ~int\|~string} */ ] + _ = g[func /* ERROR func\(\) does not implement interface{interface{comparable; ~int\|~string}} */ ()] + _ = g[R /* ERROR R does not implement interface{interface{comparable; ~int\|~string} */ ] } diff --git a/src/go/types/testdata/fixedbugs/issue49112.go2 b/src/go/types/testdata/fixedbugs/issue49112.go2 new file mode 100644 index 0000000000..61b757ccb2 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue49112.go2 @@ -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. + +package p + +func f[P int](P) {} + +func _() { + _ = f[int] + _ = f[[ /* ERROR \[\]int does not implement int */ ]int] + + f(0) + f/* ERROR \[\]int does not implement int */ ([]int{}) +} From 7c94355b738170cf06484d502af7f2d935831c2b Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 16 Dec 2021 16:28:38 -0800 Subject: [PATCH 526/752] go/types: better error message when using comparable in union This is a port of CL 372674 from types2 to go/types with minor adjustments for error handling. For #49602. Change-Id: I726081325a2ff2d5690d11ddc8a830bbcbd8ab33 Reviewed-on: https://go-review.googlesource.com/c/go/+/372954 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor Reviewed-by: Robert Findley --- .../types/testdata/fixedbugs/issue49602.go2 | 19 +++++++++++++++++++ src/go/types/union.go | 11 ++++++++++- 2 files changed, 29 insertions(+), 1 deletion(-) create mode 100644 src/go/types/testdata/fixedbugs/issue49602.go2 diff --git a/src/go/types/testdata/fixedbugs/issue49602.go2 b/src/go/types/testdata/fixedbugs/issue49602.go2 new file mode 100644 index 0000000000..208501fafd --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue49602.go2 @@ -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 p + +type M interface { + m() +} + +type C interface { + comparable +} + +type _ interface { + int | M // ERROR cannot use p\.M in union \(p\.M contains methods\) + int | comparable // ERROR cannot use comparable in union + int | C // ERROR cannot use p\.C in union \(p\.C embeds comparable\) +} diff --git a/src/go/types/union.go b/src/go/types/union.go index 7cd5b2a88b..9c59279447 100644 --- a/src/go/types/union.go +++ b/src/go/types/union.go @@ -111,7 +111,16 @@ func parseUnion(check *Checker, uexpr ast.Expr) Type { // in the beginning. Embedded interfaces with tilde are excluded above. If we reach // here, we must have at least two terms in the union. if f != nil && !f.typeSet().IsTypeSet() { - check.errorf(tlist[i], _InvalidUnion, "cannot use %s in union (interface contains methods)", t) + switch { + case f.typeSet().NumMethods() != 0: + check.errorf(tlist[i], _InvalidUnion, "cannot use %s in union (%s contains methods)", t, t) + case t.typ == universeComparable.Type(): + check.error(tlist[i], _InvalidUnion, "cannot use comparable in union") + case f.typeSet().comparable: + check.errorf(tlist[i], _InvalidUnion, "cannot use %s in union (%s embeds comparable)", t, t) + default: + panic("not a type set but no methods and not comparable") + } continue // don't report another error for t } From 59d04d104d9e08322712e837b35f4cd54c9bae1a Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Mon, 20 Dec 2021 12:45:04 -0500 Subject: [PATCH 527/752] cmd/internal/obj/riscv: mark stack bounds check prologue nonpreemptible This is similar to CL 207350, for RISCV64. May fix #50263. Updates #35470. Change-Id: I0d39e195e8254d65fa1aca1cdf1fc553aa8b7cba Reviewed-on: https://go-review.googlesource.com/c/go/+/373434 Trust: Cherry Mui Run-TryBot: Cherry Mui Reviewed-by: David Chase TryBot-Result: Gopher Robot --- src/cmd/internal/obj/riscv/obj.go | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/cmd/internal/obj/riscv/obj.go b/src/cmd/internal/obj/riscv/obj.go index 5755b118db..9f16de0c8c 100644 --- a/src/cmd/internal/obj/riscv/obj.go +++ b/src/cmd/internal/obj/riscv/obj.go @@ -790,6 +790,12 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, cursym *obj.LSym, newprog obj.ProgA p.To.Type = obj.TYPE_REG p.To.Reg = REG_X10 + // Mark the stack bound check and morestack call async nonpreemptible. + // If we get preempted here, when resumed the preemption request is + // cleared, but we'll still call morestack, which will double the stack + // unnecessarily. See issue #35470. + p = ctxt.StartUnsafePoint(p, newprog) + var to_done, to_more *obj.Prog if framesize <= objabi.StackSmall { @@ -854,7 +860,7 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, cursym *obj.LSym, newprog obj.ProgA to_done = p } - p = ctxt.EmitEntryLiveness(cursym, p, newprog) + p = ctxt.EmitEntryStackMap(cursym, p, newprog) // CALL runtime.morestack(SB) p = obj.Appendp(p, newprog) @@ -872,6 +878,8 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, cursym *obj.LSym, newprog obj.ProgA } jalToSym(ctxt, p, REG_X5) + p = ctxt.EndUnsafePoint(p, newprog, -1) + // JMP start p = obj.Appendp(p, newprog) p.As = AJAL From 9901d9e87a47b775edd0e75edb19ba696091603e Mon Sep 17 00:00:00 2001 From: Dan Kortschak Date: Mon, 20 Dec 2021 17:47:42 +1030 Subject: [PATCH 528/752] all: fix spelling errors found by misspell Change-Id: Icedd0c3d49259d5aee249ecb33374e9b78e0c275 Reviewed-on: https://go-review.googlesource.com/c/go/+/373376 Reviewed-by: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/cmd/compile/internal/types2/assignments.go | 2 +- src/cmd/compile/internal/types2/decl.go | 2 +- src/cmd/compile/internal/types2/typeterm_test.go | 2 +- src/cmd/internal/obj/ppc64/asm_test.go | 2 +- src/go/types/assignments.go | 2 +- src/go/types/decl.go | 2 +- src/go/types/typeterm_test.go | 2 +- src/internal/fuzz/fuzz.go | 2 +- src/testing/fuzz.go | 2 +- 9 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go index 668eeac00e..936930f0b1 100644 --- a/src/cmd/compile/internal/types2/assignments.go +++ b/src/cmd/compile/internal/types2/assignments.go @@ -268,7 +268,7 @@ func (check *Checker) typesSummary(list []Type, variadic bool) string { var s string switch { case t == nil: - fallthrough // should not happend but be cautious + fallthrough // should not happen but be cautious case t == Typ[Invalid]: s = "" case isUntyped(t): diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index a4bc3969c0..d5495304fa 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -351,7 +351,7 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo { // Instantiating such a type would lead to an infinite sequence of instantiations. // In general, we need "type flow analysis" to recognize those cases. // Example: type A[T any] struct{ x A[*T] } (issue #48951) - // In this algorithm we always only consider the orginal, uninstantiated type. + // In this algorithm we always only consider the original, uninstantiated type. // This won't recognize some invalid cases with parameterized types, but it // will terminate. t = t.orig diff --git a/src/cmd/compile/internal/types2/typeterm_test.go b/src/cmd/compile/internal/types2/typeterm_test.go index 5a5c1fa447..6d9c8db034 100644 --- a/src/cmd/compile/internal/types2/typeterm_test.go +++ b/src/cmd/compile/internal/types2/typeterm_test.go @@ -99,7 +99,7 @@ func TestTermUnion(t *testing.T) { "~int ~string ~int ~string", "~int myInt ~int ∅", - // union is symmetric, but the result order isn't - repeat symmetric cases explictly + // union is symmetric, but the result order isn't - repeat symmetric cases explicitly "𝓤 ∅ 𝓤 ∅", "int ∅ int ∅", "~int ∅ ~int ∅", diff --git a/src/cmd/internal/obj/ppc64/asm_test.go b/src/cmd/internal/obj/ppc64/asm_test.go index ee2e5962f7..1de6e76b09 100644 --- a/src/cmd/internal/obj/ppc64/asm_test.go +++ b/src/cmd/internal/obj/ppc64/asm_test.go @@ -300,7 +300,7 @@ func TestLarge(t *testing.T) { t.Fatal(err) } if !matched { - t.Errorf("Failed to detect long foward BC fixup in (%v):%s\n", platenv, out) + t.Errorf("Failed to detect long forward BC fixup in (%v):%s\n", platenv, out) } matched, err = regexp.MatchString(strings.Join(test.backpattern, "\n\t*"), string(out)) if err != nil { diff --git a/src/go/types/assignments.go b/src/go/types/assignments.go index fa05a10920..f75b8b6f6b 100644 --- a/src/go/types/assignments.go +++ b/src/go/types/assignments.go @@ -264,7 +264,7 @@ func (check *Checker) typesSummary(list []Type, variadic bool) string { var s string switch { case t == nil: - fallthrough // should not happend but be cautious + fallthrough // should not happen but be cautious case t == Typ[Invalid]: s = "" case isUntyped(t): diff --git a/src/go/types/decl.go b/src/go/types/decl.go index 2c51329be9..db29f11920 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -350,7 +350,7 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo { // Instantiating such a type would lead to an infinite sequence of instantiations. // In general, we need "type flow analysis" to recognize those cases. // Example: type A[T any] struct{ x A[*T] } (issue #48951) - // In this algorithm we always only consider the orginal, uninstantiated type. + // In this algorithm we always only consider the original, uninstantiated type. // This won't recognize some invalid cases with parameterized types, but it // will terminate. t = t.orig diff --git a/src/go/types/typeterm_test.go b/src/go/types/typeterm_test.go index 27f132a1d2..24a14102d0 100644 --- a/src/go/types/typeterm_test.go +++ b/src/go/types/typeterm_test.go @@ -100,7 +100,7 @@ func TestTermUnion(t *testing.T) { "~int ~string ~int ~string", "~int myInt ~int ∅", - // union is symmetric, but the result order isn't - repeat symmetric cases explictly + // union is symmetric, but the result order isn't - repeat symmetric cases explicitly "𝓤 ∅ 𝓤 ∅", "int ∅ int ∅", "~int ∅ ~int ∅", diff --git a/src/internal/fuzz/fuzz.go b/src/internal/fuzz/fuzz.go index b3f1381dbb..37b6d2b391 100644 --- a/src/internal/fuzz/fuzz.go +++ b/src/internal/fuzz/fuzz.go @@ -323,7 +323,7 @@ func CoordinateFuzzing(ctx context.Context, opts CoordinateFuzzingOpts) (err err // flakiness in the coverage counters). In order to prevent adding // duplicate entries to the corpus (and re-writing the file on // disk), skip it if the on disk file already exists. - // TOOD(roland): this check is limited in that it will only be + // TODO(roland): this check is limited in that it will only be // applied if we are using the CacheDir. Another option would be // to iterate through the corpus and check if it is already present, // which would catch cases where we are not caching entries. diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go index 17a8753ae6..efb59b3e57 100644 --- a/src/testing/fuzz.go +++ b/src/testing/fuzz.go @@ -199,7 +199,7 @@ var supportedTypes = map[reflect.Type]bool{ // the corresponding *T method instead. The only *F methods that are allowed in // the (*F).Fuzz function are (*F).Failed and (*F).Name. // -// This function sould be fast and deterministic, and its behavior should not +// This function should be fast and deterministic, and its behavior should not // depend on shared state. No mutatable input arguments, or pointers to them, // should be retained between executions of the fuzz function, as the memory // backing them may be mutated during a subsequent invocation. ff must not From 6713b5dbbc4b3bbfa2022538501c7f8104f1e5fd Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Sat, 18 Dec 2021 15:54:38 -0800 Subject: [PATCH 529/752] cmd/doc: don't log on constraint type elements Fixes #50256 Change-Id: I2327a0b28f8173c801ed2946bec8083967667027 Reviewed-on: https://go-review.googlesource.com/c/go/+/373314 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Robert Findley --- src/cmd/doc/doc_test.go | 13 +++++++++++++ src/cmd/doc/pkg.go | 8 +++++++- src/cmd/doc/testdata/pkg.go | 12 ++++++++++++ 3 files changed, 32 insertions(+), 1 deletion(-) diff --git a/src/cmd/doc/doc_test.go b/src/cmd/doc/doc_test.go index af7793133e..0ff9edcde3 100644 --- a/src/cmd/doc/doc_test.go +++ b/src/cmd/doc/doc_test.go @@ -7,6 +7,7 @@ package main import ( "bytes" "flag" + "log" "os" "path/filepath" "regexp" @@ -125,6 +126,9 @@ var tests = []test{ `func MultiLineFunc\(x interface{ ... }\) \(r struct{ ... }\)`, // Multi line function. `var LongLine = newLongLine\(("someArgument[1-4]", ){4}...\)`, // Long list of arguments. `type T1 = T2`, // Type alias + `type SimpleConstraint interface{ ... }`, + `type TildeConstraint interface{ ... }`, + `type StructConstraint interface{ ... }`, }, []string{ `const internalConstant = 2`, // No internal constants. @@ -199,6 +203,9 @@ var tests = []test{ `Comment about exported method`, `type T1 = T2`, `type T2 int`, + `type SimpleConstraint interface {`, + `type TildeConstraint interface {`, + `type StructConstraint interface {`, }, []string{ `constThree`, @@ -822,13 +829,19 @@ var tests = []test{ func TestDoc(t *testing.T) { maybeSkip(t) + defer log.SetOutput(log.Writer()) for _, test := range tests { var b bytes.Buffer var flagSet flag.FlagSet + var logbuf bytes.Buffer + log.SetOutput(&logbuf) err := do(&b, &flagSet, test.args) if err != nil { t.Fatalf("%s %v: %s\n", test.name, test.args, err) } + if logbuf.Len() > 0 { + t.Errorf("%s %v: unexpected log messages:\n%s", test.name, test.args, logbuf.Bytes()) + } output := b.Bytes() failed := false for j, yes := range test.yes { diff --git a/src/cmd/doc/pkg.go b/src/cmd/doc/pkg.go index f51efe08af..0266600730 100644 --- a/src/cmd/doc/pkg.go +++ b/src/cmd/doc/pkg.go @@ -865,6 +865,7 @@ func trimUnexportedFields(fields *ast.FieldList, isInterface bool) *ast.FieldLis if len(names) == 0 { // Embedded type. Use the name of the type. It must be of the form ident or // pkg.ident (for structs and interfaces), or *ident or *pkg.ident (structs only). + // Or a type embedded in a constraint. // Nothing else is allowed. ty := field.Type if se, ok := field.Type.(*ast.StarExpr); !isInterface && ok { @@ -872,6 +873,7 @@ func trimUnexportedFields(fields *ast.FieldList, isInterface bool) *ast.FieldLis // embedded types in structs. ty = se.X } + constraint := false switch ident := ty.(type) { case *ast.Ident: if isInterface && ident.Name == "error" && ident.Obj == nil { @@ -885,8 +887,12 @@ func trimUnexportedFields(fields *ast.FieldList, isInterface bool) *ast.FieldLis case *ast.SelectorExpr: // An embedded type may refer to a type in another package. names = []*ast.Ident{ident.Sel} + default: + // An approximation or union or type + // literal in an interface. + constraint = true } - if names == nil { + if names == nil && !constraint { // Can only happen if AST is incorrect. Safe to continue with a nil list. log.Print("invalid program: unexpected type for embedded field") } diff --git a/src/cmd/doc/testdata/pkg.go b/src/cmd/doc/testdata/pkg.go index 5ece832565..a693c74918 100644 --- a/src/cmd/doc/testdata/pkg.go +++ b/src/cmd/doc/testdata/pkg.go @@ -238,3 +238,15 @@ type ExportedFormattedType struct { // Text after pre-formatted block. ExportedField int } + +type SimpleConstraint interface { + ~int | ~float64 +} + +type TildeConstraint interface { + ~int +} + +type StructConstraint interface { + struct { F int } +} From 15550625c3140efce8ea1d7d3193ec4c563eb117 Mon Sep 17 00:00:00 2001 From: Andrew LeFevre Date: Thu, 16 Dec 2021 05:25:09 +0000 Subject: [PATCH 530/752] net/netip: add a fuzz test This is a pretty straight port of the fuzz test at https://github.com/inetaf/netaddr. The MarshalText methods of netip.Addr and net.IP, the Is* methods of netip.Addr and net.IP and the MarshalText and String methods of netip.Addr are also checked to ensure that they behave the same way. Fixes #49367 Change-Id: I44abb01f2a7af45f39597992a1fc7ff0305728fa GitHub-Last-Rev: c2323b0ae119b804a58b810ad7f0e2bb1b3a38ac GitHub-Pull-Request: golang/go#50108 Reviewed-on: https://go-review.googlesource.com/c/go/+/371055 Trust: Matt Layher Trust: Katie Hockman Reviewed-by: Katie Hockman --- src/net/netip/fuzz_test.go | 351 +++++++++++++++++++++++++++++++++++++ 1 file changed, 351 insertions(+) create mode 100644 src/net/netip/fuzz_test.go diff --git a/src/net/netip/fuzz_test.go b/src/net/netip/fuzz_test.go new file mode 100644 index 0000000000..c9fc6c98e9 --- /dev/null +++ b/src/net/netip/fuzz_test.go @@ -0,0 +1,351 @@ +// 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 netip_test + +import ( + "bytes" + "encoding" + "fmt" + "net" + . "net/netip" + "reflect" + "strings" + "testing" +) + +var corpus = []string{ + // Basic zero IPv4 address. + "0.0.0.0", + // Basic non-zero IPv4 address. + "192.168.140.255", + // IPv4 address in windows-style "print all the digits" form. + "010.000.015.001", + // IPv4 address with a silly amount of leading zeros. + "000001.00000002.00000003.000000004", + // 4-in-6 with octet with leading zero + "::ffff:1.2.03.4", + // Basic zero IPv6 address. + "::", + // Localhost IPv6. + "::1", + // Fully expanded IPv6 address. + "fd7a:115c:a1e0:ab12:4843:cd96:626b:430b", + // IPv6 with elided fields in the middle. + "fd7a:115c::626b:430b", + // IPv6 with elided fields at the end. + "fd7a:115c:a1e0:ab12:4843:cd96::", + // IPv6 with single elided field at the end. + "fd7a:115c:a1e0:ab12:4843:cd96:626b::", + "fd7a:115c:a1e0:ab12:4843:cd96:626b:0", + // IPv6 with single elided field in the middle. + "fd7a:115c:a1e0::4843:cd96:626b:430b", + "fd7a:115c:a1e0:0:4843:cd96:626b:430b", + // IPv6 with the trailing 32 bits written as IPv4 dotted decimal. (4in6) + "::ffff:192.168.140.255", + "::ffff:192.168.140.255", + // IPv6 with a zone specifier. + "fd7a:115c:a1e0:ab12:4843:cd96:626b:430b%eth0", + // IPv6 with dotted decimal and zone specifier. + "1:2::ffff:192.168.140.255%eth1", + "1:2::ffff:c0a8:8cff%eth1", + // IPv6 with capital letters. + "FD9E:1A04:F01D::1", + "fd9e:1a04:f01d::1", + // Empty string. + "", + // Garbage non-IP. + "bad", + // Single number. Some parsers accept this as an IPv4 address in + // big-endian uint32 form, but we don't. + "1234", + // IPv4 with a zone specifier. + "1.2.3.4%eth0", + // IPv4 field must have at least one digit. + ".1.2.3", + "1.2.3.", + "1..2.3", + // IPv4 address too long. + "1.2.3.4.5", + // IPv4 in dotted octal form. + "0300.0250.0214.0377", + // IPv4 in dotted hex form. + "0xc0.0xa8.0x8c.0xff", + // IPv4 in class B form. + "192.168.12345", + // IPv4 in class B form, with a small enough number to be + // parseable as a regular dotted decimal field. + "127.0.1", + // IPv4 in class A form. + "192.1234567", + // IPv4 in class A form, with a small enough number to be + // parseable as a regular dotted decimal field. + "127.1", + // IPv4 field has value >255. + "192.168.300.1", + // IPv4 with too many fields. + "192.168.0.1.5.6", + // IPv6 with not enough fields. + "1:2:3:4:5:6:7", + // IPv6 with too many fields. + "1:2:3:4:5:6:7:8:9", + // IPv6 with 8 fields and a :: expander. + "1:2:3:4::5:6:7:8", + // IPv6 with a field bigger than 2b. + "fe801::1", + // IPv6 with non-hex values in field. + "fe80:tail:scal:e::", + // IPv6 with a zone delimiter but no zone. + "fe80::1%", + // IPv6 with a zone specifier of zero. + "::ffff:0:0%0", + // IPv6 (without ellipsis) with too many fields for trailing embedded IPv4. + "ffff:ffff:ffff:ffff:ffff:ffff:ffff:192.168.140.255", + // IPv6 (with ellipsis) with too many fields for trailing embedded IPv4. + "ffff::ffff:ffff:ffff:ffff:ffff:ffff:192.168.140.255", + // IPv6 with invalid embedded IPv4. + "::ffff:192.168.140.bad", + // IPv6 with multiple ellipsis ::. + "fe80::1::1", + // IPv6 with invalid non hex/colon character. + "fe80:1?:1", + // IPv6 with truncated bytes after single colon. + "fe80:", + // AddrPort strings. + "1.2.3.4:51820", + "[fd7a:115c:a1e0:ab12:4843:cd96:626b:430b]:80", + "[::ffff:c000:0280]:65535", + "[::ffff:c000:0280%eth0]:1", + // Prefix strings. + "1.2.3.4/24", + "fd7a:115c:a1e0:ab12:4843:cd96:626b:430b/118", + "::ffff:c000:0280/96", + "::ffff:c000:0280%eth0/37", +} + +func FuzzParse(f *testing.F) { + for _, seed := range corpus { + f.Add(seed) + } + + f.Fuzz(func(t *testing.T, s string) { + ip, _ := ParseAddr(s) + checkStringParseRoundTrip(t, ip, ParseAddr) + checkEncoding(t, ip) + + // Check that we match the net's IP parser, modulo zones. + if !strings.Contains(s, "%") { + stdip := net.ParseIP(s) + if !ip.IsValid() != (stdip == nil) { + t.Errorf("ParseAddr zero != net.ParseIP nil: ip=%q stdip=%q", ip, stdip) + } + + if ip.IsValid() && !ip.Is4In6() { + buf, err := ip.MarshalText() + if err != nil { + t.Fatal(err) + } + buf2, err := stdip.MarshalText() + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(buf, buf2) { + t.Errorf("Addr.MarshalText() != net.IP.MarshalText(): ip=%q stdip=%q", ip, stdip) + } + if ip.String() != stdip.String() { + t.Errorf("Addr.String() != net.IP.String(): ip=%q stdip=%q", ip, stdip) + } + if ip.IsGlobalUnicast() != stdip.IsGlobalUnicast() { + t.Errorf("Addr.IsGlobalUnicast() != net.IP.IsGlobalUnicast(): ip=%q stdip=%q", ip, stdip) + } + if ip.IsInterfaceLocalMulticast() != stdip.IsInterfaceLocalMulticast() { + t.Errorf("Addr.IsInterfaceLocalMulticast() != net.IP.IsInterfaceLocalMulticast(): ip=%q stdip=%q", ip, stdip) + } + if ip.IsLinkLocalMulticast() != stdip.IsLinkLocalMulticast() { + t.Errorf("Addr.IsLinkLocalMulticast() != net.IP.IsLinkLocalMulticast(): ip=%q stdip=%q", ip, stdip) + } + if ip.IsLinkLocalUnicast() != stdip.IsLinkLocalUnicast() { + t.Errorf("Addr.IsLinkLocalUnicast() != net.IP.IsLinkLocalUnicast(): ip=%q stdip=%q", ip, stdip) + } + if ip.IsLoopback() != stdip.IsLoopback() { + t.Errorf("Addr.IsLoopback() != net.IP.IsLoopback(): ip=%q stdip=%q", ip, stdip) + } + if ip.IsMulticast() != stdip.IsMulticast() { + t.Errorf("Addr.IsMulticast() != net.IP.IsMulticast(): ip=%q stdip=%q", ip, stdip) + } + if ip.IsPrivate() != stdip.IsPrivate() { + t.Errorf("Addr.IsPrivate() != net.IP.IsPrivate(): ip=%q stdip=%q", ip, stdip) + } + if ip.IsUnspecified() != stdip.IsUnspecified() { + t.Errorf("Addr.IsUnspecified() != net.IP.IsUnspecified(): ip=%q stdip=%q", ip, stdip) + } + } + } + + // Check that .Next().Prev() and .Prev().Next() preserve the IP. + if ip.IsValid() && ip.Next().IsValid() && ip.Next().Prev() != ip { + t.Errorf(".Next.Prev did not round trip: ip=%q .next=%q .next.prev=%q", ip, ip.Next(), ip.Next().Prev()) + } + if ip.IsValid() && ip.Prev().IsValid() && ip.Prev().Next() != ip { + t.Errorf(".Prev.Next did not round trip: ip=%q .prev=%q .prev.next=%q", ip, ip.Prev(), ip.Prev().Next()) + } + + port, err := ParseAddrPort(s) + if err == nil { + checkStringParseRoundTrip(t, port, ParseAddrPort) + checkEncoding(t, port) + } + port = AddrPortFrom(ip, 80) + checkStringParseRoundTrip(t, port, ParseAddrPort) + checkEncoding(t, port) + + ipp, err := ParsePrefix(s) + if err == nil { + checkStringParseRoundTrip(t, ipp, ParsePrefix) + checkEncoding(t, ipp) + } + ipp = PrefixFrom(ip, 8) + checkStringParseRoundTrip(t, ipp, ParsePrefix) + checkEncoding(t, ipp) + }) +} + +// checkTextMarshaler checks that x's MarshalText and UnmarshalText functions round trip correctly. +func checkTextMarshaler(t *testing.T, x encoding.TextMarshaler) { + buf, err := x.MarshalText() + if err != nil { + t.Fatal(err) + } + y := reflect.New(reflect.TypeOf(x)).Interface().(encoding.TextUnmarshaler) + err = y.UnmarshalText(buf) + if err != nil { + t.Logf("(%v).MarshalText() = %q", x, buf) + t.Fatalf("(%T).UnmarshalText(%q) = %v", y, buf, err) + } + e := reflect.ValueOf(y).Elem().Interface() + if !reflect.DeepEqual(x, e) { + t.Logf("(%v).MarshalText() = %q", x, buf) + t.Logf("(%T).UnmarshalText(%q) = %v", y, buf, y) + t.Fatalf("MarshalText/UnmarshalText failed to round trip: %#v != %#v", x, e) + } + buf2, err := y.(encoding.TextMarshaler).MarshalText() + if err != nil { + t.Logf("(%v).MarshalText() = %q", x, buf) + t.Logf("(%T).UnmarshalText(%q) = %v", y, buf, y) + t.Fatalf("failed to MarshalText a second time: %v", err) + } + if !bytes.Equal(buf, buf2) { + t.Logf("(%v).MarshalText() = %q", x, buf) + t.Logf("(%T).UnmarshalText(%q) = %v", y, buf, y) + t.Logf("(%v).MarshalText() = %q", y, buf2) + t.Fatalf("second MarshalText differs from first: %q != %q", buf, buf2) + } +} + +// checkBinaryMarshaler checks that x's MarshalText and UnmarshalText functions round trip correctly. +func checkBinaryMarshaler(t *testing.T, x encoding.BinaryMarshaler) { + buf, err := x.MarshalBinary() + if err != nil { + t.Fatal(err) + } + y := reflect.New(reflect.TypeOf(x)).Interface().(encoding.BinaryUnmarshaler) + err = y.UnmarshalBinary(buf) + if err != nil { + t.Logf("(%v).MarshalBinary() = %q", x, buf) + t.Fatalf("(%T).UnmarshalBinary(%q) = %v", y, buf, err) + } + e := reflect.ValueOf(y).Elem().Interface() + if !reflect.DeepEqual(x, e) { + t.Logf("(%v).MarshalBinary() = %q", x, buf) + t.Logf("(%T).UnmarshalBinary(%q) = %v", y, buf, y) + t.Fatalf("MarshalBinary/UnmarshalBinary failed to round trip: %#v != %#v", x, e) + } + buf2, err := y.(encoding.BinaryMarshaler).MarshalBinary() + if err != nil { + t.Logf("(%v).MarshalBinary() = %q", x, buf) + t.Logf("(%T).UnmarshalBinary(%q) = %v", y, buf, y) + t.Fatalf("failed to MarshalBinary a second time: %v", err) + } + if !bytes.Equal(buf, buf2) { + t.Logf("(%v).MarshalBinary() = %q", x, buf) + t.Logf("(%T).UnmarshalBinary(%q) = %v", y, buf, y) + t.Logf("(%v).MarshalBinary() = %q", y, buf2) + t.Fatalf("second MarshalBinary differs from first: %q != %q", buf, buf2) + } +} + +func checkTextMarshalMatchesString(t *testing.T, x netipType) { + buf, err := x.MarshalText() + if err != nil { + t.Fatal(err) + } + str := x.String() + if string(buf) != str { + t.Fatalf("%v: MarshalText = %q, String = %q", x, buf, str) + } +} + +type appendMarshaler interface { + encoding.TextMarshaler + AppendTo([]byte) []byte +} + +// checkTextMarshalMatchesAppendTo checks that x's MarshalText matches x's AppendTo. +func checkTextMarshalMatchesAppendTo(t *testing.T, x appendMarshaler) { + buf, err := x.MarshalText() + if err != nil { + t.Fatal(err) + } + + buf2 := make([]byte, 0, len(buf)) + buf2 = x.AppendTo(buf2) + if !bytes.Equal(buf, buf2) { + t.Fatalf("%v: MarshalText = %q, AppendTo = %q", x, buf, buf2) + } +} + +type netipType interface { + encoding.BinaryMarshaler + encoding.TextMarshaler + fmt.Stringer + IsValid() bool +} + +type netipTypeCmp interface { + comparable + netipType +} + +// checkStringParseRoundTrip checks that x's String method and the provided parse function can round trip correctly. +func checkStringParseRoundTrip[P netipTypeCmp](t *testing.T, x P, parse func(string) (P, error)) { + if !x.IsValid() { + // Ignore invalid values. + return + } + + s := x.String() + y, err := parse(s) + if err != nil { + t.Fatalf("s=%q err=%v", s, err) + } + if x != y { + t.Fatalf("%T round trip identity failure: s=%q x=%#v y=%#v", x, s, x, y) + } + s2 := y.String() + if s != s2 { + t.Fatalf("%T String round trip identity failure: s=%#v s2=%#v", x, s, s2) + } +} + +func checkEncoding(t *testing.T, x netipType) { + if x.IsValid() { + checkTextMarshaler(t, x) + checkBinaryMarshaler(t, x) + checkTextMarshalMatchesString(t, x) + } + + if am, ok := x.(appendMarshaler); ok { + checkTextMarshalMatchesAppendTo(t, am) + } +} From e0879490904495d26f762e19a997d4384bffa932 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Mon, 20 Dec 2021 19:08:14 -0500 Subject: [PATCH 531/752] runtime: check the correct environment variable in TestCgoCallbackGC The test checks RUNTIME_TESTING_SHORT, whereas the test runner actually set RUNTIME_TEST_SHORT. Check the correct one. Updates #32023. Change-Id: Ie8ab00e1f5b8c02112a9aa1ee0e56028185c8a44 Reviewed-on: https://go-review.googlesource.com/c/go/+/373614 Trust: Cherry Mui Run-TryBot: Cherry Mui TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/runtime/testdata/testprogcgo/callback.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/runtime/testdata/testprogcgo/callback.go b/src/runtime/testdata/testprogcgo/callback.go index a2d8a492a4..25f07159b8 100644 --- a/src/runtime/testdata/testprogcgo/callback.go +++ b/src/runtime/testdata/testprogcgo/callback.go @@ -66,7 +66,7 @@ func grow1(x, sum *int) int { func CgoCallbackGC() { P := 100 - if os.Getenv("RUNTIME_TESTING_SHORT") != "" { + if os.Getenv("RUNTIME_TEST_SHORT") != "" { P = 10 } done := make(chan bool) From 4dfbb89f585aac690a1c41dbb1604a567bc46f63 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E2=80=9Ckinggo=E2=80=9D?= <1510613524@qq.com> Date: Mon, 20 Dec 2021 05:54:27 +0000 Subject: [PATCH 532/752] runtime: typo fix cyle -> cycle Change-Id: I213fa8aa9b9c2537a189677394ddd30c62312518 GitHub-Last-Rev: ccafdee9440b06232cdfca83099bf0aeff62a4c0 GitHub-Pull-Request: golang/go#50268 Reviewed-on: https://go-review.googlesource.com/c/go/+/373336 Reviewed-by: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Zhuo Meng --- src/runtime/mgcmark.go | 2 +- src/runtime/mgcsweep.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go index a15c62cc49..68acfd4d49 100644 --- a/src/runtime/mgcmark.go +++ b/src/runtime/mgcmark.go @@ -1561,7 +1561,7 @@ func gcmarknewobject(span *mspan, obj, size, scanSize uintptr) { if !goexperiment.PacerRedesign { // The old pacer counts newly allocated memory toward // heapScanWork because heapScan is continuously updated - // throughout the GC cyle with newly allocated memory. However, + // throughout the GC cycle with newly allocated memory. However, // these objects are never actually scanned, so we need // to account for them in heapScanWork here, "faking" their work. // Otherwise the pacer will think it's always behind, potentially diff --git a/src/runtime/mgcsweep.go b/src/runtime/mgcsweep.go index fdbec30cf1..a46f4ec2c6 100644 --- a/src/runtime/mgcsweep.go +++ b/src/runtime/mgcsweep.go @@ -393,7 +393,7 @@ func sweepone() uintptr { // The scavenger is signaled by the last sweeper because once // sweeping is done, we will definitely have useful work for // the scavenger to do, since the scavenger only runs over the - // heap once per GC cyle. This update is not done during sweep + // heap once per GC cycle. This update is not done during sweep // termination because in some cases there may be a long delay // between sweep done and sweep termination (e.g. not enough // allocations to trigger a GC) which would be nice to fill in From b5e06545b3c3b3b9c2ed8204e5ba3fd25a85db0f Mon Sep 17 00:00:00 2001 From: Reilly Watson Date: Mon, 20 Dec 2021 16:31:45 -0500 Subject: [PATCH 533/752] net/http: fix link to ResponseWriter trailer example The links to this example were using an underscore separator instead of a hyphen, and incorrect casing. Fixes #50279 Change-Id: I35d76a8a78cd708b7505ff1a70f7dacddaf43efd Reviewed-on: https://go-review.googlesource.com/c/go/+/373514 Reviewed-by: Ian Lance Taylor Reviewed-by: Emmanuel Odeke --- src/net/http/server.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/net/http/server.go b/src/net/http/server.go index ddc799bd9e..ffb742ba4a 100644 --- a/src/net/http/server.go +++ b/src/net/http/server.go @@ -494,8 +494,8 @@ type response struct { // prior to the headers being written. If the set of trailers is fixed // or known before the header is written, the normal Go trailers mechanism // is preferred: -// https://golang.org/pkg/net/http/#ResponseWriter -// https://golang.org/pkg/net/http/#example_ResponseWriter_trailers +// https://pkg.go.dev/net/http#ResponseWriter +// https://pkg.go.dev/net/http#example-ResponseWriter-Trailers const TrailerPrefix = "Trailer:" // finalTrailers is called after the Handler exits and returns a non-nil From 2d1d54808131b09da768ec334b3387ccb70562ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jing=E7=BB=B4?= Date: Mon, 20 Dec 2021 00:36:55 +0000 Subject: [PATCH 534/752] reflect: update relative path in comment Fix it to avoid misunderstanding. Change-Id: I2a09cb9edfa8077c5c0c35e07000c0c7dc72755e GitHub-Last-Rev: ae49d512eb7f58421ff2d3b9a8b04500a96ac831 GitHub-Pull-Request: golang/go#50260 Reviewed-on: https://go-review.googlesource.com/c/go/+/373334 Reviewed-by: Ian Lance Taylor Reviewed-by: Emmanuel Odeke --- src/reflect/type.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/reflect/type.go b/src/reflect/type.go index 4e03dc3382..8ba63bcad0 100644 --- a/src/reflect/type.go +++ b/src/reflect/type.go @@ -229,7 +229,7 @@ type Type interface { // See https://golang.org/issue/4876 for more details. /* - * These data structures are known to the compiler (../../cmd/internal/reflectdata/reflect.go). + * These data structures are known to the compiler (../cmd/compile/internal/reflectdata/reflect.go). * A few are known to ../runtime/type.go to convey to debuggers. * They are also known to ../runtime/type.go. */ From cfb0cc355233d4367b188b23a3bc143985a28b8c Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 21 Dec 2021 10:00:23 -0800 Subject: [PATCH 535/752] cmd/link: use SHT_INIT_ARRAY for .init_array section Fixes #50295 Change-Id: If55ebcd5f2af724da7c9c744458a56d21a7ddde7 Reviewed-on: https://go-review.googlesource.com/c/go/+/373734 Trust: Ian Lance Taylor Reviewed-by: Cherry Mui --- misc/cgo/testcarchive/carchive_test.go | 178 +++++++++++++++++++++++++ src/cmd/link/internal/ld/elf.go | 7 +- 2 files changed, 184 insertions(+), 1 deletion(-) diff --git a/misc/cgo/testcarchive/carchive_test.go b/misc/cgo/testcarchive/carchive_test.go index c5193e3f19..a821396c77 100644 --- a/misc/cgo/testcarchive/carchive_test.go +++ b/misc/cgo/testcarchive/carchive_test.go @@ -10,6 +10,7 @@ import ( "debug/elf" "flag" "fmt" + "io" "io/fs" "log" "os" @@ -17,6 +18,7 @@ import ( "path/filepath" "regexp" "runtime" + "strconv" "strings" "syscall" "testing" @@ -287,6 +289,173 @@ func checkLineComments(t *testing.T, hdrname string) { } } +// checkArchive verifies that the created library looks OK. +// We just check a couple of things now, we can add more checks as needed. +func checkArchive(t *testing.T, arname string) { + t.Helper() + + switch GOOS { + case "aix", "darwin", "ios", "windows": + // We don't have any checks for non-ELF libraries yet. + if _, err := os.Stat(arname); err != nil { + t.Errorf("archive %s does not exist: %v", arname, err) + } + default: + checkELFArchive(t, arname) + } +} + +// checkELFArchive checks an ELF archive. +func checkELFArchive(t *testing.T, arname string) { + t.Helper() + + f, err := os.Open(arname) + if err != nil { + t.Errorf("archive %s does not exist: %v", arname, err) + return + } + defer f.Close() + + // TODO(iant): put these in a shared package? But where? + const ( + magic = "!\n" + fmag = "`\n" + + namelen = 16 + datelen = 12 + uidlen = 6 + gidlen = 6 + modelen = 8 + sizelen = 10 + fmaglen = 2 + hdrlen = namelen + datelen + uidlen + gidlen + modelen + sizelen + fmaglen + ) + + type arhdr struct { + name string + date string + uid string + gid string + mode string + size string + fmag string + } + + var magbuf [len(magic)]byte + if _, err := io.ReadFull(f, magbuf[:]); err != nil { + t.Errorf("%s: archive too short", arname) + return + } + if string(magbuf[:]) != magic { + t.Errorf("%s: incorrect archive magic string %q", arname, magbuf) + } + + off := int64(len(magic)) + for { + if off&1 != 0 { + var b [1]byte + if _, err := f.Read(b[:]); err != nil { + if err == io.EOF { + break + } + t.Errorf("%s: error skipping alignment byte at %d: %v", arname, off, err) + } + off++ + } + + var hdrbuf [hdrlen]byte + if _, err := io.ReadFull(f, hdrbuf[:]); err != nil { + if err == io.EOF { + break + } + t.Errorf("%s: error reading archive header at %d: %v", arname, off, err) + return + } + + var hdr arhdr + hdrslice := hdrbuf[:] + set := func(len int, ps *string) { + *ps = string(bytes.TrimSpace(hdrslice[:len])) + hdrslice = hdrslice[len:] + } + set(namelen, &hdr.name) + set(datelen, &hdr.date) + set(uidlen, &hdr.uid) + set(gidlen, &hdr.gid) + set(modelen, &hdr.mode) + set(sizelen, &hdr.size) + hdr.fmag = string(hdrslice[:fmaglen]) + hdrslice = hdrslice[fmaglen:] + if len(hdrslice) != 0 { + t.Fatalf("internal error: len(hdrslice) == %d", len(hdrslice)) + } + + if hdr.fmag != fmag { + t.Errorf("%s: invalid fmagic value %q at %d", arname, hdr.fmag, off) + return + } + + size, err := strconv.ParseInt(hdr.size, 10, 64) + if err != nil { + t.Errorf("%s: error parsing size %q at %d: %v", arname, hdr.size, off, err) + return + } + + off += hdrlen + + switch hdr.name { + case "__.SYMDEF", "/", "/SYM64/": + // The archive symbol map. + case "//", "ARFILENAMES/": + // The extended name table. + default: + // This should be an ELF object. + checkELFArchiveObject(t, arname, off, io.NewSectionReader(f, off, size)) + } + + off += size + if _, err := f.Seek(off, os.SEEK_SET); err != nil { + t.Errorf("%s: failed to seek to %d: %v", arname, off, err) + } + } +} + +// checkELFArchiveObject checks an object in an ELF archive. +func checkELFArchiveObject(t *testing.T, arname string, off int64, obj io.ReaderAt) { + t.Helper() + + ef, err := elf.NewFile(obj) + if err != nil { + t.Errorf("%s: failed to open ELF file at %d: %v", arname, off, err) + return + } + defer ef.Close() + + // Verify section types. + for _, sec := range ef.Sections { + want := elf.SHT_NULL + switch sec.Name { + case ".text", ".data": + want = elf.SHT_PROGBITS + case ".bss": + want = elf.SHT_NOBITS + case ".symtab": + want = elf.SHT_SYMTAB + case ".strtab": + want = elf.SHT_STRTAB + case ".init_array": + want = elf.SHT_INIT_ARRAY + case ".fini_array": + want = elf.SHT_FINI_ARRAY + case ".preinit_array": + want = elf.SHT_PREINIT_ARRAY + } + if want != elf.SHT_NULL && sec.Type != want { + t.Errorf("%s: incorrect section type in elf file at %d for section %q: got %v want %v", arname, off, sec.Name, sec.Type, want) + } + } +} + func TestInstall(t *testing.T) { if !testWork { defer os.RemoveAll(filepath.Join(GOPATH, "pkg")) @@ -345,6 +514,7 @@ func TestEarlySignalHandler(t *testing.T) { t.Fatal(err) } checkLineComments(t, "libgo2.h") + checkArchive(t, "libgo2.a") ccArgs := append(cc, "-o", "testp"+exeSuffix, "main2.c", "libgo2.a") if runtime.Compiler == "gccgo" { @@ -385,6 +555,7 @@ func TestSignalForwarding(t *testing.T) { t.Fatal(err) } checkLineComments(t, "libgo2.h") + checkArchive(t, "libgo2.a") ccArgs := append(cc, "-o", "testp"+exeSuffix, "main5.c", "libgo2.a") if runtime.Compiler == "gccgo" { @@ -437,6 +608,7 @@ func TestSignalForwardingExternal(t *testing.T) { t.Fatal(err) } checkLineComments(t, "libgo2.h") + checkArchive(t, "libgo2.a") ccArgs := append(cc, "-o", "testp"+exeSuffix, "main5.c", "libgo2.a") if runtime.Compiler == "gccgo" { @@ -554,6 +726,7 @@ func TestOsSignal(t *testing.T) { t.Fatal(err) } checkLineComments(t, "libgo3.h") + checkArchive(t, "libgo3.a") ccArgs := append(cc, "-o", "testp"+exeSuffix, "main3.c", "libgo3.a") if runtime.Compiler == "gccgo" { @@ -591,6 +764,7 @@ func TestSigaltstack(t *testing.T) { t.Fatal(err) } checkLineComments(t, "libgo4.h") + checkArchive(t, "libgo4.a") ccArgs := append(cc, "-o", "testp"+exeSuffix, "main4.c", "libgo4.a") if runtime.Compiler == "gccgo" { @@ -779,6 +953,7 @@ func TestSIGPROF(t *testing.T) { t.Fatal(err) } checkLineComments(t, "libgo6.h") + checkArchive(t, "libgo6.a") ccArgs := append(cc, "-o", "testp6"+exeSuffix, "main6.c", "libgo6.a") if runtime.Compiler == "gccgo" { @@ -824,6 +999,7 @@ func TestCompileWithoutShared(t *testing.T) { t.Fatal(err) } checkLineComments(t, "libgo2.h") + checkArchive(t, "libgo2.a") exe := "./testnoshared" + exeSuffix @@ -926,6 +1102,7 @@ func TestManyCalls(t *testing.T) { t.Fatal(err) } checkLineComments(t, "libgo7.h") + checkArchive(t, "libgo7.a") ccArgs := append(cc, "-o", "testp7"+exeSuffix, "main7.c", "libgo7.a") if runtime.Compiler == "gccgo" { @@ -985,6 +1162,7 @@ func TestPreemption(t *testing.T) { t.Fatal(err) } checkLineComments(t, "libgo8.h") + checkArchive(t, "libgo8.a") ccArgs := append(cc, "-o", "testp8"+exeSuffix, "main8.c", "libgo8.a") out, err = exec.Command(ccArgs[0], ccArgs[1:]...).CombinedOutput() diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go index 4a143dfcaa..1bdfb3369c 100644 --- a/src/cmd/link/internal/ld/elf.go +++ b/src/cmd/link/internal/ld/elf.go @@ -1080,7 +1080,12 @@ func elfshbits(linkmode LinkMode, sect *sym.Section) *ElfShdr { } if sect.Vaddr < sect.Seg.Vaddr+sect.Seg.Filelen { - sh.Type = uint32(elf.SHT_PROGBITS) + switch sect.Name { + case ".init_array": + sh.Type = uint32(elf.SHT_INIT_ARRAY) + default: + sh.Type = uint32(elf.SHT_PROGBITS) + } } else { sh.Type = uint32(elf.SHT_NOBITS) } From 9502339561fac403e0dd0b3d51409e97d44ac129 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 15 Dec 2021 16:30:15 -0800 Subject: [PATCH 536/752] doc/go1.18: mention new debug/elf.R_PPC64_RELATIVE constant For #47694 Change-Id: I9f4838100741d3ba13e9374e70466fa405c6e4d2 Reviewed-on: https://go-review.googlesource.com/c/go/+/372634 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Emmanuel Odeke --- doc/go1.18.html | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 5f6476908a..f0b4a923fb 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -483,7 +483,7 @@ Do not send CLs removing the interior tags from such phrases. The new Writer.AvailableBuffer method returns an empty buffer with a possibly non-empty capacity for use with append-like APIs. After appending, the buffer can be provided to a - succeeding Write call and possibly avoid any copying. + succeeding Write call and possibly avoid any copying.

    @@ -531,6 +531,15 @@ Do not send CLs removing the interior tags from such phrases. +

    debug/elf
    +
    +

    + The R_PPC64_RELATIVE + constant has been added. +

    +
    +
    +
    go/ast

    From a1ce5503c7a9518c96a231e3ff867d5c994afda2 Mon Sep 17 00:00:00 2001 From: Filippo Valsorda Date: Tue, 21 Dec 2021 11:49:38 -0500 Subject: [PATCH 537/752] all: update vendored golang.org/x/crypto for cryptobyte fix Fixes #49678 Change-Id: I47dd959a787180a67856e60dfa6eba3ddd045972 Reviewed-on: https://go-review.googlesource.com/c/go/+/373360 Run-TryBot: Filippo Valsorda Reviewed-by: Emmanuel Odeke TryBot-Result: Gopher Robot Trust: Filippo Valsorda --- src/cmd/go.mod | 2 +- src/cmd/go.sum | 4 +- src/cmd/vendor/modules.txt | 2 +- src/crypto/x509/x509_test.go | 95 +++++++++++++++++++ src/go.mod | 2 +- src/go.sum | 4 +- .../golang.org/x/crypto/cryptobyte/asn1.go | 7 +- src/vendor/modules.txt | 2 +- 8 files changed, 109 insertions(+), 9 deletions(-) diff --git a/src/cmd/go.mod b/src/cmd/go.mod index f46c770c19..6684fbf95d 100644 --- a/src/cmd/go.mod +++ b/src/cmd/go.mod @@ -13,7 +13,7 @@ require ( require ( github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d // indirect - golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa // indirect + golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3 // indirect golang.org/x/sys v0.0.0-20211205182925-97ca703d548d // indirect golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect ) diff --git a/src/cmd/go.sum b/src/cmd/go.sum index 941011fe09..9e20235497 100644 --- a/src/cmd/go.sum +++ b/src/cmd/go.sum @@ -7,8 +7,8 @@ github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d h1:uGg2frl github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d/go.mod h1:aYm2/VgdVmcIU8iMfdMvDMsRAQjcfZSKFby6HOFvi/w= golang.org/x/arch v0.0.0-20210923205945-b76863e36670 h1:18EFjUmQOcUvxNYSkA6jO9VAiXCnxFY6NyDX0bHDmkU= golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= -golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa h1:idItI2DDfCokpg0N51B2VtiLdJ4vAuXC9fnCb2gACo4= -golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3 h1:0es+/5331RGQPcXlMfP+WrnIIS6dNnNRe0WB02W0F4M= +golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/mod v0.6.0-dev.0.20211102181907-3a5865c02020 h1:HjtpZuJcnSa+yHlL4Y5aypjDvbHkJne5FS8JRmKI2+I= golang.org/x/mod v0.6.0-dev.0.20211102181907-3a5865c02020/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ= diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt index 22dd145a55..0762dee8f2 100644 --- a/src/cmd/vendor/modules.txt +++ b/src/cmd/vendor/modules.txt @@ -24,7 +24,7 @@ golang.org/x/arch/arm/armasm golang.org/x/arch/arm64/arm64asm golang.org/x/arch/ppc64/ppc64asm golang.org/x/arch/x86/x86asm -# golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa +# golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3 ## explicit; go 1.17 golang.org/x/crypto/ed25519 golang.org/x/crypto/ed25519/internal/edwards25519 diff --git a/src/crypto/x509/x509_test.go b/src/crypto/x509/x509_test.go index a42b852a42..69dcd11543 100644 --- a/src/crypto/x509/x509_test.go +++ b/src/crypto/x509/x509_test.go @@ -3253,3 +3253,98 @@ func TestAuthKeyIdOptional(t *testing.T) { t.Fatalf("ParseCertificate to failed to parse certificate with optional authority key identifier fields: %s", err) } } + +const largeOIDPEM = ` +Certificate: + Data: + Version: 3 (0x2) + Serial Number: + da:ba:53:19:1b:09:4b:82:b2:89:26:7d:c7:6f:a0:02 + Signature Algorithm: sha256WithRSAEncryption + Issuer: O = Acme Co + Validity + Not Before: Dec 21 16:59:27 2021 GMT + Not After : Dec 21 16:59:27 2022 GMT + Subject: O = Acme Co + Subject Public Key Info: + Public Key Algorithm: rsaEncryption + RSA Public-Key: (2048 bit) + Modulus: + 00:bf:17:16:d8:bc:29:9c:16:e5:76:b4:93:15:78: + ad:6e:45:c5:4a:63:46:a1:b2:76:71:65:51:9c:14: + c4:ea:74:13:e4:34:df:2f:2c:65:11:e8:56:52:69: + 11:f9:0e:fc:77:bb:63:a8:7c:1a:c6:a1:7b:6e:6c: + e7:18:25:25:c9:e8:fb:06:7f:a2:a9:98:fe:2a:bc: + 8a:b3:75:b6:b8:7d:b6:c9:6b:29:08:32:22:10:cb: + 8d:d6:60:c8:83:ad:f5:58:91:d6:11:e8:55:56:fb: + 8f:a3:a2:9f:48:cb:79:e4:65:4a:8c:a6:52:64:9f: + 99:38:35:d4:d5:ac:6f:cf:a0:cb:42:8c:07:eb:21: + 17:31:3a:eb:91:7b:62:43:a4:75:5f:ef:a7:2f:94: + f8:69:0b:d4:ec:09:e6:00:c0:8c:dd:07:63:0b:e4: + 77:aa:60:18:3c:a0:e0:ae:0a:ea:0e:52:3b:b4:fa: + 6a:30:1b:50:62:21:73:53:33:01:60:a1:6b:99:58: + 00:f3:77:c6:0f:46:19:ca:c2:5d:cd:f5:e2:52:4d: + 84:94:23:d3:32:2f:ae:5f:da:43:a1:19:95:d2:17: + dd:49:14:b4:d9:48:1c:08:13:93:8e:d5:09:43:21: + b6:ce:52:e8:87:bb:d2:60:0d:c6:4e:bf:c5:93:6a: + c6:bf + Exponent: 65537 (0x10001) + X509v3 extensions: + X509v3 Key Usage: critical + Digital Signature, Key Encipherment + X509v3 Extended Key Usage: + TLS Web Server Authentication + X509v3 Basic Constraints: critical + CA:FALSE + X509v3 Subject Alternative Name: + DNS:longOID.example + X509v3 Certificate Policies: + Policy: 1.3.6.1.4.1.311.21.8.1492336001 + + Signature Algorithm: sha256WithRSAEncryption + 72:77:8b:de:48:fb:6d:9a:94:b1:be:d4:90:7d:4c:e6:d3:79: + fa:fb:fc:3e:d5:3d:e9:a0:ce:28:2b:2f:94:77:3f:87:f8:9c: + 9f:91:1c:f3:f6:58:91:15:6b:24:b9:ca:ae:9f:ee:ca:c8:31: + db:1a:3d:bb:6b:83:6d:bc:81:8b:a1:79:d5:3e:bb:dd:93:fe: + 35:3e:b7:99:e0:d6:eb:58:0c:fd:42:73:dc:49:da:e2:b7:ae: + 15:ee:e6:cc:aa:ef:91:41:9a:18:46:8d:4a:39:65:a2:85:3c: + 7f:0c:41:f8:0b:9c:e8:1f:35:36:60:8d:8c:e0:8e:18:b1:06: + 57:d0:4e:c4:c3:cd:8f:6f:e7:76:02:52:da:03:43:61:2b:b3: + bf:19:fd:73:0d:6a:0b:b4:b6:cb:a9:6f:70:4e:53:2a:54:07: + b3:74:fd:85:49:57:5b:23:8d:8c:6b:53:2b:09:e8:41:a5:80: + 3f:69:1b:11:d1:6b:13:35:2e:f9:d6:50:15:d9:91:38:42:43: + e9:17:af:67:d9:96:a4:d1:6a:4f:cc:b4:a7:8e:48:1f:00:72: + 69:de:4d:f1:73:a4:47:12:67:e9:f9:07:3e:79:75:90:42:b8: + d4:b5:fd:d1:7e:35:04:f7:00:04:cf:f1:36:be:0f:27:81:1f: + a6:ba:88:6c +-----BEGIN CERTIFICATE----- +MIIDHTCCAgWgAwIBAgIRANq6UxkbCUuCsokmfcdvoAIwDQYJKoZIhvcNAQELBQAw +EjEQMA4GA1UEChMHQWNtZSBDbzAeFw0yMTEyMjExNjU5MjdaFw0yMjEyMjExNjU5 +MjdaMBIxEDAOBgNVBAoTB0FjbWUgQ28wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw +ggEKAoIBAQC/FxbYvCmcFuV2tJMVeK1uRcVKY0ahsnZxZVGcFMTqdBPkNN8vLGUR +6FZSaRH5Dvx3u2OofBrGoXtubOcYJSXJ6PsGf6KpmP4qvIqzdba4fbbJaykIMiIQ +y43WYMiDrfVYkdYR6FVW+4+jop9Iy3nkZUqMplJkn5k4NdTVrG/PoMtCjAfrIRcx +OuuRe2JDpHVf76cvlPhpC9TsCeYAwIzdB2ML5HeqYBg8oOCuCuoOUju0+mowG1Bi +IXNTMwFgoWuZWADzd8YPRhnKwl3N9eJSTYSUI9MyL65f2kOhGZXSF91JFLTZSBwI +E5OO1QlDIbbOUuiHu9JgDcZOv8WTasa/AgMBAAGjbjBsMA4GA1UdDwEB/wQEAwIF +oDATBgNVHSUEDDAKBggrBgEFBQcDATAMBgNVHRMBAf8EAjAAMBoGA1UdEQQTMBGC +D2xvbmdPSUQuZXhhbXBsZTAbBgNVHSAEFDASMBAGDisGAQQBgjcVCIXHzPsBMA0G +CSqGSIb3DQEBCwUAA4IBAQByd4veSPttmpSxvtSQfUzm03n6+/w+1T3poM4oKy+U +dz+H+JyfkRzz9liRFWskucqun+7KyDHbGj27a4NtvIGLoXnVPrvdk/41PreZ4Nbr +WAz9QnPcSdrit64V7ubMqu+RQZoYRo1KOWWihTx/DEH4C5zoHzU2YI2M4I4YsQZX +0E7Ew82Pb+d2AlLaA0NhK7O/Gf1zDWoLtLbLqW9wTlMqVAezdP2FSVdbI42Ma1Mr +CehBpYA/aRsR0WsTNS751lAV2ZE4QkPpF69n2Zak0WpPzLSnjkgfAHJp3k3xc6RH +Emfp+Qc+eXWQQrjUtf3RfjUE9wAEz/E2vg8ngR+muohs +-----END CERTIFICATE-----` + +func TestLargeOID(t *testing.T) { + // See Issue 49678. + b, _ := pem.Decode([]byte(largeOIDPEM)) + if b == nil { + t.Fatalf("couldn't decode test certificate") + } + _, err := ParseCertificate(b.Bytes) + if err != nil { + t.Fatalf("ParseCertificate to failed to parse certificate with large OID: %s", err) + } +} diff --git a/src/go.mod b/src/go.mod index 07d0acf2bd..bd6308add0 100644 --- a/src/go.mod +++ b/src/go.mod @@ -3,7 +3,7 @@ module std go 1.18 require ( - golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa + golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3 golang.org/x/net v0.0.0-20211209124913-491a49abca63 ) diff --git a/src/go.sum b/src/go.sum index cec5bc4d0e..8bf08531de 100644 --- a/src/go.sum +++ b/src/go.sum @@ -1,5 +1,5 @@ -golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa h1:idItI2DDfCokpg0N51B2VtiLdJ4vAuXC9fnCb2gACo4= -golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3 h1:0es+/5331RGQPcXlMfP+WrnIIS6dNnNRe0WB02W0F4M= +golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/net v0.0.0-20211209124913-491a49abca63 h1:iocB37TsdFuN6IBRZ+ry36wrkoV51/tl5vOWqkcPGvY= golang.org/x/net v0.0.0-20211209124913-491a49abca63/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/sys v0.0.0-20211205182925-97ca703d548d h1:FjkYO/PPp4Wi0EAUOVLxePm7qVW4r4ctbWpURyuOD0E= diff --git a/src/vendor/golang.org/x/crypto/cryptobyte/asn1.go b/src/vendor/golang.org/x/crypto/cryptobyte/asn1.go index 83c776de08..3a1674a1e5 100644 --- a/src/vendor/golang.org/x/crypto/cryptobyte/asn1.go +++ b/src/vendor/golang.org/x/crypto/cryptobyte/asn1.go @@ -407,7 +407,12 @@ func (s *String) ReadASN1Enum(out *int) bool { func (s *String) readBase128Int(out *int) bool { ret := 0 for i := 0; len(*s) > 0; i++ { - if i == 4 { + if i == 5 { + return false + } + // Avoid overflowing int on a 32-bit platform. + // We don't want different behavior based on the architecture. + if ret >= 1<<(31-7) { return false } ret <<= 7 diff --git a/src/vendor/modules.txt b/src/vendor/modules.txt index 4130027c7f..3a975cde9e 100644 --- a/src/vendor/modules.txt +++ b/src/vendor/modules.txt @@ -1,4 +1,4 @@ -# golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa +# golang.org/x/crypto v0.0.0-20211215153901-e495a2d5b3d3 ## explicit; go 1.17 golang.org/x/crypto/chacha20 golang.org/x/crypto/chacha20poly1305 From 60f2c12a85470c87ef9c49d6f79458f575612e0d Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 21 Dec 2021 12:04:57 -0800 Subject: [PATCH 538/752] doc/go1.18: mention new go/types/Config.Context field For #47694 For #47916 Change-Id: Ieeffaf161da744adfdb4da8aac58a64c109ebcab Reviewed-on: https://go-review.googlesource.com/c/go/+/373775 Trust: Ian Lance Taylor Reviewed-by: Robert Findley --- doc/go1.18.html | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index f0b4a923fb..5f4cc591b7 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -587,10 +587,10 @@ Do not send CLs removing the interior tags from such phrases.

    go/types
    -

    - The new Config.GoVersion - field sets the accepted Go language version. -

    +

    + The new Config.GoVersion + field sets the accepted Go language version. +

    Per the proposal @@ -669,7 +669,10 @@ Do not send CLs removing the interior tags from such phrases.

  • The new type Context and factory function NewContext - are added to facilitate sharing of identical type instances across type-checked packages. + are added to facilitate sharing of identical type instances + across type-checked packages, via the new + Config.Context + field.
    • From 3fb17cfd17108c0c49d8a58cf25610fe5c84755a Mon Sep 17 00:00:00 2001 From: Tobias Klauser Date: Tue, 21 Dec 2021 13:13:01 +0100 Subject: [PATCH 539/752] os: enable TestPipeThreads on FreeBSD This test works on FreeBSD since CL 165801 was submitted. Updates #19093 Change-Id: I45ffeb403c1de4385cdb21b9647f21976061e1ea Reviewed-on: https://go-review.googlesource.com/c/go/+/373358 Trust: Tobias Klauser Reviewed-by: Ian Lance Taylor --- src/os/os_test.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/os/os_test.go b/src/os/os_test.go index 717330e86a..5a813e0a7d 100644 --- a/src/os/os_test.go +++ b/src/os/os_test.go @@ -2434,8 +2434,6 @@ func TestRemoveAllRace(t *testing.T) { // Test that reading from a pipe doesn't use up a thread. func TestPipeThreads(t *testing.T) { switch runtime.GOOS { - case "freebsd": - t.Skip("skipping on FreeBSD; issue 19093") case "illumos", "solaris": t.Skip("skipping on Solaris and illumos; issue 19111") case "windows": From ebac50e9cef66920ecfe018252ffdc2294a0c249 Mon Sep 17 00:00:00 2001 From: Carl Johnson Date: Sat, 18 Dec 2021 02:54:22 +0000 Subject: [PATCH 540/752] doc/go1.18: add net/http.MaxBytesHandler For #47694 Change-Id: Ifab2c2720ec2ccef175a0e14a95f8df0437eb009 GitHub-Last-Rev: f3c2f12c7b6472610428cff5cad2a4497c47150e GitHub-Pull-Request: golang/go#50250 Reviewed-on: https://go-review.googlesource.com/c/go/+/373015 Reviewed-by: Ian Lance Taylor Reviewed-by: Emmanuel Odeke --- doc/go1.18.html | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 5f4cc591b7..90bc0aa132 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -713,6 +713,14 @@ Do not send CLs removing the interior tags from such phrases. Cookie.Valid method reports whether the cookie is valid.

    + +

    + The new + MaxBytesHandler + function creates a Handler

    code> that wraps its + ResponseWriter and Request.Body with a + MaxBytesReader. +

    From 90fb5a4f97a11bb3aa4a6143ec687d20b35ef010 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 21 Dec 2021 14:44:27 -0800 Subject: [PATCH 541/752] doc/go1.18: document {text,html}/template {break,continue} commands For #20531 For #47694 Change-Id: Iaefaa0a8982eabf59cd6a53120c8af9124d60d1a Reviewed-on: https://go-review.googlesource.com/c/go/+/373915 Trust: Ian Lance Taylor Reviewed-by: Emmanuel Odeke --- doc/go1.18.html | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 90bc0aa132..cea45542db 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -678,6 +678,17 @@ Do not send CLs removing the interior tags from such phrases. +
    html/template
    +
    +

    + Within a range pipeline the new + {{break}} command will end the loop early and the + new {{continue}} command will immediately start the + next loop iteration. +

    +
    +
    +
    image/draw

    @@ -907,6 +918,13 @@ Do not send CLs removing the interior tags from such phrases.

    text/template
    +

    + Within a range pipeline the new + {{break}} command will end the loop early and the + new {{continue}} command will immediately start the + next loop iteration. +

    +

    The and function no longer always evaluates all arguments; it stops evaluating arguments after the first argument that evaluates to @@ -917,6 +935,25 @@ Do not send CLs removing the interior tags from such phrases.

    +
    text/template/parse
    +
    +

    + The package supports the new + text/template and + html/template + {{break}} command via the new constant + NodeBreak + and the new type + BreakNode, + and similarly supports the new {{continue}} command + via the new constant + NodeContinue + and the new type + ContinueNode. +

    +
    +
    +
    unicode/utf8

    From d7b035f930549bc6b6192f73351bce138130350e Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 21 Dec 2021 14:33:47 -0800 Subject: [PATCH 542/752] doc/go1.18: mention testing.F in testing package section For #47694 Change-Id: I27d88d864319bd8dbabfa6675a6abf2f74c50717 Reviewed-on: https://go-review.googlesource.com/c/go/+/373914 Trust: Ian Lance Taylor Reviewed-by: Katie Hockman Trust: Katie Hockman --- doc/go1.18.html | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index cea45542db..a1d1a72552 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -913,6 +913,12 @@ Do not send CLs removing the interior tags from such phrases. existing tests in the unlikely case that a test changes the set of subtests that are run each time the test function itself is run.

    + +

    + The new testing.F type + is used by the new fuzzing support described + above. +

    From 0f3becf62f3935846490e60e5005e1e4a55bec67 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 21 Dec 2021 12:23:53 -0800 Subject: [PATCH 543/752] doc/go1.18: list new net/netip and net functions and methods For #46518 For #47694 Change-Id: I4848556674baf85ceec350645d9eddcd83f1b2e0 Reviewed-on: https://go-review.googlesource.com/c/go/+/373834 Trust: Ian Lance Taylor Trust: Brad Fitzpatrick Reviewed-by: Brad Fitzpatrick --- doc/go1.18.html | 34 ++++++++++++++++++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index a1d1a72552..9c839bdc8f 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -457,16 +457,46 @@ Do not send CLs removing the interior tags from such phrases. Prefix, representing a network CIDR prefix.

    +

    + The package also defines several functions to create and examine + these new types: + AddrFrom4, + AddrFrom16, + AddrFromSlice, + AddrPortFrom, + IPv4Unspecified, + IPv6LinkLocalAllNodes, + IPv6Unspecified, + MustParseAddr, + MustParseAddrPort, + MustParsePrefix, + ParseAddr, + ParseAddrPort, + ParsePrefix, + PrefixFrom. +

    The net package includes new methods that parallel existing methods, but return netip.AddrPort instead of the heavier-weight net.IP or - *net.UDPAddr types. + *net.UDPAddr types: + Resolver.LookupNetIP, + UDPConn.ReadFromUDPAddrPort, + UDPConn.ReadMsgUDPAddrPort, + UDPConn.WriteToUDPAddrPort, + UDPConn.WriteMsgUDPAddrPort. + The new UDPConn methods support allocation-free I/O. +

    +

    The net package also now includes functions and methods to convert between the existing TCPAddr/UDPAddr - types and netip.AddrPort. + types and netip.AddrPort: + TCPAddrFromAddrPort, + UDPAddrFromAddrPort, + TCPAddr.AddrPort, + UDPAddr.AddrPort.

    Minor changes to the library

    From 8cfcee1fffb9429e318549ad0a2cae2046798e48 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Wed, 22 Dec 2021 11:43:06 -0500 Subject: [PATCH 544/752] runtime: handle stray profiling signal better In c-archive mode, when we turn off profiling, we restore the previous handler for SIGPROF, and ignore SIGPROF signals if no handler was installed. So if a pending signal lands after we remove the Go signal handler, it will not kill the program. In the current code there is a small window, where we can still receive signals but we are set to not handling the signal. If a signal lands in this window (possibly on another thread), it will see that we are not handling this signal and no previous handler installed, and kill the program. To avoid this race, we set the previous handler to SIG_IGN (ignoring the signal) when turning on profiling. So when turning off profiling we'll ignore the signal even if a stray signal lands in the small window. Fixes #43828. Change-Id: I304bc85a93ca0e63b0c0d8e902b097bfdc8e3f1d Reviewed-on: https://go-review.googlesource.com/c/go/+/374074 Trust: Cherry Mui Reviewed-by: Ian Lance Taylor --- src/runtime/signal_unix.go | 31 ++++++++++++++++++------------- 1 file changed, 18 insertions(+), 13 deletions(-) diff --git a/src/runtime/signal_unix.go b/src/runtime/signal_unix.go index dbcbfc67bc..08f266cc67 100644 --- a/src/runtime/signal_unix.go +++ b/src/runtime/signal_unix.go @@ -271,7 +271,24 @@ func setProcessCPUProfilerTimer(hz int32) { if hz != 0 { // Enable the Go signal handler if not enabled. if atomic.Cas(&handlingSig[_SIGPROF], 0, 1) { - atomic.Storeuintptr(&fwdSig[_SIGPROF], getsig(_SIGPROF)) + h := getsig(_SIGPROF) + // If no signal handler was installed before, then we record + // _SIG_IGN here. When we turn off profiling (below) we'll start + // ignoring SIGPROF signals. We do this, rather than change + // to SIG_DFL, because there may be a pending SIGPROF + // signal that has not yet been delivered to some other thread. + // If we change to SIG_DFL when turning off profiling, the + // program will crash when that SIGPROF is delivered. We assume + // that programs that use profiling don't want to crash on a + // stray SIGPROF. See issue 19320. + // We do the change here instead of when turning off profiling, + // because there we may race with a signal handler running + // concurrently, in particular, sigfwdgo may observe _SIG_DFL and + // die. See issue 43828. + if h == _SIG_DFL { + h = _SIG_IGN + } + atomic.Storeuintptr(&fwdSig[_SIGPROF], h) setsig(_SIGPROF, abi.FuncPCABIInternal(sighandler)) } @@ -288,21 +305,9 @@ func setProcessCPUProfilerTimer(hz int32) { // when we enabled profiling. We don't try to handle the case // of a program that changes the SIGPROF handler while Go // profiling is enabled. - // - // If no signal handler was installed before, then start - // ignoring SIGPROF signals. We do this, rather than change - // to SIG_DFL, because there may be a pending SIGPROF - // signal that has not yet been delivered to some other thread. - // If we change to SIG_DFL here, the program will crash - // when that SIGPROF is delivered. We assume that programs - // that use profiling don't want to crash on a stray SIGPROF. - // See issue 19320. if !sigInstallGoHandler(_SIGPROF) { if atomic.Cas(&handlingSig[_SIGPROF], 1, 0) { h := atomic.Loaduintptr(&fwdSig[_SIGPROF]) - if h == _SIG_DFL { - h = _SIG_IGN - } setsig(_SIGPROF, h) } } From d2ce93960448559a7cb5685661502d8fc0c2ebc1 Mon Sep 17 00:00:00 2001 From: Carl Johnson Date: Wed, 22 Dec 2021 04:23:26 +0000 Subject: [PATCH 545/752] doc/go1.18: fix broken HTML in net/http.MaxBytesHandler For #47694 Sorry about that! I guess the autocompleter in VSCode auto-closed the paragraph and I didn't notice. Change-Id: I1e834e47deb708cd5285d26201a442305f8c3b24 GitHub-Last-Rev: ab8873155191072efd51270c85fc6feaed318cdc GitHub-Pull-Request: golang/go#50305 Reviewed-on: https://go-review.googlesource.com/c/go/+/374014 Reviewed-by: Ian Lance Taylor Trust: Dmitri Shuralyov --- doc/go1.18.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 9c839bdc8f..4d5184017e 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -758,7 +758,7 @@ Do not send CLs removing the interior tags from such phrases.

    The new MaxBytesHandler - function creates a Handler

    code> that wraps its + function creates a Handler that wraps its ResponseWriter and Request.Body with a MaxBytesReader.

    From ed766b6ffbf9f0b3efc5cb2790cb9bb3a4af856d Mon Sep 17 00:00:00 2001 From: zhangjian Date: Thu, 23 Dec 2021 14:21:41 +0000 Subject: [PATCH 546/752] cmd/compile/internal/ir: fix a typo in node.go README.md -> HACKING.md Change-Id: I63909b86b2e6f8d9a34622f5d2b05048c79cd698 GitHub-Last-Rev: afaab8f05eff1d66c796909ccf9912e0f4e99754 GitHub-Pull-Request: golang/go#50326 Reviewed-on: https://go-review.googlesource.com/c/go/+/374274 Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: Dan Scales Trust: Dan Scales Reviewed-by: Emmanuel Odeke --- src/cmd/compile/internal/ir/node.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go index 4fdee5010b..5fdccf8927 100644 --- a/src/cmd/compile/internal/ir/node.go +++ b/src/cmd/compile/internal/ir/node.go @@ -471,7 +471,7 @@ const ( UintptrEscapes // pointers converted to uintptr escape // Runtime-only func pragmas. - // See ../../../../runtime/README.md for detailed descriptions. + // See ../../../../runtime/HACKING.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 From af3b8cf5026a9d74a53ac5d3fec2bba35a96ad91 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Thu, 23 Dec 2021 13:09:02 -0500 Subject: [PATCH 547/752] cmd/go: remove MallocNanoZone environment variable workaround We added a workaround in runtime/race. This should not be necessary now. Updates #49138. Change-Id: Ia2010e4acc95c4ddf5f463ab2919401d893c0bac Reviewed-on: https://go-review.googlesource.com/c/go/+/374314 Trust: Cherry Mui Run-TryBot: Cherry Mui Reviewed-by: Ian Lance Taylor TryBot-Result: Gopher Robot --- src/cmd/go/script_test.go | 1 - 1 file changed, 1 deletion(-) diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go index dbfba2291c..7adbc71a89 100644 --- a/src/cmd/go/script_test.go +++ b/src/cmd/go/script_test.go @@ -146,7 +146,6 @@ var extraEnvKeys = []string{ "GO_TESTING_GOTOOLS", // for gccgo testing "GCCGO", // for gccgo testing "GCCGOTOOLDIR", // for gccgo testing - "MallocNanoZone", // Needed to work around an apparent kernel bug in macOS 12; see https://golang.org/issue/49138. } // setup sets up the test execution temporary directory and environment. From 0e4b878258ffc3fca6a8fc6a98ebd81fc933b249 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 21 Dec 2021 11:59:19 -0800 Subject: [PATCH 548/752] doc/go1.18: mention debug/plan9obj.ErrNoSymbols For #47694 For #48052 Change-Id: I136be9b498033309d876099aae16bad330555416 Reviewed-on: https://go-review.googlesource.com/c/go/+/373774 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Tobias Klauser --- doc/go1.18.html | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 4d5184017e..a87e3f45f1 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -570,6 +570,17 @@ Do not send CLs removing the interior tags from such phrases.
    +
    debug/plan9obj
    +
    +

    + The File.Symbols + method now returns the new exported error + value ErrNoSymbols + if the file has no symbol section. +

    +
    +
    +
    go/ast

    From b357b05b70d2b8c4988ac2a27f2af176e7a09e1b Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 21 Dec 2021 13:58:15 -0800 Subject: [PATCH 549/752] doc/go1.18: add section for runtime/debug changes For #37475 For #47694 Change-Id: If8c1f1b756daf32648110f1a669b2ea60f797a24 Reviewed-on: https://go-review.googlesource.com/c/go/+/373875 Trust: Ian Lance Taylor Reviewed-by: Emmanuel Odeke --- doc/go1.18.html | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index a87e3f45f1..4907dd6e2d 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -856,6 +856,27 @@ Do not send CLs removing the interior tags from such phrases.

    +
    runtime/debug
    +
    +

    + The BuildInfo + struct has two new fields, containing additional information + about how the binary was built: +

      +
    • GoVersion + holds the version of Go used to build the binary. +
      • +
    • + Settings + is a slice of + BuildSettings + structs holding key/value pairs describing the build. +
      • +
    +

    +
    +
    +
    strconv

    From a78532a4121d26c33ee3ce69b3dda3a608f5a077 Mon Sep 17 00:00:00 2001 From: Meng Zhuo Date: Fri, 17 Dec 2021 14:15:42 +0800 Subject: [PATCH 550/752] runtime: invalid negative frequency while tracing The riscv64 Hifive Unmatched is the only platform that failed on testcase TestAnalyzeAnnotations occasionally after CL 332954 had merged. The failure happens when ticks per second (freq) is over 1e12 which causing the timestamps of two events are same. There are 2 reasons causing big frequency: 1. RDCYCLE is HART based according to the riscv manual which makes negative ticks delta 2. negative float64 -> uint64 is undefined and "lucky" negative float is too big to handle for trace For #46737 Change-Id: I1f3c1ac31aae249969000c719c32aaf5a66d29a5 Reviewed-on: https://go-review.googlesource.com/c/go/+/373034 Trust: Zhuo Meng Run-TryBot: Zhuo Meng TryBot-Result: Gopher Robot Reviewed-by: Cherry Mui Reviewed-by: Michael Knyszek --- src/runtime/asm_riscv64.s | 5 ++++- src/runtime/trace.go | 3 +++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/src/runtime/asm_riscv64.s b/src/runtime/asm_riscv64.s index 0e813189d4..2a4837b399 100644 --- a/src/runtime/asm_riscv64.s +++ b/src/runtime/asm_riscv64.s @@ -81,7 +81,10 @@ TEXT setg_gcc<>(SB),NOSPLIT,$0-0 // func cputicks() int64 TEXT runtime·cputicks(SB),NOSPLIT,$0-8 - RDCYCLE A0 + // RDTIME to emulate cpu ticks + // RDCYCLE reads counter that is per HART(core) based + // according to the riscv manual, see issue 46737 + RDTIME A0 MOV A0, ret+0(FP) RET diff --git a/src/runtime/trace.go b/src/runtime/trace.go index 5b14a5f553..71a29d4316 100644 --- a/src/runtime/trace.go +++ b/src/runtime/trace.go @@ -426,6 +426,9 @@ func ReadTrace() []byte { trace.footerWritten = true // Use float64 because (trace.ticksEnd - trace.ticksStart) * 1e9 can overflow int64. freq := float64(trace.ticksEnd-trace.ticksStart) * 1e9 / float64(trace.timeEnd-trace.timeStart) / traceTickDiv + if freq <= 0 { + throw("trace: ReadTrace got invalid frequency") + } trace.lockOwner = nil unlock(&trace.lock) var data []byte From 91e782106ea465acc6a4c719081cefb690b28533 Mon Sep 17 00:00:00 2001 From: fanzha02 Date: Mon, 27 Dec 2021 16:38:48 +0800 Subject: [PATCH 551/752] runtime: fix the issue that the -asan option cannot print where the error occurred The current -asan option does not print where the error occurred. The reason is that the current implementation calls incorrect asan runtime functions, which do not pass sp and pc where asan runtime functions are called, and report the stack trace from the native code. But asan runtime functions are called from cgo on a separated stack, so it cannot dump the Go stack trace correctly. The correct asan runtime function we should call is __asan_report_error, which will pass sp and pc, and report where the error occurred correctly. This patch fixes this issue. Add the test cases. Fixes #50362 Change-Id: I12ee1d46c7ae069ddef3d23f2fe86e112db60045 Reviewed-on: https://go-review.googlesource.com/c/go/+/374395 Trust: Fannie Zhang Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- misc/cgo/testsanitizers/asan_test.go | 13 +++++--- misc/cgo/testsanitizers/cc_test.go | 2 ++ .../cgo/testsanitizers/testdata/asan1_fail.go | 2 +- .../cgo/testsanitizers/testdata/asan2_fail.go | 2 +- src/runtime/asan.go | 27 ++++++++++++---- src/runtime/asan/asan.go | 31 +++---------------- src/runtime/asan_amd64.s | 20 ++++++++---- src/runtime/asan_arm64.s | 24 ++++++++------ 8 files changed, 67 insertions(+), 54 deletions(-) diff --git a/misc/cgo/testsanitizers/asan_test.go b/misc/cgo/testsanitizers/asan_test.go index dbcce2fe28..cd1e9f354b 100644 --- a/misc/cgo/testsanitizers/asan_test.go +++ b/misc/cgo/testsanitizers/asan_test.go @@ -33,11 +33,12 @@ func TestASAN(t *testing.T) { cases := []struct { src string memoryAccessError string + errorLocation string }{ - {src: "asan1_fail.go", memoryAccessError: "heap-use-after-free"}, - {src: "asan2_fail.go", memoryAccessError: "heap-buffer-overflow"}, - {src: "asan3_fail.go", memoryAccessError: "use-after-poison"}, - {src: "asan4_fail.go", memoryAccessError: "use-after-poison"}, + {src: "asan1_fail.go", memoryAccessError: "heap-use-after-free", errorLocation: "asan1_fail.go:25"}, + {src: "asan2_fail.go", memoryAccessError: "heap-buffer-overflow", errorLocation: "asan2_fail.go:31"}, + {src: "asan3_fail.go", memoryAccessError: "use-after-poison", errorLocation: "asan3_fail.go:13"}, + {src: "asan4_fail.go", memoryAccessError: "use-after-poison", errorLocation: "asan4_fail.go:13"}, {src: "asan_useAfterReturn.go"}, } for _, tc := range cases { @@ -56,6 +57,10 @@ func TestASAN(t *testing.T) { if tc.memoryAccessError != "" { out, err := cmd.CombinedOutput() if err != nil && strings.Contains(string(out), tc.memoryAccessError) { + // Check if -asan option can correctly print where the error occured. + if tc.errorLocation != "" && !strings.Contains(string(out), tc.errorLocation) { + t.Errorf("%#q exited without expected location of the error\n%s; got failure\n%s", strings.Join(cmd.Args, " "), tc.errorLocation, out) + } return } t.Fatalf("%#q exited without expected memory access error\n%s; got failure\n%s", strings.Join(cmd.Args, " "), tc.memoryAccessError, out) diff --git a/misc/cgo/testsanitizers/cc_test.go b/misc/cgo/testsanitizers/cc_test.go index b776afa3e6..0ce4f75935 100644 --- a/misc/cgo/testsanitizers/cc_test.go +++ b/misc/cgo/testsanitizers/cc_test.go @@ -269,6 +269,8 @@ func configure(sanitizer string) *config { case "address": c.goFlags = append(c.goFlags, "-asan") + // Set the debug mode to print the C stack trace. + c.cFlags = append(c.cFlags, "-g") default: panic(fmt.Sprintf("unrecognized sanitizer: %q", sanitizer)) diff --git a/misc/cgo/testsanitizers/testdata/asan1_fail.go b/misc/cgo/testsanitizers/testdata/asan1_fail.go index e60db76981..80289e5c30 100644 --- a/misc/cgo/testsanitizers/testdata/asan1_fail.go +++ b/misc/cgo/testsanitizers/testdata/asan1_fail.go @@ -22,7 +22,7 @@ func main() { // C passes Go an invalid pointer. a := C.test() // Use after free - *a = 2 + *a = 2 // BOOM // We shouldn't get here; asan should stop us first. fmt.Println(*a) } diff --git a/misc/cgo/testsanitizers/testdata/asan2_fail.go b/misc/cgo/testsanitizers/testdata/asan2_fail.go index e35670c440..3ab0608571 100644 --- a/misc/cgo/testsanitizers/testdata/asan2_fail.go +++ b/misc/cgo/testsanitizers/testdata/asan2_fail.go @@ -28,7 +28,7 @@ func main() { a := C.f() q5 := (*C.int)(unsafe.Add(unsafe.Pointer(a), 4*5)) // Access to C pointer out of bounds. - *q5 = 100 + *q5 = 100 // BOOM // We shouldn't get here; asan should stop us first. fmt.Printf("q5: %d, %x\n", *q5, q5) } diff --git a/src/runtime/asan.go b/src/runtime/asan.go index a22b56bb07..affafd4d8d 100644 --- a/src/runtime/asan.go +++ b/src/runtime/asan.go @@ -11,23 +11,38 @@ import ( ) // Public address sanitizer API. - func ASanRead(addr unsafe.Pointer, len int) { - asanread(addr, uintptr(len)) + sp := getcallersp() + pc := getcallerpc() + doasanread(addr, uintptr(len), sp, pc) } func ASanWrite(addr unsafe.Pointer, len int) { - asanwrite(addr, uintptr(len)) + sp := getcallersp() + pc := getcallerpc() + doasanwrite(addr, uintptr(len), sp, pc) } // Private interface for the runtime. const asanenabled = true -//go:noescape -func asanread(addr unsafe.Pointer, sz uintptr) +func asanread(addr unsafe.Pointer, sz uintptr) { + sp := getcallersp() + pc := getcallerpc() + doasanread(addr, sz, sp, pc) +} + +func asanwrite(addr unsafe.Pointer, sz uintptr) { + sp := getcallersp() + pc := getcallerpc() + doasanwrite(addr, sz, sp, pc) +} //go:noescape -func asanwrite(addr unsafe.Pointer, sz uintptr) +func doasanread(addr unsafe.Pointer, sz, sp, pc uintptr) + +//go:noescape +func doasanwrite(addr unsafe.Pointer, sz, sp, pc uintptr) //go:noescape func asanunpoison(addr unsafe.Pointer, sz uintptr) diff --git a/src/runtime/asan/asan.go b/src/runtime/asan/asan.go index eb66b3aab5..bab2362c51 100644 --- a/src/runtime/asan/asan.go +++ b/src/runtime/asan/asan.go @@ -14,38 +14,15 @@ package asan #include #include -extern void __asan_report_load1(void*); -extern void __asan_report_load2(void*); -extern void __asan_report_load4(void*); -extern void __asan_report_load8(void*); -extern void __asan_report_load_n(void*, uintptr_t); -extern void __asan_report_store1(void*); -extern void __asan_report_store2(void*); -extern void __asan_report_store4(void*); -extern void __asan_report_store8(void*); -extern void __asan_report_store_n(void*, uintptr_t); - -void __asan_read_go(void *addr, uintptr_t sz) { +void __asan_read_go(void *addr, uintptr_t sz, void *sp, void *pc) { if (__asan_region_is_poisoned(addr, sz)) { - switch (sz) { - case 1: __asan_report_load1(addr); break; - case 2: __asan_report_load2(addr); break; - case 4: __asan_report_load4(addr); break; - case 8: __asan_report_load8(addr); break; - default: __asan_report_load_n(addr, sz); break; - } + __asan_report_error(pc, 0, sp, addr, false, sz); } } -void __asan_write_go(void *addr, uintptr_t sz) { +void __asan_write_go(void *addr, uintptr_t sz, void *sp, void *pc) { if (__asan_region_is_poisoned(addr, sz)) { - switch (sz) { - case 1: __asan_report_store1(addr); break; - case 2: __asan_report_store2(addr); break; - case 4: __asan_report_store4(addr); break; - case 8: __asan_report_store8(addr); break; - default: __asan_report_store_n(addr, sz); break; - } + __asan_report_error(pc, 0, sp, addr, true, sz); } } diff --git a/src/runtime/asan_amd64.s b/src/runtime/asan_amd64.s index e8de80399b..3857350020 100644 --- a/src/runtime/asan_amd64.s +++ b/src/runtime/asan_amd64.s @@ -15,25 +15,33 @@ #ifdef GOOS_windows #define RARG0 CX #define RARG1 DX +#define RARG2 R8 +#define RARG3 R9 #else #define RARG0 DI #define RARG1 SI +#define RARG2 DX +#define RARG3 CX #endif // Called from intrumented code. -// func runtime·asanread(addr unsafe.Pointer, sz uintptr) -TEXT runtime·asanread(SB), NOSPLIT, $0-16 +// func runtime·doasanread(addr unsafe.Pointer, sz, sp, pc uintptr) +TEXT runtime·doasanread(SB), NOSPLIT, $0-32 MOVQ addr+0(FP), RARG0 MOVQ size+8(FP), RARG1 - // void __asan_read_go(void *addr, uintptr_t sz); + MOVQ sp+16(FP), RARG2 + MOVQ pc+24(FP), RARG3 + // void __asan_read_go(void *addr, uintptr_t sz, void *sp, void *pc); MOVQ $__asan_read_go(SB), AX JMP asancall<>(SB) -// func runtime·asanwrite(addr unsafe.Pointer, sz uintptr) -TEXT runtime·asanwrite(SB), NOSPLIT, $0-16 +// func runtime·doasanwrite(addr unsafe.Pointer, sz, sp, pc uintptr) +TEXT runtime·doasanwrite(SB), NOSPLIT, $0-32 MOVQ addr+0(FP), RARG0 MOVQ size+8(FP), RARG1 - // void __asan_write_go(void *addr, uintptr_t sz); + MOVQ sp+16(FP), RARG2 + MOVQ pc+24(FP), RARG3 + // void __asan_write_go(void *addr, uintptr_t sz, void *sp, void *pc); MOVQ $__asan_write_go(SB), AX JMP asancall<>(SB) diff --git a/src/runtime/asan_arm64.s b/src/runtime/asan_arm64.s index acae200fb5..5ed03c932b 100644 --- a/src/runtime/asan_arm64.s +++ b/src/runtime/asan_arm64.s @@ -9,22 +9,28 @@ #define RARG0 R0 #define RARG1 R1 -#define FARG R3 +#define RARG2 R2 +#define RARG3 R3 +#define FARG R4 // Called from instrumented code. -// func runtime·asanread(addr unsafe.Pointer, sz uintptr) -TEXT runtime·asanread(SB), NOSPLIT, $0-16 +// func runtime·doasanread(addr unsafe.Pointer, sz, sp, pc uintptr) +TEXT runtime·doasanread(SB), NOSPLIT, $0-32 MOVD addr+0(FP), RARG0 MOVD size+8(FP), RARG1 - // void __asan_read_go(void *addr, uintptr_t sz); + MOVD sp+16(FP), RARG2 + MOVD pc+24(FP), RARG3 + // void __asan_read_go(void *addr, uintptr_t sz, void *sp, void *pc); MOVD $__asan_read_go(SB), FARG JMP asancall<>(SB) -// func runtime·asanwrite(addr unsafe.Pointer, sz uintptr) -TEXT runtime·asanwrite(SB), NOSPLIT, $0-16 +// func runtime·doasanwrite(addr unsafe.Pointer, sz, sp, pc uintptr) +TEXT runtime·doasanwrite(SB), NOSPLIT, $0-32 MOVD addr+0(FP), RARG0 MOVD size+8(FP), RARG1 - // void __asan_write_go(void *addr, uintptr_t sz); + MOVD sp+16(FP), RARG2 + MOVD pc+24(FP), RARG3 + // void __asan_write_go(void *addr, uintptr_t sz, void *sp, void *pc); MOVD $__asan_write_go(SB), FARG JMP asancall<>(SB) @@ -53,8 +59,8 @@ TEXT asancall<>(SB), NOSPLIT, $0-0 CMP R11, g BEQ g0stack - MOVD (g_sched+gobuf_sp)(R11), R4 - MOVD R4, RSP + MOVD (g_sched+gobuf_sp)(R11), R5 + MOVD R5, RSP g0stack: BL (FARG) From 8a306e205663cde672e9920e2e81db9d3615e6c0 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 29 Dec 2021 10:02:27 -0800 Subject: [PATCH 552/752] misc/cgo/testsanitizers: don't fail asan test if no symbolizer Change-Id: Ic05c641bda3cc8f5292921c9b0c0d3df34f3bc48 Reviewed-on: https://go-review.googlesource.com/c/go/+/374794 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor Reviewed-by: Cherry Mui --- misc/cgo/testsanitizers/asan_test.go | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/misc/cgo/testsanitizers/asan_test.go b/misc/cgo/testsanitizers/asan_test.go index cd1e9f354b..ed58e5a183 100644 --- a/misc/cgo/testsanitizers/asan_test.go +++ b/misc/cgo/testsanitizers/asan_test.go @@ -55,10 +55,15 @@ func TestASAN(t *testing.T) { cmd := hangProneCmd(outPath) if tc.memoryAccessError != "" { - out, err := cmd.CombinedOutput() - if err != nil && strings.Contains(string(out), tc.memoryAccessError) { + outb, err := cmd.CombinedOutput() + out := string(outb) + if err != nil && strings.Contains(out, tc.memoryAccessError) { + // This string is output if the + // sanitizer library needs a + // symbolizer program and can't find it. + const noSymbolizer = "external symbolizer" // Check if -asan option can correctly print where the error occured. - if tc.errorLocation != "" && !strings.Contains(string(out), tc.errorLocation) { + if tc.errorLocation != "" && !strings.Contains(out, tc.errorLocation) && !strings.Contains(out, noSymbolizer) { t.Errorf("%#q exited without expected location of the error\n%s; got failure\n%s", strings.Join(cmd.Args, " "), tc.errorLocation, out) } return From 6178d25fc0b28724b1b5aec2b1b74fc06d9294c7 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 29 Dec 2021 11:19:13 -0800 Subject: [PATCH 553/752] misc/cgo/testsanitizers: accept compilers that don't report location It appears that GCC before version 10 doesn't report file/line location for asan errors. Change-Id: I03ee24180ba365636596aa2384961df7ce6ed71f Reviewed-on: https://go-review.googlesource.com/c/go/+/374874 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor Reviewed-by: Cherry Mui TryBot-Result: Gopher Robot --- misc/cgo/testsanitizers/asan_test.go | 6 +++++- misc/cgo/testsanitizers/cc_test.go | 17 +++++++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/misc/cgo/testsanitizers/asan_test.go b/misc/cgo/testsanitizers/asan_test.go index ed58e5a183..27bd8a5b1f 100644 --- a/misc/cgo/testsanitizers/asan_test.go +++ b/misc/cgo/testsanitizers/asan_test.go @@ -63,7 +63,11 @@ func TestASAN(t *testing.T) { // symbolizer program and can't find it. const noSymbolizer = "external symbolizer" // Check if -asan option can correctly print where the error occured. - if tc.errorLocation != "" && !strings.Contains(out, tc.errorLocation) && !strings.Contains(out, noSymbolizer) { + if tc.errorLocation != "" && + !strings.Contains(out, tc.errorLocation) && + !strings.Contains(out, noSymbolizer) && + compilerSupportsLocation() { + t.Errorf("%#q exited without expected location of the error\n%s; got failure\n%s", strings.Join(cmd.Args, " "), tc.errorLocation, out) } return diff --git a/misc/cgo/testsanitizers/cc_test.go b/misc/cgo/testsanitizers/cc_test.go index 0ce4f75935..05b77932b4 100644 --- a/misc/cgo/testsanitizers/cc_test.go +++ b/misc/cgo/testsanitizers/cc_test.go @@ -218,6 +218,23 @@ func compilerVersion() (version, error) { return compiler.version, compiler.err } +// compilerSupportsLocation reports whether the compiler should be +// able to provide file/line information in backtraces. +func compilerSupportsLocation() bool { + compiler, err := compilerVersion() + if err != nil { + return false + } + switch compiler.name { + case "gcc": + return compiler.major >= 10 + case "clang": + return true + default: + return false + } +} + type compilerCheck struct { once sync.Once err error From d181885de8f718623b41d45f5cc8644bbd8ad318 Mon Sep 17 00:00:00 2001 From: Tobias Klauser Date: Tue, 21 Dec 2021 13:20:20 +0100 Subject: [PATCH 554/752] os: enable TestMkdirAllWithSymlink on darwin/arm64 Go 1.16 renamed the iOS port from darwin/arm64 to ios/arm64 and darwin/arm64 was repurposed for the macOS ARM64 port (see https://golang.org/doc/go1.16#darwin). TestMkdirAllWithSymlink ought to run on darwin/arm64, so enable it on that platform. For #45696 Change-Id: I2cad6b1dfddf215e6b6cd262bbd22251f48f3d8c Reviewed-on: https://go-review.googlesource.com/c/go/+/373359 Trust: Tobias Klauser Run-TryBot: Tobias Klauser TryBot-Result: Gopher Robot Reviewed-by: Emmanuel Odeke --- src/os/path_test.go | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/os/path_test.go b/src/os/path_test.go index 4535abbc52..59f7283485 100644 --- a/src/os/path_test.go +++ b/src/os/path_test.go @@ -96,13 +96,8 @@ func TestMkdirAllWithSymlink(t *testing.T) { func TestMkdirAllAtSlash(t *testing.T) { switch runtime.GOOS { - case "android", "plan9", "windows": + case "android", "ios", "plan9", "windows": t.Skipf("skipping on %s", runtime.GOOS) - case "darwin", "ios": - switch runtime.GOARCH { - case "arm64": - t.Skipf("skipping on darwin/arm64, mkdir returns EPERM") - } } RemoveAll("/_go_os_test") const dir = "/_go_os_test/dir" From c8861432b84157363c84220e6ed71180531bf2b4 Mon Sep 17 00:00:00 2001 From: Tobias Klauser Date: Thu, 30 Dec 2021 14:06:30 +0100 Subject: [PATCH 555/752] os: simplify ios checks in tests Go 1.16 renamed the iOS port from darwin/arm64 to ios/arm64 and darwin/arm64 was repurposed for the macOS ARM64 port (see https://golang.org/doc/go1.16#darwin). Change tests to only use GOOS=ios to detect special cases for iOS and stop treating darwin/arm64 as iOS. Change-Id: I6a19f16fa9ec159ab1386aeb8fe912585e457171 Reviewed-on: https://go-review.googlesource.com/c/go/+/374399 Trust: Tobias Klauser Run-TryBot: Tobias Klauser TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/os/os_test.go | 98 ++++++++++++++++++++--------------------------- 1 file changed, 42 insertions(+), 56 deletions(-) diff --git a/src/os/os_test.go b/src/os/os_test.go index 5a813e0a7d..82ca6f987d 100644 --- a/src/os/os_test.go +++ b/src/os/os_test.go @@ -54,34 +54,31 @@ var sysdir = func() *sysDir { "libpowermanager.so", }, } - case "darwin", "ios": - switch runtime.GOARCH { - case "arm64": - wd, err := syscall.Getwd() - if err != nil { - wd = err.Error() - } - sd := &sysDir{ - filepath.Join(wd, "..", ".."), - []string{ - "ResourceRules.plist", - "Info.plist", - }, - } - found := true - for _, f := range sd.files { - path := filepath.Join(sd.name, f) - if _, err := Stat(path); err != nil { - found = false - break - } - } - if found { - return sd - } - // In a self-hosted iOS build the above files might - // not exist. Look for system files instead below. + case "ios": + wd, err := syscall.Getwd() + if err != nil { + wd = err.Error() } + sd := &sysDir{ + filepath.Join(wd, "..", ".."), + []string{ + "ResourceRules.plist", + "Info.plist", + }, + } + found := true + for _, f := range sd.files { + path := filepath.Join(sd.name, f) + if _, err := Stat(path); err != nil { + found = false + break + } + } + if found { + return sd + } + // In a self-hosted iOS build the above files might + // not exist. Look for system files instead below. case "windows": return &sysDir{ Getenv("SystemRoot") + "\\system32\\drivers\\etc", @@ -140,13 +137,8 @@ func equal(name1, name2 string) (r bool) { // localTmp returns a local temporary directory not on NFS. func localTmp() string { switch runtime.GOOS { - case "android", "windows": + case "android", "ios", "windows": return TempDir() - case "darwin", "ios": - switch runtime.GOARCH { - case "arm64": - return TempDir() - } } return "/tmp" } @@ -570,15 +562,12 @@ func TestReaddirnamesOneAtATime(t *testing.T) { switch runtime.GOOS { case "android": dir = "/system/bin" - case "darwin", "ios": - switch runtime.GOARCH { - case "arm64": - wd, err := Getwd() - if err != nil { - t.Fatal(err) - } - dir = wd + case "ios": + wd, err := Getwd() + if err != nil { + t.Fatal(err) } + dir = wd case "plan9": dir = "/bin" case "windows": @@ -1399,22 +1388,19 @@ func TestChdirAndGetwd(t *testing.T) { dirs = []string{"/system/bin"} case "plan9": dirs = []string{"/", "/usr"} - case "darwin", "ios": - switch runtime.GOARCH { - case "arm64": - dirs = nil - for _, d := range []string{"d1", "d2"} { - dir, err := os.MkdirTemp("", d) - if err != nil { - t.Fatalf("TempDir: %v", err) - } - // Expand symlinks so path equality tests work. - dir, err = filepath.EvalSymlinks(dir) - if err != nil { - t.Fatalf("EvalSymlinks: %v", err) - } - dirs = append(dirs, dir) + case "ios": + dirs = nil + for _, d := range []string{"d1", "d2"} { + dir, err := os.MkdirTemp("", d) + if err != nil { + t.Fatalf("TempDir: %v", err) } + // Expand symlinks so path equality tests work. + dir, err = filepath.EvalSymlinks(dir) + if err != nil { + t.Fatalf("EvalSymlinks: %v", err) + } + dirs = append(dirs, dir) } } oldwd := Getenv("PWD") From a893d0f464e15f72d5f01937bed5011098adbb7b Mon Sep 17 00:00:00 2001 From: Jonathan Amsterdam Date: Fri, 17 Dec 2021 10:30:51 -0500 Subject: [PATCH 556/752] go/doc: use subtests Change the Test function to use sub-tests for each doc mode and package. This will allow more fine-grained test execution. Change-Id: Ie3dda5791bda2781a60776886dd39fd18e670e24 Reviewed-on: https://go-review.googlesource.com/c/go/+/375094 Trust: Jonathan Amsterdam Run-TryBot: Jonathan Amsterdam TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/go/doc/doc_test.go | 88 +++++++++++++++++++++--------------------- 1 file changed, 43 insertions(+), 45 deletions(-) diff --git a/src/go/doc/doc_test.go b/src/go/doc/doc_test.go index 3d17036f01..c8cdf9eb37 100644 --- a/src/go/doc/doc_test.go +++ b/src/go/doc/doc_test.go @@ -100,58 +100,56 @@ func test(t *testing.T, mode Mode) { // test packages for _, pkg := range pkgs { - importPath := dataDir + "/" + pkg.Name - var files []*ast.File - for _, f := range pkg.Files { - files = append(files, f) - } - doc, err := NewFromFiles(fset, files, importPath, mode) - if err != nil { - t.Error(err) - continue - } - - // golden files always use / in filenames - canonicalize them - for i, filename := range doc.Filenames { - doc.Filenames[i] = filepath.ToSlash(filename) - } - - // print documentation - var buf bytes.Buffer - if err := templateTxt.Execute(&buf, bundle{doc, fset}); err != nil { - t.Error(err) - continue - } - got := buf.Bytes() - - // update golden file if necessary - golden := filepath.Join(dataDir, fmt.Sprintf("%s.%d.golden", pkg.Name, mode)) - if *update { - err := os.WriteFile(golden, got, 0644) - if err != nil { - t.Error(err) + t.Run(pkg.Name, func(t *testing.T) { + importPath := dataDir + "/" + pkg.Name + var files []*ast.File + for _, f := range pkg.Files { + files = append(files, f) + } + doc, err := NewFromFiles(fset, files, importPath, mode) + if err != nil { + t.Fatal(err) } - continue - } - // get golden file - want, err := os.ReadFile(golden) - if err != nil { - t.Error(err) - continue - } + // golden files always use / in filenames - canonicalize them + for i, filename := range doc.Filenames { + doc.Filenames[i] = filepath.ToSlash(filename) + } - // compare - if !bytes.Equal(got, want) { - t.Errorf("package %s\n\tgot:\n%s\n\twant:\n%s", pkg.Name, got, want) - } + // print documentation + var buf bytes.Buffer + if err := templateTxt.Execute(&buf, bundle{doc, fset}); err != nil { + t.Fatal(err) + } + got := buf.Bytes() + + // update golden file if necessary + golden := filepath.Join(dataDir, fmt.Sprintf("%s.%d.golden", pkg.Name, mode)) + if *update { + err := os.WriteFile(golden, got, 0644) + if err != nil { + t.Fatal(err) + } + } + + // get golden file + want, err := os.ReadFile(golden) + if err != nil { + t.Fatal(err) + } + + // compare + if !bytes.Equal(got, want) { + t.Errorf("package %s\n\tgot:\n%s\n\twant:\n%s", pkg.Name, got, want) + } + }) } } func Test(t *testing.T) { - test(t, 0) - test(t, AllDecls) - test(t, AllMethods) + t.Run("default", func(t *testing.T) { test(t, 0) }) + t.Run("AllDecls", func(t *testing.T) { test(t, AllDecls) }) + t.Run("AllMethods", func(t *testing.T) { test(t, AllMethods) }) } func TestAnchorID(t *testing.T) { From 95b240b2cd63e9631b3d0be72a10a3f2cc6f1d28 Mon Sep 17 00:00:00 2001 From: Jonathan Amsterdam Date: Sat, 18 Dec 2021 07:28:16 -0500 Subject: [PATCH 557/752] go/doc: handle generic receiver strings A receiver expression for a type with parameters may be an IndexExpr or IndexListExpr in addition to an Ident or StarExpr. Add cases to recvString to account for the new types. Add tests that compare the fields of Func, and the fields of Type that hold Funcs. These fields weren't previously tested. Change-Id: Ia2cef51c85113422e0c5745c77dddcd53507ee51 Reviewed-on: https://go-review.googlesource.com/c/go/+/375095 Trust: Jonathan Amsterdam Run-TryBot: Jonathan Amsterdam TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/go/doc/doc_test.go | 139 +++++++++++++++++++++++++++++++++++++++++ src/go/doc/reader.go | 30 ++++++++- 2 files changed, 167 insertions(+), 2 deletions(-) diff --git a/src/go/doc/doc_test.go b/src/go/doc/doc_test.go index c8cdf9eb37..5a5fbd8bf3 100644 --- a/src/go/doc/doc_test.go +++ b/src/go/doc/doc_test.go @@ -160,3 +160,142 @@ func TestAnchorID(t *testing.T) { t.Errorf("anchorID(%q) = %q; want %q", in, got, want) } } + +func TestFuncs(t *testing.T) { + fset := token.NewFileSet() + file, err := parser.ParseFile(fset, "funcs.go", strings.NewReader(funcsTestFile), parser.ParseComments) + if err != nil { + t.Fatal(err) + } + doc, err := NewFromFiles(fset, []*ast.File{file}, "importPath", Mode(0)) + if err != nil { + t.Fatal(err) + } + + for _, f := range doc.Funcs { + f.Decl = nil + } + for _, ty := range doc.Types { + for _, f := range ty.Funcs { + f.Decl = nil + } + for _, m := range ty.Methods { + m.Decl = nil + } + } + + compareFuncs := func(t *testing.T, msg string, got, want *Func) { + // ignore Decl and Examples + got.Decl = nil + got.Examples = nil + if !(got.Doc == want.Doc && + got.Name == want.Name && + got.Recv == want.Recv && + got.Orig == want.Orig && + got.Level == want.Level) { + t.Errorf("%s:\ngot %+v\nwant %+v", msg, got, want) + } + } + + compareSlices(t, "Funcs", doc.Funcs, funcsPackage.Funcs, compareFuncs) + compareSlices(t, "Types", doc.Types, funcsPackage.Types, func(t *testing.T, msg string, got, want *Type) { + if got.Name != want.Name { + t.Errorf("%s.Name: got %q, want %q", msg, got.Name, want.Name) + } else { + compareSlices(t, got.Name+".Funcs", got.Funcs, want.Funcs, compareFuncs) + compareSlices(t, got.Name+".Methods", got.Methods, want.Methods, compareFuncs) + } + }) +} + +func compareSlices[E any](t *testing.T, name string, got, want []E, compareElem func(*testing.T, string, E, E)) { + if len(got) != len(want) { + t.Errorf("%s: got %d, want %d", name, len(got), len(want)) + } + for i := 0; i < len(got) && i < len(want); i++ { + compareElem(t, fmt.Sprintf("%s[%d]", name, i), got[i], want[i]) + } +} + +const funcsTestFile = ` +package funcs + +func F() {} + +type S1 struct { + S2 // embedded, exported + s3 // embedded, unexported +} + +func NewS1() S1 {return S1{} } +func NewS1p() *S1 { return &S1{} } + +func (S1) M1() {} +func (r S1) M2() {} +func(S1) m3() {} // unexported not shown +func (*S1) P1() {} // pointer receiver + +type S2 int +func (S2) M3() {} // shown on S2 + +type s3 int +func (s3) M4() {} // shown on S1 + +type G1[T any] struct { + *s3 +} + +func NewG1[T any]() G1[T] { return G1[T]{} } + +func (G1[T]) MG1() {} +func (*G1[U]) MG2() {} + +type G2[T, U any] struct {} + +func NewG2[T, U any]() G2[T, U] { return G2[T, U]{} } + +func (G2[T, U]) MG3() {} +func (*G2[A, B]) MG4() {} + + +` + +var funcsPackage = &Package{ + Funcs: []*Func{{Name: "F"}}, + Types: []*Type{ + { + Name: "G1", + Funcs: []*Func{{Name: "NewG1"}}, + Methods: []*Func{ + {Name: "M4", Recv: "G1", // TODO: synthesize a param for G1? + Orig: "s3", Level: 1}, + {Name: "MG1", Recv: "G1[T]", Orig: "G1[T]", Level: 0}, + {Name: "MG2", Recv: "*G1[U]", Orig: "*G1[U]", Level: 0}, + }, + }, + { + Name: "G2", + Funcs: []*Func{{Name: "NewG2"}}, + Methods: []*Func{ + {Name: "MG3", Recv: "G2[T, U]", Orig: "G2[T, U]", Level: 0}, + {Name: "MG4", Recv: "*G2[A, B]", Orig: "*G2[A, B]", Level: 0}, + }, + }, + { + Name: "S1", + Funcs: []*Func{{Name: "NewS1"}, {Name: "NewS1p"}}, + Methods: []*Func{ + {Name: "M1", Recv: "S1", Orig: "S1", Level: 0}, + {Name: "M2", Recv: "S1", Orig: "S1", Level: 0}, + {Name: "M4", Recv: "S1", Orig: "s3", Level: 1}, + {Name: "P1", Recv: "*S1", Orig: "*S1", Level: 0}, + }, + }, + { + Name: "S2", + Methods: []*Func{ + {Name: "M3", Recv: "S2", Orig: "S2", Level: 0}, + }, + }, + }, +} diff --git a/src/go/doc/reader.go b/src/go/doc/reader.go index 7ff868f062..de1d422106 100644 --- a/src/go/doc/reader.go +++ b/src/go/doc/reader.go @@ -5,11 +5,13 @@ package doc import ( + "fmt" "go/ast" "go/token" "internal/lazyregexp" "sort" "strconv" + "strings" ) // ---------------------------------------------------------------------------- @@ -22,8 +24,8 @@ import ( // type methodSet map[string]*Func -// recvString returns a string representation of recv of the -// form "T", "*T", or "BADRECV" (if not a proper receiver type). +// recvString returns a string representation of recv of the form "T", "*T", +// "T[A, ...]", "*T[A, ...]" or "BADRECV" (if not a proper receiver type). // func recvString(recv ast.Expr) string { switch t := recv.(type) { @@ -31,10 +33,34 @@ func recvString(recv ast.Expr) string { return t.Name case *ast.StarExpr: return "*" + recvString(t.X) + case *ast.IndexExpr: + // Generic type with one parameter. + return fmt.Sprintf("%s[%s]", recvString(t.X), recvParam(t.Index)) + case *ast.IndexListExpr: + // Generic type with multiple parameters. + if len(t.Indices) > 0 { + var b strings.Builder + b.WriteString(recvString(t.X)) + b.WriteByte('[') + b.WriteString(recvParam(t.Indices[0])) + for _, e := range t.Indices[1:] { + b.WriteString(", ") + b.WriteString(recvParam(e)) + } + b.WriteByte(']') + return b.String() + } } return "BADRECV" } +func recvParam(p ast.Expr) string { + if id, ok := p.(*ast.Ident); ok { + return id.Name + } + return "BADPARAM" +} + // set creates the corresponding Func for f and adds it to mset. // If there are multiple f's with the same name, set keeps the first // one with documentation; conflicts are ignored. The boolean From 1c8f9d2c97db7390a7ed2cd4663571b544147f4d Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Thu, 23 Dec 2021 15:57:54 -0800 Subject: [PATCH 558/752] doc/go1.18: mention new cmd/go fuzzing flags For #47694 Change-Id: I00da9bd39700e938ec492daa71aba2035d911a06 Reviewed-on: https://go-review.googlesource.com/c/go/+/374354 Trust: Ian Lance Taylor Trust: Katie Hockman Reviewed-by: Katie Hockman --- doc/go1.18.html | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 4907dd6e2d..a5d7dcfcc5 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -304,6 +304,27 @@ Do not send CLs removing the interior tags from such phrases. file to specify the single main module.

    +

    + The go command now supports additional command line + options for the new fuzzing support described + above: +

      +
    • + go test supports + -fuzz, -fuzztime, and + -fuzzminimizetime options. + For documentation on these see + go help testflag. +
      • +
    • + go clean supports a -fuzzcache + option. + For documentation see + go help clean. +
      • +
    +

    +

    gofmt

    @@ -979,7 +1000,9 @@ Do not send CLs removing the interior tags from such phrases.

    The new testing.F type is used by the new fuzzing support described - above. + above. Tests also now support the command line + options -test.fuzz, -test.fuzztime, and + -test.fuzzminimizetime.

    From e39ab9b01cbbdac0750fc13fa8fb1de4f07aa79a Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Wed, 15 Dec 2021 18:42:00 -0800 Subject: [PATCH 559/752] cmd/compile: pop instantiations of local types when leaving scope Since we use existing instantiations from the symbol table when possible (to make sure each instantiation is unique), we need to pop instantiations of local types when leaving the containing scope. g.stmts() now pushes and pops scope, and we do a Pushdcl() in g.typ0() when creating an instantiation of a local type. Non-instantiated local types (generic or not) are translated directly from types2, so they don't need to be pushed/popped. We don't export function bodies with local types, so there is no issue during import. We still don't support local types in generic functions/methods. Fixes #50177 Change-Id: If2d2fe71aec003d13f0338565c7a0da2c9580a14 Reviewed-on: https://go-review.googlesource.com/c/go/+/372654 Reviewed-by: Keith Randall Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/noder/stmt.go | 3 + src/cmd/compile/internal/noder/types.go | 9 ++- test/typeparam/issue50177.go | 101 ++++++++++++++++++++++++ 3 files changed, 112 insertions(+), 1 deletion(-) create mode 100644 test/typeparam/issue50177.go diff --git a/src/cmd/compile/internal/noder/stmt.go b/src/cmd/compile/internal/noder/stmt.go index 1e996b95c4..a349a7ef10 100644 --- a/src/cmd/compile/internal/noder/stmt.go +++ b/src/cmd/compile/internal/noder/stmt.go @@ -13,8 +13,10 @@ import ( "cmd/internal/src" ) +// stmts creates nodes for a slice of statements that form a scope. func (g *irgen) stmts(stmts []syntax.Stmt) []ir.Node { var nodes []ir.Node + types.Markdcl() for _, stmt := range stmts { switch s := g.stmt(stmt).(type) { case nil: // EmptyStmt @@ -24,6 +26,7 @@ func (g *irgen) stmts(stmts []syntax.Stmt) []ir.Node { nodes = append(nodes, s) } } + types.Popdcl() return nodes } diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go index 4f6d828720..ed816b4955 100644 --- a/src/cmd/compile/internal/noder/types.go +++ b/src/cmd/compile/internal/noder/types.go @@ -123,7 +123,14 @@ func (g *irgen) typ0(typ types2.Type) *types.Type { // Make sure the base generic type exists in type1 (it may // not yet if we are referecing an imported generic type, as // opposed to a generic type declared in this package). - _ = g.obj(typ.Origin().Obj()) + base := g.obj(typ.Origin().Obj()) + if base.Class == ir.PAUTO { + // If the base type is a local type, we want to pop + // this instantiated type symbol/definition when we + // leave the containing block, so we don't use it + // incorrectly later. + types.Pushdcl(s) + } // Create a forwarding type first and put it in the g.typs // map, in order to deal with recursive generic types diff --git a/test/typeparam/issue50177.go b/test/typeparam/issue50177.go new file mode 100644 index 0000000000..5fd62ad4f6 --- /dev/null +++ b/test/typeparam/issue50177.go @@ -0,0 +1,101 @@ +// compile -G=3 + +// 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 Fn[T any] func(T) +type FnErr[T any] func(T) error + +// Test that local generic types across functions don't conflict, and they also don't +// conflict with local non-generic types and local variables. +func caller0() { + type X[T any] struct { + fn Fn[int] + } + + x := X[int]{func(v int) { fmt.Println(v) }} + x.fn(0) +} + +func caller1(val int) { + type X[T any] struct { + fn FnErr[int] + } + + x := X[int]{func(v int) error { fmt.Println(v); return nil }} + x.fn(0) +} + +func caller1a(val int) { + type X struct { + fn func(float64) error + } + + x := X{func(v float64) error { fmt.Println(v); return nil }} + x.fn(float64(3.2)) +} + +func caller1b(val int) { + type Y struct { + fn func(float64) error + } + + X := Y{func(v float64) error { fmt.Println(v); return nil }} + X.fn(float64(3.2)) +} + +// Test that local generic types within different if clauses don't conflict. +func caller2(val int) { + if val > 2 { + type X[T any] struct { + fn func(v int) float64 + } + + x := X[int]{func(v int) float64 { fmt.Println(v); return 1.5 }} + x.fn(0) + } else { + type X[T any] struct { + fn func(v int) int + } + x := X[int]{func(v int) int { fmt.Println(v); return 5 }} + x.fn(0) + } +} + +// Test that local generic types within different cases don't conflict with each +// other or with local non-generic types or local variables. +func caller3(val int) { + switch val { + case 0: + type X[T any] struct { + fn func(v int) float64 + } + + x := X[int]{func(v int) float64 { fmt.Println(v); return 1.5 }} + x.fn(0) + case 1: + type X[T any] struct { + fn func(v int) int + } + x := X[int]{func(v int) int { fmt.Println(v); return 5 }} + x.fn(0) + case 2: + type X struct { + fn func(v int) bool + } + x := X{func(v int) bool { fmt.Println(v); return false }} + x.fn(0) + case 3: + type Y struct { + fn func(v int) bool + } + X := Y{func(v int) bool { fmt.Println(v); return false }} + X.fn(0) + + } +} From f154f8b5bb16833139bb171371691150b1bd9cd5 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Tue, 21 Dec 2021 07:59:16 -0800 Subject: [PATCH 560/752] cmd/compile: save selector/inst info for generic method/function calls In the dict info, we need to save the SelectorExpr of a generic method call when making its sub-dictionary entry. The generic method call will eventually be transformed into a function call on the method shape instantiation, so we may not always have the selector info available when we need it to create a dictionary. We use this SelectorExpr as needed if the relevant call node has already been transformed. Similarly, we save the InstExpr of generic function calls, since the InstExpr will be dropped when the function call is transformed to a call to a shape instantiation. We use this InstExpr if the relevant function call has already been transformed. Added an extra generic function Some2 and a call to it from Some that exercises the generic function case. The existing test already tests the method call case. Fixes #50264 Change-Id: I2c7c7d79a8e33ca36a5e88e64e913c57500c97f9 Reviewed-on: https://go-review.googlesource.com/c/go/+/373754 Reviewed-by: Keith Randall Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/noder/irgen.go | 13 +++- src/cmd/compile/internal/noder/stencil.go | 94 ++++++++++++++--------- test/typeparam/issue50264.go | 45 +++++++++++ 3 files changed, 113 insertions(+), 39 deletions(-) create mode 100644 test/typeparam/issue50264.go diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go index e20939de66..344a2639ac 100644 --- a/src/cmd/compile/internal/noder/irgen.go +++ b/src/cmd/compile/internal/noder/irgen.go @@ -96,6 +96,17 @@ func check2(noders []*noder) { } } +// Information about sub-dictionary entries in a dictionary +type subDictInfo struct { + // Call or XDOT node that requires a dictionary. + callNode ir.Node + // Saved CallExpr.X node (*ir.SelectorExpr or *InstExpr node) for a generic + // method or function call, since this node will get dropped when the generic + // method/function call is transformed to a call on the instantiated shape + // function. Nil for other kinds of calls or XDOTs. + savedXNode ir.Node +} + // dictInfo is the dictionary format for an instantiation of a generic function with // particular shapes. shapeParams, derivedTypes, subDictCalls, and itabConvs describe // the actual dictionary entries in order, and the remaining fields are other info @@ -108,7 +119,7 @@ type dictInfo struct { // Nodes in the instantiation that requires a subdictionary. Includes // method and function calls (OCALL), function values (OFUNCINST), method // values/expressions (OXDOT). - subDictCalls []ir.Node + subDictCalls []subDictInfo // Nodes in the instantiation that are a conversion from a typeparam/derived // type to a specific interface. itabConvs []ir.Node diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go index 62c306b89e..d3006d40f8 100644 --- a/src/cmd/compile/internal/noder/stencil.go +++ b/src/cmd/compile/internal/noder/stencil.go @@ -609,7 +609,7 @@ func (g *genInst) getDictOrSubdict(declInfo *instInfo, n ir.Node, nameNode *ir.N if declInfo != nil { entry := -1 for i, de := range declInfo.dictInfo.subDictCalls { - if n == de { + if n == de.callNode { entry = declInfo.dictInfo.startSubDict + i break } @@ -1570,8 +1570,9 @@ func (g *genInst) getDictionarySym(gf *ir.Name, targs []*types.Type, isMeth bool markTypeUsed(ts, lsym) } // Emit an entry for each subdictionary (after substituting targs) - for _, n := range info.subDictCalls { + for _, subDictInfo := range info.subDictCalls { var sym *types.Sym + n := subDictInfo.callNode switch n.Op() { case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH: call := n.(*ir.CallExpr) @@ -1618,31 +1619,31 @@ func (g *genInst) getDictionarySym(gf *ir.Name, targs []*types.Type, isMeth bool } else { // This is the case of a normal // method call on a generic type. - recvType := deref(call.X.(*ir.SelectorExpr).X.Type()) - genRecvType := recvType.OrigSym().Def.Type() - nameNode = typecheck.Lookdot1(call.X, se.Sel, genRecvType, genRecvType.Methods(), 1).Nname.(*ir.Name) - subtargs := recvType.RParams() - s2targs := make([]*types.Type, len(subtargs)) - for i, t := range subtargs { - s2targs[i] = subst.Typ(t) - } - sym = g.getDictionarySym(nameNode, s2targs, true) + assert(subDictInfo.savedXNode == se) + sym = g.getSymForMethodCall(se, &subst) } } else { - inst := call.X.(*ir.InstExpr) - var nameNode *ir.Name - var meth *ir.SelectorExpr - var isMeth bool - if meth, isMeth = inst.X.(*ir.SelectorExpr); isMeth { - nameNode = meth.Selection.Nname.(*ir.Name) + inst, ok := call.X.(*ir.InstExpr) + if ok { + // Code hasn't been transformed yet + assert(subDictInfo.savedXNode == inst) + } + // If !ok, then the generic method/function call has + // already been transformed to a shape instantiation + // call. Either way, use the SelectorExpr/InstExpr + // node saved in info. + cex := subDictInfo.savedXNode + if se, ok := cex.(*ir.SelectorExpr); ok { + sym = g.getSymForMethodCall(se, &subst) } else { - nameNode = inst.X.(*ir.Name) + inst := cex.(*ir.InstExpr) + nameNode := inst.X.(*ir.Name) + subtargs := typecheck.TypesOf(inst.Targs) + for i, t := range subtargs { + subtargs[i] = subst.Typ(t) + } + sym = g.getDictionarySym(nameNode, subtargs, false) } - subtargs := typecheck.TypesOf(inst.Targs) - for i, t := range subtargs { - subtargs[i] = subst.Typ(t) - } - sym = g.getDictionarySym(nameNode, subtargs, isMeth) } case ir.OFUNCINST: @@ -1655,16 +1656,7 @@ func (g *genInst) getDictionarySym(gf *ir.Name, targs []*types.Type, isMeth bool sym = g.getDictionarySym(nameNode, subtargs, false) case ir.OXDOT, ir.OMETHEXPR, ir.OMETHVALUE: - selExpr := n.(*ir.SelectorExpr) - recvType := deref(selExpr.Selection.Type.Recv().Type) - genRecvType := recvType.OrigSym().Def.Type() - subtargs := recvType.RParams() - s2targs := make([]*types.Type, len(subtargs)) - for i, t := range subtargs { - s2targs[i] = subst.Typ(t) - } - nameNode := typecheck.Lookdot1(selExpr, selExpr.Sel, genRecvType, genRecvType.Methods(), 1).Nname.(*ir.Name) - sym = g.getDictionarySym(nameNode, s2targs, true) + sym = g.getSymForMethodCall(n.(*ir.SelectorExpr), &subst) default: assert(false) @@ -1692,6 +1684,24 @@ func (g *genInst) getDictionarySym(gf *ir.Name, targs []*types.Type, isMeth bool return sym } +// getSymForMethodCall gets the dictionary sym for a method call, method value, or method +// expression that has selector se. subst gives the substitution from shape types to +// concrete types. +func (g *genInst) getSymForMethodCall(se *ir.SelectorExpr, subst *typecheck.Tsubster) *types.Sym { + // For everything except method expressions, 'recvType = deref(se.X.Type)' would + // also give the receiver type. For method expressions with embedded types, we + // need to look at the type of the selection to get the final receiver type. + recvType := deref(se.Selection.Type.Recv().Type) + genRecvType := recvType.OrigSym().Def.Type() + nameNode := typecheck.Lookdot1(se, se.Sel, genRecvType, genRecvType.Methods(), 1).Nname.(*ir.Name) + subtargs := recvType.RParams() + s2targs := make([]*types.Type, len(subtargs)) + for i, t := range subtargs { + s2targs[i] = subst.Typ(t) + } + return g.getDictionarySym(nameNode, s2targs, true) +} + // finalizeSyms finishes up all dictionaries on g.dictSymsToFinalize, by writing out // any needed LSyms for itabs. The itab lsyms create wrappers which need various // dictionaries and method instantiations to be complete, so, to avoid recursive @@ -1839,7 +1849,7 @@ func (g *genInst) getInstInfo(st *ir.Func, shapes []*types.Type, instInfo *instI case ir.OFUNCINST: if !callMap[n] && hasShapeNodes(n.(*ir.InstExpr).Targs) { infoPrint(" Closure&subdictionary required at generic function value %v\n", n.(*ir.InstExpr).X) - info.subDictCalls = append(info.subDictCalls, n) + info.subDictCalls = append(info.subDictCalls, subDictInfo{callNode: n, savedXNode: nil}) } case ir.OMETHEXPR, ir.OMETHVALUE: if !callMap[n] && !types.IsInterfaceMethod(n.(*ir.SelectorExpr).Selection.Type) && @@ -1850,7 +1860,7 @@ func (g *genInst) getInstInfo(st *ir.Func, shapes []*types.Type, instInfo *instI } else { infoPrint(" Closure&subdictionary required at generic meth value %v\n", n) } - info.subDictCalls = append(info.subDictCalls, n) + info.subDictCalls = append(info.subDictCalls, subDictInfo{callNode: n, savedXNode: nil}) } case ir.OCALL: ce := n.(*ir.CallExpr) @@ -1858,14 +1868,18 @@ func (g *genInst) getInstInfo(st *ir.Func, shapes []*types.Type, instInfo *instI callMap[ce.X] = true if hasShapeNodes(ce.X.(*ir.InstExpr).Targs) { infoPrint(" Subdictionary at generic function/method call: %v - %v\n", ce.X.(*ir.InstExpr).X, n) - info.subDictCalls = append(info.subDictCalls, n) + // Save the instExpr node for the function call, + // since we will lose this information when the + // generic function call is transformed to a call + // on the shape instantiation. + info.subDictCalls = append(info.subDictCalls, subDictInfo{callNode: n, savedXNode: ce.X}) } } if ce.X.Op() == ir.OXDOT && isShapeDeref(ce.X.(*ir.SelectorExpr).X.Type()) { callMap[ce.X] = true infoPrint(" Optional subdictionary at generic bound call: %v\n", n) - info.subDictCalls = append(info.subDictCalls, n) + info.subDictCalls = append(info.subDictCalls, subDictInfo{callNode: n, savedXNode: nil}) } case ir.OCALLMETH: ce := n.(*ir.CallExpr) @@ -1874,7 +1888,11 @@ func (g *genInst) getInstInfo(st *ir.Func, shapes []*types.Type, instInfo *instI callMap[ce.X] = true if hasShapeTypes(deref(ce.X.(*ir.SelectorExpr).X.Type()).RParams()) { infoPrint(" Subdictionary at generic method call: %v\n", n) - info.subDictCalls = append(info.subDictCalls, n) + // Save the selector for the method call, since we + // will eventually lose this information when the + // generic method call is transformed into a + // function call on the method shape instantiation. + info.subDictCalls = append(info.subDictCalls, subDictInfo{callNode: n, savedXNode: ce.X}) } } case ir.OCONVIFACE: diff --git a/test/typeparam/issue50264.go b/test/typeparam/issue50264.go new file mode 100644 index 0000000000..ee3eedc358 --- /dev/null +++ b/test/typeparam/issue50264.go @@ -0,0 +1,45 @@ +// run -gcflags=-G=3 + +// 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 + +type hello struct{} + +func main() { + _ = Some(hello{}) + res := Applicative2(func(a int, b int) int { + return 0 + }) + _ = res +} + +type NoneType[T any] struct{} + +func (r NoneType[T]) Recover() any { + return nil +} + +type Func2[A1, A2, R any] func(a1 A1, a2 A2) R + +func Some[T any](v T) any { + _ = Some2[T](v) + return NoneType[T]{}.Recover() +} + +//go:noinline +func Some2[T any](v T) any { + return v +} + +type Nil struct{} + +type ApplicativeFunctor2[H, HT, A1, A2, R any] struct { + h any +} + +func Applicative2[A1, A2, R any](fn Func2[A1, A2, R]) ApplicativeFunctor2[Nil, Nil, A1, A2, R] { + return ApplicativeFunctor2[Nil, Nil, A1, A2, R]{Some(Nil{})} +} From 301db3f5d2d38a13aafe5bc6efea9a3bdbfc475e Mon Sep 17 00:00:00 2001 From: "Jason A. Donenfeld" Date: Wed, 5 Jan 2022 00:16:40 +0100 Subject: [PATCH 561/752] net: do not panic on nil IPNet.String() The code looks like it was already trying to avoid this but missed a spot. Fixes #50271. Change-Id: I450adac3f618b9535b61a28e6a160eacc351d47c Reviewed-on: https://go-review.googlesource.com/c/go/+/373075 Trust: Jason Donenfeld Run-TryBot: Jason Donenfeld TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/net/ip.go | 3 +++ src/net/ip_test.go | 1 + 2 files changed, 4 insertions(+) diff --git a/src/net/ip.go b/src/net/ip.go index b016bef144..54c52881cf 100644 --- a/src/net/ip.go +++ b/src/net/ip.go @@ -545,6 +545,9 @@ func (n *IPNet) Network() string { return "ip+net" } // character and a mask expressed as hexadecimal form with no // punctuation like "198.51.100.0/c000ff00". func (n *IPNet) String() string { + if n == nil { + return "" + } nn, m := networkNumberAndMask(n) if nn == nil || m == nil { return "" diff --git a/src/net/ip_test.go b/src/net/ip_test.go index 777461ad27..8f1590cfd5 100644 --- a/src/net/ip_test.go +++ b/src/net/ip_test.go @@ -407,6 +407,7 @@ var ipNetStringTests = []struct { {&IPNet{IP: IPv4(192, 168, 1, 0), Mask: IPv4Mask(255, 0, 255, 0)}, "192.168.1.0/ff00ff00"}, {&IPNet{IP: ParseIP("2001:db8::"), Mask: CIDRMask(55, 128)}, "2001:db8::/55"}, {&IPNet{IP: ParseIP("2001:db8::"), Mask: IPMask(ParseIP("8000:f123:0:cafe::"))}, "2001:db8::/8000f1230000cafe0000000000000000"}, + {nil, ""}, } func TestIPNetString(t *testing.T) { From 2c58bb2e428c1f587dc30817bc211570f6fd4793 Mon Sep 17 00:00:00 2001 From: fanzha02 Date: Thu, 30 Dec 2021 11:09:42 +0800 Subject: [PATCH 562/752] src/runtime: mark asanread and asanwrite functions as NOSPLIT The asan runtime functions may run on stacks that cannot grow, and they do not have large local variables, so it is safe to mark them as NOSPLIT. Add test case. Fixes #50391 Change-Id: Iadcbf1ae0c837d9b64da5be208c7f424e6ba11de Reviewed-on: https://go-review.googlesource.com/c/go/+/374398 Trust: Emmanuel Odeke Trust: Fannie Zhang Reviewed-by: Cherry Mui --- misc/cgo/testsanitizers/asan_test.go | 1 + .../cgo/testsanitizers/testdata/asan5_fail.go | 21 +++++++++++++++++++ src/runtime/asan.go | 4 ++++ 3 files changed, 26 insertions(+) create mode 100644 misc/cgo/testsanitizers/testdata/asan5_fail.go diff --git a/misc/cgo/testsanitizers/asan_test.go b/misc/cgo/testsanitizers/asan_test.go index 27bd8a5b1f..1b70bce3d1 100644 --- a/misc/cgo/testsanitizers/asan_test.go +++ b/misc/cgo/testsanitizers/asan_test.go @@ -39,6 +39,7 @@ func TestASAN(t *testing.T) { {src: "asan2_fail.go", memoryAccessError: "heap-buffer-overflow", errorLocation: "asan2_fail.go:31"}, {src: "asan3_fail.go", memoryAccessError: "use-after-poison", errorLocation: "asan3_fail.go:13"}, {src: "asan4_fail.go", memoryAccessError: "use-after-poison", errorLocation: "asan4_fail.go:13"}, + {src: "asan5_fail.go", memoryAccessError: "use-after-poison", errorLocation: "asan5_fail.go:18"}, {src: "asan_useAfterReturn.go"}, } for _, tc := range cases { diff --git a/misc/cgo/testsanitizers/testdata/asan5_fail.go b/misc/cgo/testsanitizers/testdata/asan5_fail.go new file mode 100644 index 0000000000..d6853eab73 --- /dev/null +++ b/misc/cgo/testsanitizers/testdata/asan5_fail.go @@ -0,0 +1,21 @@ +package main + +import ( + "fmt" + "runtime" + "unsafe" +) + +func main() { + p := new([1024 * 1000]int) + p[0] = 10 + r := bar(&p[1024*1000-1]) + fmt.Printf("r value is %d", r) +} + +func bar(a *int) int { + p := unsafe.Add(unsafe.Pointer(a), 2*unsafe.Sizeof(int(1))) + runtime.ASanWrite(p, 8) // BOOM + *((*int)(p)) = 10 + return *((*int)(p)) +} diff --git a/src/runtime/asan.go b/src/runtime/asan.go index affafd4d8d..26656cd975 100644 --- a/src/runtime/asan.go +++ b/src/runtime/asan.go @@ -26,12 +26,16 @@ func ASanWrite(addr unsafe.Pointer, len int) { // Private interface for the runtime. const asanenabled = true +// Mark asan(read, write) as NOSPLIT, because they may run +// on stacks that cannot grow. See issue #50391. +//go:nosplit func asanread(addr unsafe.Pointer, sz uintptr) { sp := getcallersp() pc := getcallerpc() doasanread(addr, sz, sp, pc) } +//go:nosplit func asanwrite(addr unsafe.Pointer, sz uintptr) { sp := getcallersp() pc := getcallerpc() From 002283eaca8335c4c1fb209f267bacf5afe6cf2c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Chigot?= Date: Fri, 17 Dec 2021 11:03:21 +0100 Subject: [PATCH 563/752] runtime: ensure that asmsyscall6 follow AIX stack convention The function asmsyscall6 must follow AIX stack layout. It means that its first local variable must be stored after its arguments area, ie after offset 112. Fixes #50185 Change-Id: I897731ddd2a9faad8218443a4c2f4b204ad7e173 Reviewed-on: https://go-review.googlesource.com/c/go/+/373074 Trust: Dmitri Shuralyov Reviewed-by: Cherry Mui --- src/runtime/sys_aix_ppc64.s | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/runtime/sys_aix_ppc64.s b/src/runtime/sys_aix_ppc64.s index c171c191c0..217ebb8878 100644 --- a/src/runtime/sys_aix_ppc64.s +++ b/src/runtime/sys_aix_ppc64.s @@ -25,7 +25,12 @@ TEXT callCfunction<>(SB), NOSPLIT|NOFRAME,$0 // stored in libcall_fn and store the results in libcall struture // Up to 6 arguments can be passed to this C function // Called by runtime.asmcgocall -// It reserves a stack of 288 bytes for the C function. +// It reserves a stack of 288 bytes for the C function. It must +// follow AIX convention, thus the first local variable must +// be stored at the offset 112, after the linker area (48 bytes) +// and the argument area (64). +// The AIX convention is described here: +// https://www.ibm.com/docs/en/aix/7.2?topic=overview-runtime-process-stack // NOT USING GO CALLING CONVENTION // runtime.asmsyscall6 is a function descriptor to the real asmsyscall6. DATA runtime·asmsyscall6+0(SB)/8, $asmsyscall6<>(SB) @@ -34,7 +39,8 @@ DATA runtime·asmsyscall6+16(SB)/8, $0 GLOBL runtime·asmsyscall6(SB), NOPTR, $24 TEXT asmsyscall6<>(SB),NOSPLIT,$256 - MOVD R3, 48(R1) // Save libcall for later + // Save libcall for later + MOVD R3, 112(R1) MOVD libcall_fn(R3), R12 MOVD libcall_args(R3), R9 MOVD 0(R9), R3 @@ -50,7 +56,7 @@ TEXT asmsyscall6<>(SB),NOSPLIT,$256 MOVD 40(R1), R2 // Store result in libcall - MOVD 48(R1), R5 + MOVD 112(R1), R5 MOVD R3, (libcall_r1)(R5) MOVD $-1, R6 CMP R6, R3 From 88cafe0f58cf7374722a2a98d8919c32bb8795e5 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 5 Jan 2022 14:20:30 -0500 Subject: [PATCH 564/752] net/http: skip TestClientTimeout_h{1,2} on windows/arm and windows/arm64 These tests are empirically flaky on the windows/arm and windows/arm64 builders, with a consistent (but rare) failure mode. This change skips the test if that particular failure mode is encountered on those platforms; the skip can be removed if and when someone has the time to pin down the root cause. For #43120 Change-Id: Ie3a9a06bf47e3a907c7b07441acc1494a4631135 Reviewed-on: https://go-review.googlesource.com/c/go/+/375635 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Damien Neil TryBot-Result: Gopher Robot --- src/net/http/client_test.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/net/http/client_test.go b/src/net/http/client_test.go index c2ea6f4330..ea59f68f35 100644 --- a/src/net/http/client_test.go +++ b/src/net/http/client_test.go @@ -13,6 +13,7 @@ import ( "encoding/base64" "errors" "fmt" + "internal/testenv" "io" "log" "net" @@ -21,6 +22,7 @@ import ( "net/http/httptest" "net/url" "reflect" + "runtime" "strconv" "strings" "sync" @@ -1289,6 +1291,9 @@ func testClientTimeout(t *testing.T, h2 bool) { t.Errorf("net.Error.Timeout = false; want true") } if got := ne.Error(); !strings.Contains(got, "(Client.Timeout") { + if runtime.GOOS == "windows" && strings.HasPrefix(runtime.GOARCH, "arm") { + testenv.SkipFlaky(t, 43120) + } t.Errorf("error string = %q; missing timeout substring", got) } From 2b39d86344608423138b648b98157470d3809ee7 Mon Sep 17 00:00:00 2001 From: Roland Shoemaker Date: Wed, 5 Jan 2022 12:25:28 -0800 Subject: [PATCH 565/752] cmd/go: add fuzzing coverage test Adds a test script for fuzzing coverage instrumentation. Fixes #48654 Change-Id: Ieea7b4146bd5581baae869441cc1c652dd7485f5 Reviewed-on: https://go-review.googlesource.com/c/go/+/375736 Trust: Katie Hockman Reviewed-by: Katie Hockman Trust: Roland Shoemaker Run-TryBot: Roland Shoemaker TryBot-Result: Gopher Robot --- src/cmd/go/testdata/script/test_fuzz_cov.txt | 33 ++++++++++++++++++++ 1 file changed, 33 insertions(+) create mode 100644 src/cmd/go/testdata/script/test_fuzz_cov.txt diff --git a/src/cmd/go/testdata/script/test_fuzz_cov.txt b/src/cmd/go/testdata/script/test_fuzz_cov.txt new file mode 100644 index 0000000000..05b634889f --- /dev/null +++ b/src/cmd/go/testdata/script/test_fuzz_cov.txt @@ -0,0 +1,33 @@ +# Test that coverage instrumentation is working. Without the instrumentation +# it is _extremely_ unlikely that the fuzzer would produce this particular +# input in any reasonable amount of time. + +[short] skip +[!fuzz-instrumented] skip + +! go test -fuzz=FuzzCov +! stderr 'cov instrumentation working' + +-- go.mod -- +module test + +-- cov_test.go -- +package cov + +import "testing" + +func FuzzCov(f *testing.F) { + f.Fuzz(func(t *testing.T, b []byte) { + if len(b) == 8 && + b[0] == 'h' && + b[1] == 'e' && + b[2] == 'l' && + b[3] == 'l' && + b[4] == 'o' && + b[5] == ' ' && + b[6] == ':' && + b[7] == ')' { + panic("cov instrumentation working") + } + }) +} From b5bfaf410ad4dc329400b92a7818ffec5cd9ebb0 Mon Sep 17 00:00:00 2001 From: Ulrich Kunitz Date: Wed, 15 Dec 2021 11:37:36 +0100 Subject: [PATCH 566/752] doc: improve documentation for GOAMD64 The change clarifies in the release notes for go1.18 that the variable is for compilation and references the microarchitecture description in the Go Wiki, https://golang.org/wiki/MinimumRequirements#amd64, and references the same information in the output of go help environment. Fixes #50174 Change-Id: I6a7d5a06f48463a810c96cc9c76fe66113d5147c Reviewed-on: https://go-review.googlesource.com/c/go/+/372194 Reviewed-by: Keith Randall Reviewed-by: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot --- doc/go1.18.html | 9 +++++---- src/cmd/go/alldocs.go | 2 +- src/cmd/go/internal/help/helpdoc.go | 2 +- 3 files changed, 7 insertions(+), 6 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index a5d7dcfcc5..0f313ee454 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -143,11 +143,12 @@ Do not send CLs removing the interior tags from such phrases.

    AMD64

    - Go 1.18 introduces the new GOAMD64 environment variable which selects - a version of the AMD64 architecture. Allowed values are v1, + Go 1.18 introduces the new GOAMD64 environment variable, which selects + a mininum target version of the AMD64 architecture. Allowed values are v1, v2, v3, or v4. Each higher level requires, - and takes advantage of, additional processor features. A detailed description of the - versions is here. + and takes advantage of, additional processor features. A detailed + description can be found + here.

    The GOAMD64 environment variable defaults to v1. diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index d90321414a..3bb9d146b2 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -2131,7 +2131,7 @@ // GOAMD64 // For GOARCH=amd64, the microarchitecture level for which to compile. // Valid values are v1 (default), v2, v3, v4. -// See https://en.wikipedia.org/wiki/X86-64#Microarchitecture_levels. +// See https://golang.org/wiki/MinimumRequirements#amd64 // GOMIPS // For GOARCH=mips{,le}, whether to use floating point instructions. // Valid values are hardfloat (default), softfloat. diff --git a/src/cmd/go/internal/help/helpdoc.go b/src/cmd/go/internal/help/helpdoc.go index 035235fe1b..7dc066cfba 100644 --- a/src/cmd/go/internal/help/helpdoc.go +++ b/src/cmd/go/internal/help/helpdoc.go @@ -595,7 +595,7 @@ Architecture-specific environment variables: GOAMD64 For GOARCH=amd64, the microarchitecture level for which to compile. Valid values are v1 (default), v2, v3, v4. - See https://en.wikipedia.org/wiki/X86-64#Microarchitecture_levels. + See https://golang.org/wiki/MinimumRequirements#amd64 GOMIPS For GOARCH=mips{,le}, whether to use floating point instructions. Valid values are hardfloat (default), softfloat. From f300fc2d2c620feac4e7f9b6cf0125b92943d3c4 Mon Sep 17 00:00:00 2001 From: Benny Siegert Date: Thu, 6 Jan 2022 11:27:57 +0000 Subject: [PATCH 567/752] runtime: crash on netbsd-arm64 when setcontext fails Instead of exiting with status 16962 when we fail to call SYS_setcontext in sigreturn, reference a null pointer and crash. Hopefully, this will enable grabbing a core dump to debug. Updates #42422 Change-Id: If02c14a0a37084351f3f00db3dc9766cb68ae4b8 Reviewed-on: https://go-review.googlesource.com/c/go/+/375834 Reviewed-by: Tobias Klauser Trust: Tobias Klauser Trust: Benny Siegert --- src/runtime/sys_netbsd_arm64.s | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/runtime/sys_netbsd_arm64.s b/src/runtime/sys_netbsd_arm64.s index 2d0b894d47..8a0496e807 100644 --- a/src/runtime/sys_netbsd_arm64.s +++ b/src/runtime/sys_netbsd_arm64.s @@ -279,8 +279,8 @@ fail: TEXT sigreturn_tramp<>(SB),NOSPLIT,$-8 MOVD g, R0 SVC $SYS_setcontext - MOVD $0x4242, R0 // Something failed, return magic number - SVC $SYS_exit + MOVD $0, R0 + MOVD R0, (R0) // crash TEXT runtime·sigaction(SB),NOSPLIT,$-8 MOVW sig+0(FP), R0 // arg 1 - signum From da7891f6f36c48f2931ed916ed305330c06f9bd7 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 5 Jan 2022 11:13:27 -0500 Subject: [PATCH 568/752] net: synchronize instead of sleeping in TestDialParallelSpuriousConnection The arbitrary sleep in this test is empirically not always long enough on slower builders. However, we know the exact number of connections that should be dialed: we can wait on that number in the dial hook instead. Fixes #34495 Change-Id: I538244ceb75a80271a724304b993309482bd5b41 Reviewed-on: https://go-review.googlesource.com/c/go/+/375694 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Ian Lance Taylor TryBot-Result: Gopher Robot --- src/net/dial_test.go | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/src/net/dial_test.go b/src/net/dial_test.go index e0c9cdc2ae..b9aead0371 100644 --- a/src/net/dial_test.go +++ b/src/net/dial_test.go @@ -429,14 +429,15 @@ func TestDialParallelSpuriousConnection(t *testing.T) { readDeadline = time.Now().Add(5 * time.Second) } - var wg sync.WaitGroup - wg.Add(2) + var closed sync.WaitGroup + closed.Add(2) handler := func(dss *dualStackServer, ln Listener) { // Accept one connection per address. c, err := ln.Accept() if err != nil { t.Fatal(err) } + // The client should close itself, without sending data. c.SetReadDeadline(readDeadline) var b [1]byte @@ -444,7 +445,7 @@ func TestDialParallelSpuriousConnection(t *testing.T) { t.Errorf("got %v; want %v", err, io.EOF) } c.Close() - wg.Done() + closed.Done() } dss, err := newDualStackServer() if err != nil { @@ -457,12 +458,16 @@ func TestDialParallelSpuriousConnection(t *testing.T) { const fallbackDelay = 100 * time.Millisecond + var dialing sync.WaitGroup + dialing.Add(2) origTestHookDialTCP := testHookDialTCP defer func() { testHookDialTCP = origTestHookDialTCP }() testHookDialTCP = func(ctx context.Context, net string, laddr, raddr *TCPAddr) (*TCPConn, error) { - // Sleep long enough for Happy Eyeballs to kick in, and inhibit cancellation. + // Wait until Happy Eyeballs kicks in and both connections are dialing, + // and inhibit cancellation. // This forces dialParallel to juggle two successful connections. - time.Sleep(fallbackDelay * 2) + dialing.Done() + dialing.Wait() // Now ignore the provided context (which will be canceled) and use a // different one to make sure this completes with a valid connection, @@ -496,7 +501,7 @@ func TestDialParallelSpuriousConnection(t *testing.T) { c.Close() // The server should've seen both connections. - wg.Wait() + closed.Wait() } func TestDialerPartialDeadline(t *testing.T) { From f0099106254e288db62de3e3b030915af7decc25 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 4 Jan 2022 15:13:33 -0800 Subject: [PATCH 569/752] cmd/compile/internal/types2: better error message for invalid range clause Fixes #50372. Change-Id: I8e4c0020dae42744cce016433e398e0b884bb044 Reviewed-on: https://go-review.googlesource.com/c/go/+/375475 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/stmt.go | 30 ++++++++++++------- .../types2/testdata/fixedbugs/issue50372.go | 27 +++++++++++++++++ test/fixedbugs/issue50372.go | 29 ++++++++++++++++++ 3 files changed, 76 insertions(+), 10 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50372.go create mode 100644 test/fixedbugs/issue50372.go diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go index ab64882c02..ae9cc69c99 100644 --- a/src/cmd/compile/internal/types2/stmt.go +++ b/src/cmd/compile/internal/types2/stmt.go @@ -810,32 +810,34 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu func (check *Checker) rangeStmt(inner stmtContext, s *syntax.ForStmt, rclause *syntax.RangeClause) { // scope already opened - // check expression to iterate over - var x operand - check.expr(&x, rclause.X) - // determine lhs, if any sKey := rclause.Lhs // possibly nil - var sValue syntax.Expr + var sValue, sExtra syntax.Expr if p, _ := sKey.(*syntax.ListExpr); p != nil { - if len(p.ElemList) != 2 { + if len(p.ElemList) < 2 { check.error(s, invalidAST+"invalid lhs in range clause") return } + // len(p.ElemList) >= 2 sKey = p.ElemList[0] sValue = p.ElemList[1] + if len(p.ElemList) > 2 { + // delay error reporting until we know more + sExtra = p.ElemList[2] + } } + // check expression to iterate over + var x operand + check.expr(&x, rclause.X) + // determine key/value types var key, val Type if x.mode != invalid { // Ranging over a type parameter is permitted if it has a structural type. var cause string u := structuralType(x.typ) - switch t := u.(type) { - case nil: - cause = check.sprintf("%s has no structural type", x.typ) - case *Chan: + if t, _ := u.(*Chan); t != nil { if sValue != nil { check.softErrorf(sValue, "range over %s permits only one iteration variable", &x) // ok to continue @@ -843,6 +845,14 @@ func (check *Checker) rangeStmt(inner stmtContext, s *syntax.ForStmt, rclause *s if t.dir == SendOnly { cause = "receive from send-only channel" } + } else { + if sExtra != nil { + check.softErrorf(sExtra, "range clause permits at most two iteration variables") + // ok to continue + } + if u == nil { + cause = check.sprintf("%s has no structural type", x.typ) + } } key, val = rangeKeyVal(u) if key == nil || cause != "" { diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50372.go b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50372.go new file mode 100644 index 0000000000..0f15dc0b62 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50372.go @@ -0,0 +1,27 @@ +// 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 _(s []int) { + var i, j, k, l int + _, _, _, _ = i, j, k, l + + for range s {} + for i = range s {} + for i, j = range s {} + for i, j, k /* ERROR range clause permits at most two iteration variables */ = range s {} + for i, j, k /* ERROR range clause permits at most two iteration variables */, l = range s {} +} + +func _(s chan int) { + var i, j, k, l int + _, _, _, _ = i, j, k, l + + for range s {} + for i = range s {} + for i, j /* ERROR range over .* permits only one iteration variable */ = range s {} + for i, j /* ERROR range over .* permits only one iteration variable */, k = range s {} + for i, j /* ERROR range over .* permits only one iteration variable */, k, l = range s {} +} diff --git a/test/fixedbugs/issue50372.go b/test/fixedbugs/issue50372.go new file mode 100644 index 0000000000..30a171d5a6 --- /dev/null +++ b/test/fixedbugs/issue50372.go @@ -0,0 +1,29 @@ +// errorcheck -G=3 + +// Copyright 2022 The Go 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 _(s []int) { + var i, j, k, l int + _, _, _, _ = i, j, k, l + + for range s {} + for i = range s {} + for i, j = range s {} + for i, j, k = range s {} // ERROR "range clause permits at most two iteration variables" + for i, j, k, l = range s {} // ERROR "range clause permits at most two iteration variables" +} + +func _(s chan int) { + var i, j, k, l int + _, _, _, _ = i, j, k, l + + for range s {} + for i = range s {} + for i, j = range s {} // ERROR "range over .* permits only one iteration variable" + for i, j, k = range s {} // ERROR "range over .* permits only one iteration variable" + for i, j, k, l = range s {} // ERROR "range over .* permits only one iteration variable" +} From 7a3a2b18ff3b8591eba18b730da7f84751bbfdc5 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Thu, 23 Dec 2021 10:33:17 -0500 Subject: [PATCH 570/752] go/types, types2: eagerly check that constraints are not type params As a result of the change to the underlying of a type parameter to be its constraint interface, we had couple inaccuracies that combined to cause an infinite recursion when type checking the invalid type parameter list [A A]. - We deferred tpar.iface() using check.later twice: once in newTypeParam, and then again at the end of collectTypeParams. - We deferred the check that type parameter constraints are not type parameters, even though this is unnecessary: the constraint type is known. With these inaccuracies, tpar.iface() was executing before our guard against using type parameters as constraints, causing an infinite recursion through under(). Fix this by eagerly checking whether the constraint is a type parameter, and marking it invalid if so. Also remove the unnecessary calls to tpar.iface() at the end of collectTypeParams, as this will already have been scheduled by newTypeParam. Fixes #50321 Change-Id: I4eecbecf21656615867cb94be65b520e9e795bd1 Reviewed-on: https://go-review.googlesource.com/c/go/+/374294 Reviewed-by: Robert Griesemer Trust: Robert Findley Run-TryBot: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/decl.go | 19 +++--------- .../types2/testdata/fixedbugs/issue50321.go2 | 8 +++++ src/go/types/decl.go | 31 ++++++++----------- .../types/testdata/fixedbugs/issue50321.go2 | 8 +++++ 4 files changed, 34 insertions(+), 32 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50321.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50321.go2 diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index d5495304fa..d61d2a8b0d 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -657,33 +657,24 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list []*syntax.Fiel // Keep track of bounds for later validation. var bound Type var bounds []Type - var posers []poser for i, f := range list { // Optimization: Re-use the previous type bound if it hasn't changed. // This also preserves the grouped output of type parameter lists // when printing type strings. if i == 0 || f.Type != list[i-1].Type { bound = check.bound(f.Type) - bounds = append(bounds, bound) - posers = append(posers, f.Type) - } - tparams[i].bound = bound - } - - check.later(func() { - for i, bound := range bounds { if isTypeParam(bound) { // We may be able to allow this since it is now well-defined what // the underlying type and thus type set of a type parameter is. // But we may need some additional form of cycle detection within // type parameter lists. - check.error(posers[i], "cannot use a type parameter as constraint") + check.error(f.Type, "cannot use a type parameter as constraint") + bound = Typ[Invalid] } + bounds = append(bounds, bound) } - for _, tpar := range tparams { - tpar.iface() // compute type set - } - }) + tparams[i].bound = bound + } } func (check *Checker) bound(x syntax.Expr) Type { diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50321.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50321.go2 new file mode 100644 index 0000000000..199e66eb6c --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50321.go2 @@ -0,0 +1,8 @@ +// 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 Ln[A A /* ERROR cannot use a type parameter as constraint */ ](p A) { +} diff --git a/src/go/types/decl.go b/src/go/types/decl.go index db29f11920..02af0d5f3e 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -708,34 +708,29 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list *ast.FieldList index := 0 var bounds []Type - var posns []positioner // bound positions for _, f := range list.List { - // TODO(rfindley) we should be able to rely on f.Type != nil at this point + var bound Type + // NOTE: we may be able to assert that f.Type != nil here, but this is not + // an invariant of the AST, so we are cautious. if f.Type != nil { - bound := check.bound(f.Type) - bounds = append(bounds, bound) - posns = append(posns, f.Type) - for i := range f.Names { - tparams[index+i].bound = bound - } - } - index += len(f.Names) - } - - check.later(func() { - for i, bound := range bounds { + bound = check.bound(f.Type) if isTypeParam(bound) { // We may be able to allow this since it is now well-defined what // the underlying type and thus type set of a type parameter is. // But we may need some additional form of cycle detection within // type parameter lists. - check.error(posns[i], _MisplacedTypeParam, "cannot use a type parameter as constraint") + check.error(f.Type, _MisplacedTypeParam, "cannot use a type parameter as constraint") + bound = Typ[Invalid] } + } else { + bound = Typ[Invalid] } - for _, tpar := range tparams { - tpar.iface() // compute type set + bounds = append(bounds, bound) + for i := range f.Names { + tparams[index+i].bound = bound } - }) + index += len(f.Names) + } } func (check *Checker) bound(x ast.Expr) Type { diff --git a/src/go/types/testdata/fixedbugs/issue50321.go2 b/src/go/types/testdata/fixedbugs/issue50321.go2 new file mode 100644 index 0000000000..199e66eb6c --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50321.go2 @@ -0,0 +1,8 @@ +// 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 Ln[A A /* ERROR cannot use a type parameter as constraint */ ](p A) { +} From ed84a8357c0107dedc42c9658ae9b020777b1bb7 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 5 Jan 2022 20:22:15 -0800 Subject: [PATCH 571/752] test: add test of incorrect gofrontend error For #50439 Change-Id: Ifad6e6f8de42121c695b5a4dc56e0f6606e2917e Reviewed-on: https://go-review.googlesource.com/c/go/+/375796 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Than McIntosh Trust: Than McIntosh Reviewed-by: Cherry Mui --- test/fixedbugs/issue50439.go | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 test/fixedbugs/issue50439.go diff --git a/test/fixedbugs/issue50439.go b/test/fixedbugs/issue50439.go new file mode 100644 index 0000000000..63629a5bde --- /dev/null +++ b/test/fixedbugs/issue50439.go @@ -0,0 +1,13 @@ +// compile + +// Copyright 2022 The Go 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 data []struct { + F string `tag` +} + +var V = ([]struct{ F string })(data) From 10f1ed131cd2cfb5ac4d9aa09888deb1bac6e921 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Thu, 6 Jan 2022 11:59:09 -0500 Subject: [PATCH 572/752] time: skip TestTimerModifiedEarlier on plan9/arm This test is observed to be flaky on the plan9-arm builder. Skip it on that platform until it can be diagnosed and fixed. For #50470 Change-Id: If626af426d856c377e00ac5baaca52899456556e Reviewed-on: https://go-review.googlesource.com/c/go/+/375934 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/time/sleep_test.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/time/sleep_test.go b/src/time/sleep_test.go index c48e704eb7..5a949b6f80 100644 --- a/src/time/sleep_test.go +++ b/src/time/sleep_test.go @@ -7,6 +7,7 @@ package time_test import ( "errors" "fmt" + "internal/testenv" "math/rand" "runtime" "strings" @@ -531,6 +532,10 @@ func TestZeroTimer(t *testing.T) { // Test that rapidly moving a timer earlier doesn't cause it to get dropped. // Issue 47329. func TestTimerModifiedEarlier(t *testing.T) { + if runtime.GOOS == "plan9" && runtime.GOARCH == "arm" { + testenv.SkipFlaky(t, 50470) + } + past := Until(Unix(0, 0)) count := 1000 fail := 0 From c5540e53b1f692a8c977fd1e4ee0915eea66f999 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 5 Jan 2022 12:25:43 -0800 Subject: [PATCH 573/752] go/types, types2: ensure that signature type bounds are interfaces Do this by running verification for instantiated signatures later, after the delayed type parameter set-up had a chance to wrap type bounds in implicit interfaces where needed. Fixes #50450 Change-Id: If3ff7dc0be6af14af854830bfddb81112ac575cb Reviewed-on: https://go-review.googlesource.com/c/go/+/375737 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/call.go | 24 +++++++++++-------- .../types2/testdata/fixedbugs/issue50450.go2 | 11 +++++++++ src/go/types/call.go | 24 +++++++++++-------- .../types/testdata/fixedbugs/issue50450.go2 | 11 +++++++++ 4 files changed, 50 insertions(+), 20 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50450.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50450.go2 diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go index ed8b67c607..d93805e9c7 100644 --- a/src/cmd/compile/internal/types2/call.go +++ b/src/cmd/compile/internal/types2/call.go @@ -74,17 +74,21 @@ func (check *Checker) instantiateSignature(pos syntax.Pos, typ *Signature, targs inst := check.instance(pos, typ, targs, check.bestContext(nil)).(*Signature) assert(len(xlist) <= len(targs)) - tparams := typ.TypeParams().list() - if i, err := check.verify(pos, tparams, targs); err != nil { - // best position for error reporting - pos := pos - if i < len(xlist) { - pos = syntax.StartPos(xlist[i]) + + // verify instantiation lazily (was issue #50450) + check.later(func() { + tparams := typ.TypeParams().list() + if i, err := check.verify(pos, tparams, targs); err != nil { + // best position for error reporting + pos := pos + if i < len(xlist) { + pos = syntax.StartPos(xlist[i]) + } + check.softErrorf(pos, "%s", err) + } else { + check.mono.recordInstance(check.pkg, pos, tparams, targs, xlist) } - check.softErrorf(pos, "%s", err) - } else { - check.mono.recordInstance(check.pkg, pos, tparams, targs, xlist) - } + }) return inst } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50450.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50450.go2 new file mode 100644 index 0000000000..bae3111578 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50450.go2 @@ -0,0 +1,11 @@ +// Copyright 2022 The Go 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 S struct{} + +func f[P S]() {} + +var _ = f[S] diff --git a/src/go/types/call.go b/src/go/types/call.go index 4156d56d9f..ec6efd2379 100644 --- a/src/go/types/call.go +++ b/src/go/types/call.go @@ -75,17 +75,21 @@ func (check *Checker) instantiateSignature(pos token.Pos, typ *Signature, targs inst := check.instance(pos, typ, targs, check.bestContext(nil)).(*Signature) assert(len(xlist) <= len(targs)) - tparams := typ.TypeParams().list() - if i, err := check.verify(pos, tparams, targs); err != nil { - // best position for error reporting - pos := pos - if i < len(xlist) { - pos = xlist[i].Pos() + + // verify instantiation lazily (was issue #50450) + check.later(func() { + tparams := typ.TypeParams().list() + if i, err := check.verify(pos, tparams, targs); err != nil { + // best position for error reporting + pos := pos + if i < len(xlist) { + pos = xlist[i].Pos() + } + check.softErrorf(atPos(pos), _InvalidTypeArg, "%s", err) + } else { + check.mono.recordInstance(check.pkg, pos, tparams, targs, xlist) } - check.softErrorf(atPos(pos), _InvalidTypeArg, "%s", err) - } else { - check.mono.recordInstance(check.pkg, pos, tparams, targs, xlist) - } + }) return inst } diff --git a/src/go/types/testdata/fixedbugs/issue50450.go2 b/src/go/types/testdata/fixedbugs/issue50450.go2 new file mode 100644 index 0000000000..bae3111578 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50450.go2 @@ -0,0 +1,11 @@ +// Copyright 2022 The Go 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 S struct{} + +func f[P S]() {} + +var _ = f[S] From 2bfa6ef63d3cfa89f46cc5f6708c1078f15fb875 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 4 Jan 2022 21:01:21 -0800 Subject: [PATCH 574/752] go/types, types2: remove unused code in lookupFieldOrMethod The underlying type of a type parameter is an interface, so we don't need a special case for type parameters anymore. Simply share the (identical) code for interfaces. Adjust code in types.NewMethodSet accordingly. No functional difference. Preparation for fix of issues below. For #50233. For #50417. Change-Id: Ib2deadd12f89e6918dec224b4ce35583001c3101 Reviewed-on: https://go-review.googlesource.com/c/go/+/375514 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/lookup.go | 32 +++-------------------- src/go/types/lookup.go | 26 +++--------------- src/go/types/methodset.go | 12 +-------- 3 files changed, 9 insertions(+), 61 deletions(-) diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index ee764c7d14..7bdf13b4b7 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -82,7 +82,7 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name typ, isPtr := deref(T) - // *typ where typ is an interface has no methods. + // *typ where typ is an interface (incl. a type parameter) has no methods. if isPtr { if _, ok := under(typ).(*Interface); ok { return @@ -106,7 +106,6 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name var next []embeddedType // embedded types found at current depth // look for (pkg, name) in all types at current depth - var tpar *TypeParam // set if obj receiver is a type parameter for _, e := range current { typ := e.typ @@ -139,13 +138,9 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name indirect = e.indirect continue // we can't have a matching field or interface method } - - // continue with underlying type - typ = named.under() } - tpar = nil - switch t := typ.(type) { + switch t := under(typ).(type) { case *Struct: // look for a matching field and collect embedded types for i, f := range t.fields { @@ -178,7 +173,7 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name } case *Interface: - // look for a matching method + // look for a matching method (interface may be a type parameter) if i, m := lookupMethodFold(t.typeSet().methods, pkg, name, checkFold); m != nil { assert(m.typ != nil) index = concat(e.index, i) @@ -188,24 +183,6 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name obj = m indirect = e.indirect } - - case *TypeParam: - if i, m := lookupMethodFold(t.iface().typeSet().methods, pkg, name, checkFold); m != nil { - assert(m.typ != nil) - index = concat(e.index, i) - if obj != nil || e.multiples { - return nil, index, false // collision - } - tpar = t - obj = m - indirect = e.indirect - } - if obj == nil { - // At this point we're not (yet) looking into methods - // that any underlying type of the types in the type list - // might have. - // TODO(gri) Do we want to specify the language that way? - } } } @@ -217,8 +194,7 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name // is shorthand for (&x).m()". if f, _ := obj.(*Func); f != nil { // determine if method has a pointer receiver - hasPtrRecv := tpar == nil && f.hasPtrRecv() - if hasPtrRecv && !indirect && !addressable { + if f.hasPtrRecv() && !indirect && !addressable { return nil, nil, true // pointer/addressable receiver required } } diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go index c787601a06..7f3fbd6929 100644 --- a/src/go/types/lookup.go +++ b/src/go/types/lookup.go @@ -80,7 +80,7 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o typ, isPtr := deref(T) - // *typ where typ is an interface has no methods. + // *typ where typ is an interface (incl. a type parameter) has no methods. if isPtr { if _, ok := under(typ).(*Interface); ok { return @@ -104,7 +104,6 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o var next []embeddedType // embedded types found at current depth // look for (pkg, name) in all types at current depth - var tpar *TypeParam // set if obj receiver is a type parameter for _, e := range current { typ := e.typ @@ -137,13 +136,9 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o indirect = e.indirect continue // we can't have a matching field or interface method } - - // continue with underlying type - typ = named.under() } - tpar = nil - switch t := typ.(type) { + switch t := under(typ).(type) { case *Struct: // look for a matching field and collect embedded types for i, f := range t.fields { @@ -176,7 +171,7 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o } case *Interface: - // look for a matching method + // look for a matching method (interface may be a type parameter) if i, m := t.typeSet().LookupMethod(pkg, name); m != nil { assert(m.typ != nil) index = concat(e.index, i) @@ -186,18 +181,6 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o obj = m indirect = e.indirect } - - case *TypeParam: - if i, m := t.iface().typeSet().LookupMethod(pkg, name); m != nil { - assert(m.typ != nil) - index = concat(e.index, i) - if obj != nil || e.multiples { - return nil, index, false // collision - } - tpar = t - obj = m - indirect = e.indirect - } } } @@ -209,8 +192,7 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o // is shorthand for (&x).m()". if f, _ := obj.(*Func); f != nil { // determine if method has a pointer receiver - hasPtrRecv := tpar == nil && f.hasPtrRecv() - if hasPtrRecv && !indirect && !addressable { + if f.hasPtrRecv() && !indirect && !addressable { return nil, nil, true // pointer/addressable receiver required } } diff --git a/src/go/types/methodset.go b/src/go/types/methodset.go index e17be7c41a..5c3bc39271 100644 --- a/src/go/types/methodset.go +++ b/src/go/types/methodset.go @@ -126,16 +126,9 @@ func NewMethodSet(T Type) *MethodSet { seen[named] = true mset = mset.add(named.methods, e.index, e.indirect, e.multiples) - - // continue with underlying type, but only if it's not a type parameter - // TODO(rFindley): should this use named.under()? Can there be a difference? - typ = named.underlying - if _, ok := typ.(*TypeParam); ok { - continue - } } - switch t := typ.(type) { + switch t := under(typ).(type) { case *Struct: for i, f := range t.fields { if fset == nil { @@ -158,9 +151,6 @@ func NewMethodSet(T Type) *MethodSet { case *Interface: mset = mset.add(t.typeSet().methods, e.index, true, e.multiples) - - case *TypeParam: - mset = mset.add(t.iface().typeSet().methods, e.index, true, e.multiples) } } From 61014f00f24df8b144d9d235fe3e25ff64b96521 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 5 Jan 2022 15:46:31 -0800 Subject: [PATCH 575/752] go/types, types2: implement field access for struct structural constraints This change implements field the access p.f where the type of p is a type parameter with a structural constraint that is a struct with a field f. This is only the fix for the type checker. The compiler will need a separate CL. This makes the behavior consistent with the fact that we can write struct composite literals for type parameters with a struct structural type. For #50417. For #50233. Change-Id: I87d07e016f97cbf19c45cde19165eae3ec0bad2b Reviewed-on: https://go-review.googlesource.com/c/go/+/375795 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/lookup.go | 18 ++++- .../types2/testdata/fixedbugs/issue50417.go2 | 64 +++++++++++++++++ src/go/types/lookup.go | 18 ++++- .../types/testdata/fixedbugs/issue50417.go2 | 64 +++++++++++++++++ test/typeparam/issue50417.go | 70 +++++++++++++++++++ 5 files changed, 230 insertions(+), 4 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50417.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50417.go2 create mode 100644 test/typeparam/issue50417.go diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index 7bdf13b4b7..77a70a0510 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -43,7 +43,7 @@ import ( // the method's formal receiver base type, nor was the receiver addressable. // func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) { - // Methods cannot be associated to a named pointer type + // Methods cannot be associated to a named pointer type. // (spec: "The type denoted by T is called the receiver base type; // it must not be a pointer or interface type and it must be declared // in the same package as the method."). @@ -60,7 +60,21 @@ func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o } } - return lookupFieldOrMethod(T, addressable, false, pkg, name) + obj, index, indirect = lookupFieldOrMethod(T, addressable, false, pkg, name) + + // If we didn't find anything and if we have a type parameter with a structural constraint, + // see if there is a matching field (but not a method, those need to be declared explicitly + // in the constraint). If the structural constraint is a named pointer type (see above), we + // are ok here because only fields are accepted as results. + if obj == nil && isTypeParam(T) { + if t := structuralType(T); t != nil { + obj, index, indirect = lookupFieldOrMethod(t, addressable, false, pkg, name) + if _, ok := obj.(*Var); !ok { + obj, index, indirect = nil, nil, false // accept fields (variables) only + } + } + } + return } // TODO(gri) The named type consolidation and seen maps below must be diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50417.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50417.go2 new file mode 100644 index 0000000000..c05987e5ea --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50417.go2 @@ -0,0 +1,64 @@ +// Copyright 2022 The Go 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 Sf struct { + f int +} + +func f0[P Sf](p P) { + _ = p.f + p.f = 0 +} + +func f0t[P ~struct{f int}](p P) { + _ = p.f + p.f = 0 +} + +var _ = f0[Sf] +var _ = f0t[Sf] + +var _ = f0[Sm /* ERROR does not implement */ ] +var _ = f0t[Sm /* ERROR does not implement */ ] + +func f1[P interface{ Sf; m() }](p P) { + _ = p.f + p.f = 0 + p.m() +} + +var _ = f1[Sf /* ERROR missing method m */ ] +var _ = f1[Sm /* ERROR does not implement */ ] + +type Sm struct {} + +func (Sm) m() {} + +type Sfm struct { + f int +} + +func (Sfm) m() {} + +func f2[P interface{ Sfm; m() }](p P) { + _ = p.f + p.f = 0 + p.m() +} + +var _ = f2[Sfm] + +// special case: structural type is a named pointer type + +type PSfm *Sfm + +func f3[P interface{ PSfm }](p P) { + _ = p.f + p.f = 0 + p.m /* ERROR type bound for P has no method m */ () +} + +var _ = f3[PSfm] diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go index 7f3fbd6929..e593351804 100644 --- a/src/go/types/lookup.go +++ b/src/go/types/lookup.go @@ -43,7 +43,7 @@ import ( // the method's formal receiver base type, nor was the receiver addressable. // func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) { - // Methods cannot be associated to a named pointer type + // Methods cannot be associated to a named pointer type. // (spec: "The type denoted by T is called the receiver base type; // it must not be a pointer or interface type and it must be declared // in the same package as the method."). @@ -60,7 +60,21 @@ func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o } } - return lookupFieldOrMethod(T, addressable, pkg, name) + obj, index, indirect = lookupFieldOrMethod(T, addressable, pkg, name) + + // If we didn't find anything and if we have a type parameter with a structural constraint, + // see if there is a matching field (but not a method, those need to be declared explicitly + // in the constraint). If the structural constraint is a named pointer type (see above), we + // are ok here because only fields are accepted as results. + if obj == nil && isTypeParam(T) { + if t := structuralType(T); t != nil { + obj, index, indirect = lookupFieldOrMethod(t, addressable, pkg, name) + if _, ok := obj.(*Var); !ok { + obj, index, indirect = nil, nil, false // accept fields (variables) only + } + } + } + return } // TODO(gri) The named type consolidation and seen maps below must be diff --git a/src/go/types/testdata/fixedbugs/issue50417.go2 b/src/go/types/testdata/fixedbugs/issue50417.go2 new file mode 100644 index 0000000000..c05987e5ea --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50417.go2 @@ -0,0 +1,64 @@ +// Copyright 2022 The Go 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 Sf struct { + f int +} + +func f0[P Sf](p P) { + _ = p.f + p.f = 0 +} + +func f0t[P ~struct{f int}](p P) { + _ = p.f + p.f = 0 +} + +var _ = f0[Sf] +var _ = f0t[Sf] + +var _ = f0[Sm /* ERROR does not implement */ ] +var _ = f0t[Sm /* ERROR does not implement */ ] + +func f1[P interface{ Sf; m() }](p P) { + _ = p.f + p.f = 0 + p.m() +} + +var _ = f1[Sf /* ERROR missing method m */ ] +var _ = f1[Sm /* ERROR does not implement */ ] + +type Sm struct {} + +func (Sm) m() {} + +type Sfm struct { + f int +} + +func (Sfm) m() {} + +func f2[P interface{ Sfm; m() }](p P) { + _ = p.f + p.f = 0 + p.m() +} + +var _ = f2[Sfm] + +// special case: structural type is a named pointer type + +type PSfm *Sfm + +func f3[P interface{ PSfm }](p P) { + _ = p.f + p.f = 0 + p.m /* ERROR type bound for P has no method m */ () +} + +var _ = f3[PSfm] diff --git a/test/typeparam/issue50417.go b/test/typeparam/issue50417.go new file mode 100644 index 0000000000..bf6ac424c5 --- /dev/null +++ b/test/typeparam/issue50417.go @@ -0,0 +1,70 @@ +// run + +// Copyright 2022 The Go 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() {} + +type Sf struct { + f int +} + +func f0[P Sf](p P) { + _ = p.f + p.f = 0 +} + +func f0t[P ~struct{ f int }](p P) { + _ = p.f + p.f = 0 +} + +// TODO(danscales) enable once the compiler is fixed +// var _ = f0[Sf] +// var _ = f0t[Sf] + +func f1[P interface { + Sf + m() +}](p P) { + _ = p.f + p.f = 0 + p.m() +} + +type Sm struct{} + +func (Sm) m() {} + +type Sfm struct { + f int +} + +func (Sfm) m() {} + +func f2[P interface { + Sfm + m() +}](p P) { + _ = p.f + p.f = 0 + p.m() +} + +// TODO(danscales) enable once the compiler is fixed +// var _ = f2[Sfm] + +// special case: structural type is a named pointer type + +type PSfm *Sfm + +func f3[P interface{ PSfm }](p P) { + _ = p.f + p.f = 0 +} + +// TODO(danscales) enable once the compiler is fixed +// var _ = f3[PSfm] From b9cae6f78f129bb3f1b3293da5375040f5c4f356 Mon Sep 17 00:00:00 2001 From: Katie Hockman Date: Wed, 22 Dec 2021 10:34:55 -0500 Subject: [PATCH 576/752] testing: fix deadlock with t.Parallel in testing seed corpus The c.startParallel channel on the testContext is stuck in t.Parallel() because c.running starts at 1 for the main fuzz parent test, and is causing a deadlock because it is never released. It would normally be released by tRunner, but needs to instead be released by fRunner instead for fuzz tests. Fixes #50217 Change-Id: I2d010e9adddfd8e8321ff2f9dd2e43daf46c128f Reviewed-on: https://go-review.googlesource.com/c/go/+/374054 Reviewed-by: Roland Shoemaker Reviewed-by: Bryan Mills Trust: Katie Hockman Run-TryBot: Katie Hockman TryBot-Result: Gopher Robot --- src/cmd/go/testdata/script/test_fuzz_parallel.txt | 7 +++++++ src/testing/fuzz.go | 9 +++++---- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/src/cmd/go/testdata/script/test_fuzz_parallel.txt b/src/cmd/go/testdata/script/test_fuzz_parallel.txt index 1795e0b2a5..e6325208d0 100644 --- a/src/cmd/go/testdata/script/test_fuzz_parallel.txt +++ b/src/cmd/go/testdata/script/test_fuzz_parallel.txt @@ -13,6 +13,13 @@ go test -run=FuzzSeed ! go test -run=FuzzMutate -fuzz=FuzzMutate exists testdata/fuzz/FuzzMutate +# Testdata should now contain a corpus entry which will fail FuzzMutate. +# Run the test without fuzzing, setting -parallel to different values to make +# sure it fails, and doesn't hang. +! go test -run=FuzzMutate -parallel=1 +! go test -run=FuzzMutate -parallel=2 +! go test -run=FuzzMutate -parallel=4 + -- go.mod -- module fuzz_parallel diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go index efb59b3e57..037d531acf 100644 --- a/src/testing/fuzz.go +++ b/src/testing/fuzz.go @@ -323,10 +323,10 @@ func (f *F) Fuzz(ff any) { for _, v := range e.Values { args = append(args, reflect.ValueOf(v)) } - // Before reseting the current coverage, defer the snapshot so that we - // make sure it is called right before the tRunner function exits, - // regardless of whether it was executed cleanly, panicked, or if the - // fuzzFn called t.Fatal. + // Before resetting the current coverage, defer the snapshot so that + // we make sure it is called right before the tRunner function + // exits, regardless of whether it was executed cleanly, panicked, + // or if the fuzzFn called t.Fatal. defer f.fuzzContext.deps.SnapshotCoverage() f.fuzzContext.deps.ResetCoverage() fn.Call(args) @@ -666,6 +666,7 @@ func fRunner(f *F, fn func(*F)) { // This only affects fuzz tests run as normal tests. // While fuzzing, T.Parallel has no effect, so f.sub is empty, and this // branch is not taken. f.barrier is nil in that case. + f.testContext.release() close(f.barrier) // Wait for the subtests to complete. for _, sub := range f.sub { From 042548b1fdba21e351368e9f3ecd93059d09083f Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 6 Jan 2022 10:58:30 -0800 Subject: [PATCH 577/752] cmd/compile: report type parameter error for methods only once Move switch to enable method type parameters entirely to the parser, by adding the mode AllowMethodTypeParams. Ensure that the error messages are consistent. Remove unnecessary code in the type checker. Fixes #50317. Change-Id: I4f3958722400bdb919efa4c494b85cf62f4002bb Reviewed-on: https://go-review.googlesource.com/c/go/+/376054 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/syntax/parser.go | 12 +++++++++--- src/cmd/compile/internal/syntax/parser_test.go | 2 +- src/cmd/compile/internal/syntax/syntax.go | 1 + .../internal/syntax/testdata/issue48382.go2 | 10 +++++----- .../compile/internal/syntax/testdata/tparams.go2 | 2 +- src/cmd/compile/internal/types2/api_test.go | 2 +- src/cmd/compile/internal/types2/check_test.go | 2 +- src/cmd/compile/internal/types2/interface.go | 7 ------- src/cmd/compile/internal/types2/lookup.go | 5 +++++ src/cmd/compile/internal/types2/resolver.go | 9 ++------- src/cmd/compile/internal/types2/signature.go | 10 +--------- .../types2/testdata/fixedbugs/issue39634.go2 | 2 +- src/cmd/compile/internal/types2/types_test.go | 9 --------- test/typeparam/issue50317.go | 15 +++++++++++++++ 14 files changed, 43 insertions(+), 45 deletions(-) delete mode 100644 src/cmd/compile/internal/types2/types_test.go create mode 100644 test/typeparam/issue50317.go diff --git a/src/cmd/compile/internal/syntax/parser.go b/src/cmd/compile/internal/syntax/parser.go index 40c5eca408..a75a3b1a2e 100644 --- a/src/cmd/compile/internal/syntax/parser.go +++ b/src/cmd/compile/internal/syntax/parser.go @@ -760,7 +760,13 @@ func (p *parser) funcDeclOrNil() *FuncDecl { } f.Name = p.name() - f.TParamList, f.Type = p.funcType("") + + context := "" + if f.Recv != nil && p.mode&AllowMethodTypeParams == 0 { + context = "method" // don't permit (method) type parameters in funcType + } + f.TParamList, f.Type = p.funcType(context) + if p.tok == _Lbrace { f.Body = p.funcBody() } @@ -1415,7 +1421,7 @@ func (p *parser) funcType(context string) ([]*Field, *FuncType) { if p.allowGenerics() && p.got(_Lbrack) { if context != "" { // accept but complain - p.syntaxErrorAt(typ.pos, context+" cannot have type parameters") + p.syntaxErrorAt(typ.pos, context+" must have no type parameters") } if p.tok == _Rbrack { p.syntaxError("empty type parameter list") @@ -1823,7 +1829,7 @@ func (p *parser) methodDecl() *Field { // TODO(gri) Record list as type parameter list with f.Type // if we want to type-check the generic method. // For now, report an error so this is not a silent event. - p.errorAt(pos, "interface method cannot have type parameters") + p.errorAt(pos, "interface method must have no type parameters") break } diff --git a/src/cmd/compile/internal/syntax/parser_test.go b/src/cmd/compile/internal/syntax/parser_test.go index 68f3c376c9..e258a17c38 100644 --- a/src/cmd/compile/internal/syntax/parser_test.go +++ b/src/cmd/compile/internal/syntax/parser_test.go @@ -46,7 +46,7 @@ func TestParseGo2(t *testing.T) { for _, fi := range list { name := fi.Name() if !fi.IsDir() && !strings.HasPrefix(name, ".") { - ParseFile(filepath.Join(dir, name), func(err error) { t.Error(err) }, nil, AllowGenerics) + ParseFile(filepath.Join(dir, name), func(err error) { t.Error(err) }, nil, AllowGenerics|AllowMethodTypeParams) } } } diff --git a/src/cmd/compile/internal/syntax/syntax.go b/src/cmd/compile/internal/syntax/syntax.go index f3d4c09ed5..25c8116206 100644 --- a/src/cmd/compile/internal/syntax/syntax.go +++ b/src/cmd/compile/internal/syntax/syntax.go @@ -17,6 +17,7 @@ type Mode uint const ( CheckBranches Mode = 1 << iota // check correct use of labels, break, continue, and goto statements AllowGenerics + AllowMethodTypeParams // does not support interface methods yet; ignored if AllowGenerics is not set ) // Error describes a syntax error. Error implements the error interface. diff --git a/src/cmd/compile/internal/syntax/testdata/issue48382.go2 b/src/cmd/compile/internal/syntax/testdata/issue48382.go2 index 1e8f4b0ec6..c00fee6f82 100644 --- a/src/cmd/compile/internal/syntax/testdata/issue48382.go2 +++ b/src/cmd/compile/internal/syntax/testdata/issue48382.go2 @@ -4,12 +4,12 @@ package p -type _ func /* ERROR function type cannot have type parameters */ [ /* ERROR empty type parameter list */ ]() -type _ func /* ERROR function type cannot have type parameters */ [ x /* ERROR missing type constraint */ ]() -type _ func /* ERROR function type cannot have type parameters */ [P any]() +type _ func /* ERROR function type must have no type parameters */ [ /* ERROR empty type parameter list */ ]() +type _ func /* ERROR function type must have no type parameters */ [ x /* ERROR missing type constraint */ ]() +type _ func /* ERROR function type must have no type parameters */ [P any]() -var _ = func /* ERROR function literal cannot have type parameters */ [P any]() {} +var _ = func /* ERROR function literal must have no type parameters */ [P any]() {} type _ interface{ - m /* ERROR interface method cannot have type parameters */ [P any]() + m /* ERROR interface method must have no type parameters */ [P any]() } diff --git a/src/cmd/compile/internal/syntax/testdata/tparams.go2 b/src/cmd/compile/internal/syntax/testdata/tparams.go2 index 80e155bfe0..a9bd72cf2d 100644 --- a/src/cmd/compile/internal/syntax/testdata/tparams.go2 +++ b/src/cmd/compile/internal/syntax/testdata/tparams.go2 @@ -13,7 +13,7 @@ type t struct { } type t interface { t[a] - m /* ERROR method cannot have type parameters */ [_ _, /* ERROR mixed */ _]() + m /* ERROR method must have no type parameters */ [_ _, /* ERROR mixed */ _]() t[a, b] } diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go index dee7ffbaf7..28c1f97e87 100644 --- a/src/cmd/compile/internal/types2/api_test.go +++ b/src/cmd/compile/internal/types2/api_test.go @@ -25,7 +25,7 @@ const brokenPkg = "package broken_" func parseSrc(path, src string) (*syntax.File, error) { errh := func(error) {} // dummy error handler so that parsing continues in presence of errors - return syntax.Parse(syntax.NewFileBase(path), strings.NewReader(src), errh, nil, syntax.AllowGenerics) + return syntax.Parse(syntax.NewFileBase(path), strings.NewReader(src), errh, nil, syntax.AllowGenerics|syntax.AllowMethodTypeParams) } func pkgFor(path, source string, info *Info) (*Package, error) { diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go index f13679d1e3..1868ad0c6e 100644 --- a/src/cmd/compile/internal/types2/check_test.go +++ b/src/cmd/compile/internal/types2/check_test.go @@ -118,7 +118,7 @@ func testFiles(t *testing.T, filenames []string, colDelta uint, manual bool) { var mode syntax.Mode if strings.HasSuffix(filenames[0], ".go2") || manual { - mode |= syntax.AllowGenerics + mode |= syntax.AllowGenerics | syntax.AllowMethodTypeParams } // parse files and collect parser errors files, errlist := parseFiles(t, filenames, mode) diff --git a/src/cmd/compile/internal/types2/interface.go b/src/cmd/compile/internal/types2/interface.go index b048fdd9e2..4ce75c476c 100644 --- a/src/cmd/compile/internal/types2/interface.go +++ b/src/cmd/compile/internal/types2/interface.go @@ -136,13 +136,6 @@ func (check *Checker) interfaceType(ityp *Interface, iface *syntax.InterfaceType continue // ignore } - // Always type-check method type parameters but complain if they are not enabled. - // (This extra check is needed here because interface method signatures don't have - // a receiver specification.) - if sig.tparams != nil && !acceptMethodTypeParams { - check.error(f.Type, "methods cannot have type parameters") - } - // use named receiver type if available (for better error messages) var recvTyp Type = ityp if def != nil { diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index 77a70a0510..0cce3fdc3f 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -282,6 +282,11 @@ func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType b return m, typ != nil } +// If we accept type parameters for methods, (at least) the code +// guarded with this constant will need to be adjusted when such +// methods are used (not just parsed). +const acceptMethodTypeParams = false + // missingMethod is like MissingMethod but accepts a *Checker as // receiver and an addressable flag. // The receiver may be nil if missingMethod is invoked through diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go index a8cb244c55..a0cad40429 100644 --- a/src/cmd/compile/internal/types2/resolver.go +++ b/src/cmd/compile/internal/types2/resolver.go @@ -448,15 +448,10 @@ func (check *Checker) collectObjects() { } else { // method // d.Recv != nil - if !acceptMethodTypeParams && len(s.TParamList) != 0 { - //check.error(d.TParamList.Pos(), invalidAST + "method must have no type parameters") - check.error(s.TParamList[0], invalidAST+"method must have no type parameters") - hasTParamError = true - } ptr, recv, _ := check.unpackRecv(s.Recv.Type, false) - // (Methods with invalid receiver cannot be associated to a type, and + // Methods with invalid receiver cannot be associated to a type, and // methods with blank _ names are never found; no need to collect any - // of them. They will still be type-checked with all the other functions.) + // of them. They will still be type-checked with all the other functions. if recv != nil && name != "_" { methods = append(methods, methodInfo{obj, ptr, recv}) } diff --git a/src/cmd/compile/internal/types2/signature.go b/src/cmd/compile/internal/types2/signature.go index 06dcd9131a..39161fcdf5 100644 --- a/src/cmd/compile/internal/types2/signature.go +++ b/src/cmd/compile/internal/types2/signature.go @@ -91,9 +91,6 @@ func (s *Signature) String() string { return TypeString(s, nil) } // ---------------------------------------------------------------------------- // Implementation -// Disabled by default, but enabled when running tests (via types_test.go). -var acceptMethodTypeParams bool - // funcType type-checks a function or method type. func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams []*syntax.Field, ftyp *syntax.FuncType) { check.openScope(ftyp, "function") @@ -163,13 +160,8 @@ func (check *Checker) funcType(sig *Signature, recvPar *syntax.Field, tparams [] } if tparams != nil { + // The parser will complain about invalid type parameters for methods. check.collectTypeParams(&sig.tparams, tparams) - // Always type-check method type parameters but complain if they are not enabled. - // (A separate check is needed when type-checking interface method signatures because - // they don't have a receiver specification.) - if recvPar != nil && !acceptMethodTypeParams { - check.error(ftyp, "methods cannot have type parameters") - } } // Value (non-type) parameters' scope starts in the function body. Use a temporary scope for their diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39634.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39634.go2 index 9a98f7f955..c56f23918d 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39634.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39634.go2 @@ -85,7 +85,7 @@ func (t T25[A]) m1() {} var x T25 /* ERROR without instantiation */ .m1 // crash 26 -type T26 = interface{ F26[ /* ERROR cannot have type parameters */ Z any]() } +type T26 = interface{ F26[ /* ERROR interface method must have no type parameters */ Z any]() } func F26[Z any]() T26 { return F26 /* ERROR without instantiation */ [] /* ERROR operand */ } // crash 27 diff --git a/src/cmd/compile/internal/types2/types_test.go b/src/cmd/compile/internal/types2/types_test.go deleted file mode 100644 index 11dca0b53d..0000000000 --- a/src/cmd/compile/internal/types2/types_test.go +++ /dev/null @@ -1,9 +0,0 @@ -// 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 types2 - -func init() { - acceptMethodTypeParams = true -} diff --git a/test/typeparam/issue50317.go b/test/typeparam/issue50317.go new file mode 100644 index 0000000000..c33c4f061c --- /dev/null +++ b/test/typeparam/issue50317.go @@ -0,0 +1,15 @@ +// errorcheck + +// Copyright 2022 The Go 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 S struct{} + +func (S) _[_ any]() {} // ERROR "method must have no type parameters" + +type _ interface { + m[_ any]() // ERROR "method must have no type parameters" +} From c295137ad8e5e947205d060a26164cb71952c1bb Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 6 Jan 2022 14:10:45 -0800 Subject: [PATCH 578/752] go/types, types2: disallow multiple blank type parameters Work-around for #50481: report an error for multiple blank type parameters. It's always possible to use non-blank names in those cases. We expect to lift this restriction for 1.19. For #50481. Change-Id: Ifdd2d91340aac1da3387f7d80d46e44f5997c2a8 Reviewed-on: https://go-review.googlesource.com/c/go/+/376058 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Trust: Dan Scales Reviewed-by: Dan Scales Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/decl.go | 11 +++++++++++ src/go/types/decl.go | 13 +++++++++++++ test/typeparam/issue50481.go | 21 +++++++++++++++++++++ 3 files changed, 45 insertions(+) create mode 100644 test/typeparam/issue50481.go diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index d61d2a8b0d..69388f78be 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -632,8 +632,19 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list []*syntax.Fiel // Declare type parameters up-front. // The scope of type parameters starts at the beginning of the type parameter // list (so we can have mutually recursive parameterized type bounds). + nblanks := 0 for i, f := range list { tparams[i] = check.declareTypeParam(f.Name) + // Issue #50481: For now, disallow multiple blank type parameters because + // it causes problems with export data. Report an error unless we are in + // testing mode ("assert" is defined). + // We expect to lift this restriction for Go 1.19. + if f.Name.Value == "_" { + nblanks++ + if nblanks == 2 && Universe.Lookup("assert") == nil { + check.softErrorf(f, "cannot have multiple blank type parameters (temporary restriction, see issue #50481)") + } + } } // Set the type parameters before collecting the type constraints because diff --git a/src/go/types/decl.go b/src/go/types/decl.go index 02af0d5f3e..bbd3f04b7e 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -684,8 +684,21 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list *ast.FieldList // Declare type parameters up-front, with empty interface as type bound. // The scope of type parameters starts at the beginning of the type parameter // list (so we can have mutually recursive parameterized interfaces). + nblanks := 0 for _, f := range list.List { tparams = check.declareTypeParams(tparams, f.Names) + // Issue #50481: For now, disallow multiple blank type parameters because + // it causes problems with export data. Report an error unless we are in + // testing mode ("assert" is defined). + // We expect to lift this restriction for Go 1.19. + for _, name := range f.Names { + if name.Name == "_" { + nblanks++ + if nblanks == 2 && Universe.Lookup("assert") == nil { + check.softErrorf(name, _InvalidBlank, "cannot have multiple blank type parameters (temporary restriction, see issue #50481)") + } + } + } } // Set the type parameters before collecting the type constraints because diff --git a/test/typeparam/issue50481.go b/test/typeparam/issue50481.go new file mode 100644 index 0000000000..22d61ee29b --- /dev/null +++ b/test/typeparam/issue50481.go @@ -0,0 +1,21 @@ +// errorcheck + +// Copyright 2022 The Go 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 _[_ any] struct{} +type _[_, _ any] struct{} // ERROR "cannot have multiple blank type parameters" +type _[_, _, _ any] struct{} // ERROR "cannot have multiple blank type parameters" +type _[a, _, b, _, c, _ any] struct{} // ERROR "cannot have multiple blank type parameters" + +func _[_ any]() {} +func _[_, _ any]() {} // ERROR "cannot have multiple blank type parameters" +func _[_, _, _ any]() {} // ERROR "cannot have multiple blank type parameters" +func _[a, _, b, _, c, _ any]() {} // ERROR "cannot have multiple blank type parameters" + +type S[P1, P2 any] struct{} + +func (_ S[_, _]) m() {} // this is ok From 07525e16ba9fcb8924ed872b015dc217d1b01b6b Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Thu, 6 Jan 2022 12:20:14 -0500 Subject: [PATCH 579/752] math/big: fix spurious race in Rat.Denom, Float.SetRat Rat maintains the invariant that x.b.neg is always false, but Rat.Denom was writing x.b.neg = false itself too. That makes Rat.Denom a writing operation, when it should be a read-only operation. That in turn makes it unsafe to use from multiple goroutines, which is highly unexpected. Make it read-only and therefore race-free again. Fixes #50473. Change-Id: I97b87913954511e5200c0665d16b9ed63422e505 Reviewed-on: https://go-review.googlesource.com/c/go/+/375935 Trust: Russ Cox Run-TryBot: Russ Cox Reviewed-by: Robert Griesemer --- src/math/big/rat.go | 2 +- src/math/big/rat_test.go | 18 ++++++++++++++++++ 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/src/math/big/rat.go b/src/math/big/rat.go index d35cd4cbd1..731a979ff7 100644 --- a/src/math/big/rat.go +++ b/src/math/big/rat.go @@ -418,7 +418,7 @@ func (x *Rat) Num() *Int { // If the result is a reference to x's denominator it // may change if a new value is assigned to x, and vice versa. func (x *Rat) Denom() *Int { - x.b.neg = false // the result is always >= 0 + // Note that x.b.neg is guaranteed false. if len(x.b.abs) == 0 { // Note: If this proves problematic, we could // panic instead and require the Rat to diff --git a/src/math/big/rat_test.go b/src/math/big/rat_test.go index 02569c1b16..d98c89b357 100644 --- a/src/math/big/rat_test.go +++ b/src/math/big/rat_test.go @@ -726,3 +726,21 @@ func TestIssue34919(t *testing.T) { } } } + +func TestDenomRace(t *testing.T) { + x := NewRat(1, 2) + const N = 3 + c := make(chan bool, N) + for i := 0; i < N; i++ { + go func() { + // Denom (also used by Float.SetRat) used to mutate x unnecessarily, + // provoking race reports when run in the race detector. + x.Denom() + new(Float).SetRat(x) + c <- true + }() + } + for i := 0; i < N; i++ { + <-c + } +} From c1e7c518ae74d3902a2e8fd1f8d8a37cabe2c1cc Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 6 Jan 2022 16:50:49 -0800 Subject: [PATCH 580/752] test/typeparam: adjust test preamble (fix longtests) For #50417. Change-Id: Ic55727c454ec342354f7fbffd22aa350e0d392c2 Reviewed-on: https://go-review.googlesource.com/c/go/+/376174 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Dan Scales Trust: Dan Scales TryBot-Result: Gopher Robot --- test/typeparam/issue50417.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/typeparam/issue50417.go b/test/typeparam/issue50417.go index bf6ac424c5..f6cf73b18f 100644 --- a/test/typeparam/issue50417.go +++ b/test/typeparam/issue50417.go @@ -1,4 +1,4 @@ -// run +// run -gcflags=-G=3 // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style From ab4556a93d88a8ce8dbff1b5fcf7dea27c6c6587 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 6 Jan 2022 18:23:01 -0800 Subject: [PATCH 581/752] test/typeparam: adjust test preamble (fix longtests) For #50317. Change-Id: I24ccf333c380283a36b573ef8fc3e7fcd71bd17f Reviewed-on: https://go-review.googlesource.com/c/go/+/376215 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Dan Scales Trust: Dan Scales --- test/typeparam/issue50317.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/typeparam/issue50317.go b/test/typeparam/issue50317.go index c33c4f061c..df879c1f01 100644 --- a/test/typeparam/issue50317.go +++ b/test/typeparam/issue50317.go @@ -1,4 +1,4 @@ -// errorcheck +// errorcheck -G=3 // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style From 2bb7f6b4f1e5ffd90d7ea00a653d7407f496d639 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 17 Dec 2021 17:17:41 -0800 Subject: [PATCH 582/752] doc/go1.18: point to spec in same directory for release notes The release notes explicitly refer to sections updated for generics in the spec but then point to the old spec which is very confusing for beta users. For #47694 Change-Id: I5b555db3543cc32f088a8b267ec3f1195a52a812 Reviewed-on: https://go-review.googlesource.com/c/go/+/373174 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 0f313ee454..06a75643fc 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -48,16 +48,16 @@ Do not send CLs removing the interior tags from such phrases.

    The following is a list of the most visible changes. For a more comprehensive overview, see the proposal. - For details see the language spec. + For details see the language spec.

    • The syntax for - Function and - type declarations + function and + type declarations now accepts - type parameters. + type parameters.
    • Parameterized functions and types can be instantiated by following them with a list of @@ -65,11 +65,11 @@ Do not send CLs removing the interior tags from such phrases.
    • The new token ~ has been added to the set of - operators and punctuation. + operators and punctuation.
    • The syntax for - Interface types + Interface types now permits the embedding of arbitrary types (not just type names of interfaces) as well as union and ~T type elements. Such interfaces may only be used as type constraints. @@ -77,13 +77,13 @@ Do not send CLs removing the interior tags from such phrases.
    • The new - predeclared identifier + predeclared identifier any is an alias for the empty interface. It may be used instead of interface{}.
    • The new - predeclared identifier + predeclared identifier comparable is an interface the denotes the set of all types which can be compared using == or !=. It may only be used as (or embedded in) a type constraint. From 40afced8d74a58d66a4f0201c21eb187e50bf325 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 5 Jan 2022 21:37:04 -0800 Subject: [PATCH 583/752] spec: be more precise with rules on specific types Problem pointed out on golang-nuts mailing list. Change-Id: If1c9b22e1ed7b4ec7ebcaadc80fa450333e6856c Reviewed-on: https://go-review.googlesource.com/c/go/+/375799 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index c0b224f977..fa6630719b 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1,6 +1,6 @@ @@ -1988,7 +1988,8 @@ More precisely, for a given interface, the set 𝑆 of specific types is defined
    • For an interface with type elements, 𝑆 is the intersection - of the specific types of its type elements. + of the specific types of its type elements with specific types + (type elements that have no specific types are ignored).
    • For a non-interface type term T @@ -2021,7 +2022,7 @@ interface{ ~string } // string interface{ int|~string } // int, string interface{ Celsius|Kelvin } // Celsius, Kelvin interface{ int; m() } // int (but type set is empty because int has no method m) -interface{ int; any } // no specific types (intersection is empty) +interface{ int; any } // int (any has no specific types and is ignored) interface{ int; string } // no specific types (intersection is empty) From 11b28e7e98bce0d92d8b49c6d222fb66858994ff Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 6 Jan 2022 20:06:40 -0800 Subject: [PATCH 584/752] test/typeparam: adjust test preamble (fix longtests) For #50481. Change-Id: I27e6c6499d6abfea6e215d8aedbdd5074ff88291 Reviewed-on: https://go-review.googlesource.com/c/go/+/376216 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Bryan Mills --- test/typeparam/issue50481.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/typeparam/issue50481.go b/test/typeparam/issue50481.go index 22d61ee29b..23038356bf 100644 --- a/test/typeparam/issue50481.go +++ b/test/typeparam/issue50481.go @@ -1,4 +1,4 @@ -// errorcheck +// errorcheck -G=3 // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style From 2f45981679551e88880a18684a4d65ca3d9b45d9 Mon Sep 17 00:00:00 2001 From: Dmitri Shuralyov Date: Fri, 7 Jan 2022 17:50:37 +0000 Subject: [PATCH 585/752] .github: remove duplicate security link Since a SECURITY.md file is present in the main Go repository, GitHub already shows a "Report a security vulnerability" link in the issue template list. Remove the duplicate custom link. Fixes #49962. Change-Id: Ifdf7e93b76ebd9258d907aa9cb4915c0dbc4f93e Reviewed-on: https://go-review.googlesource.com/c/go/+/376357 Trust: Dmitri Shuralyov Reviewed-by: Julie Qiu --- .github/ISSUE_TEMPLATE/config.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml index ddf5fc6833..c07f1e4d1c 100644 --- a/.github/ISSUE_TEMPLATE/config.yml +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -3,6 +3,3 @@ contact_links: - name: Questions about: Please use one of the forums for questions or general discussions url: https://go.dev/wiki/Questions - - name: Security Vulnerabilities - about: See here for our security policy - url: https://go.dev/security From 98ed91636926b4029bbbbb8c2ab4b66ee15a5734 Mon Sep 17 00:00:00 2001 From: Cuong Manh Le Date: Wed, 5 Jan 2022 16:19:19 +0700 Subject: [PATCH 586/752] cmd/compile: fix instantiation of types referenced during inlining CL 352870 added extra phase for instantiation after inlining, to take care of the new fully-instantiated types. However, when fetching inlined body of these types's methods, we need to allow OADDR operations on untyped expressions, the same as what main inlining phase does. The problem does not show up, until CL 371554, which made the compiler do not re-typecheck while importing, thus leaving a OXDOT node to be marked as address taken when it's not safe to do that. Fixes #50437 Change-Id: I20076b872182c520075a4f8b84230f5bcb05b341 Reviewed-on: https://go-review.googlesource.com/c/go/+/375574 Trust: Cuong Manh Le Run-TryBot: Cuong Manh Le TryBot-Result: Gopher Robot Reviewed-by: Dan Scales Trust: Dan Scales Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/main.go | 5 +++ src/cmd/compile/internal/typecheck/subr.go | 2 +- test/typeparam/issue50437.dir/a.go | 43 ++++++++++++++++++++++ test/typeparam/issue50437.dir/b.go | 11 ++++++ test/typeparam/issue50437.go | 7 ++++ 5 files changed, 67 insertions(+), 1 deletion(-) create mode 100644 test/typeparam/issue50437.dir/a.go create mode 100644 test/typeparam/issue50437.dir/b.go create mode 100644 test/typeparam/issue50437.go diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go index ed81ef7bc0..669e53d932 100644 --- a/src/cmd/compile/internal/gc/main.go +++ b/src/cmd/compile/internal/gc/main.go @@ -248,7 +248,12 @@ func Main(archInit func(*ssagen.ArchInfo)) { // If any new fully-instantiated types were referenced during // inlining, we need to create needed instantiations. if len(typecheck.GetInstTypeList()) > 0 { + // typecheck.IncrementalAddrtaken must be false when loading + // an inlined body. See comment in typecheck.ImportedBody function. + old := typecheck.IncrementalAddrtaken + typecheck.IncrementalAddrtaken = false noder.BuildInstantiations(false) + typecheck.IncrementalAddrtaken = old } } noder.MakeWrappers(typecheck.Target) // must happen after inlining diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go index 5b5b043715..da5e9645ea 100644 --- a/src/cmd/compile/internal/typecheck/subr.go +++ b/src/cmd/compile/internal/typecheck/subr.go @@ -80,7 +80,7 @@ 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. + // main typecheck has completed, and not loading the inlined body. // 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. diff --git a/test/typeparam/issue50437.dir/a.go b/test/typeparam/issue50437.dir/a.go new file mode 100644 index 0000000000..4a136b52ae --- /dev/null +++ b/test/typeparam/issue50437.dir/a.go @@ -0,0 +1,43 @@ +// Copyright 2022 The Go 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 MarshalOptions struct { + *typedArshalers[MarshalOptions] +} + +func Marshal(in interface{}) (out []byte, err error) { + return MarshalOptions{}.Marshal(in) +} + +func (mo MarshalOptions) Marshal(in interface{}) (out []byte, err error) { + err = mo.MarshalNext(in) + return nil, err +} + +func (mo MarshalOptions) MarshalNext(in interface{}) error { + a := new(arshaler) + a.marshal = func(MarshalOptions) error { return nil } + return a.marshal(mo) +} + +type arshaler struct { + marshal func(MarshalOptions) error +} + +type typedArshalers[Options any] struct { + m M +} + +func (a *typedArshalers[Options]) lookup(fnc func(Options) error) (func(Options) error, bool) { + a.m.Load(nil) + return fnc, false +} + +type M struct {} + +func (m *M) Load(key any) (value any, ok bool) { + return +} diff --git a/test/typeparam/issue50437.dir/b.go b/test/typeparam/issue50437.dir/b.go new file mode 100644 index 0000000000..afddc3f330 --- /dev/null +++ b/test/typeparam/issue50437.dir/b.go @@ -0,0 +1,11 @@ +// Copyright 2022 The Go 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" + +func f() { + a.Marshal(map[int]int{}) +} diff --git a/test/typeparam/issue50437.go b/test/typeparam/issue50437.go new file mode 100644 index 0000000000..87b4ff46c1 --- /dev/null +++ b/test/typeparam/issue50437.go @@ -0,0 +1,7 @@ +// compiledir -G=3 + +// 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 From ade5488d75fefc4afd72f2f6090f4c823c93d083 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 7 Jan 2022 10:06:53 -0800 Subject: [PATCH 587/752] doc/go1.18: document type parameter name restriction For #47694. Change-Id: I00862f987a0ff9f71e0295ce4320e6f9a6a4332f Reviewed-on: https://go-review.googlesource.com/c/go/+/376414 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 06a75643fc..03d2b4e346 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -108,6 +108,12 @@ Do not send CLs removing the interior tags from such phrases. interface type with a non-empty method set. Whether this will ever be permitted is unclear at present.
      • +
    • + A generic type or function currently may declare at most one blank (_) + type parameter name. Note that it is always possible to use an arbitrary new + (unused) identifier in place of a blank type parameter name. + We plan to remove this restriction in Go 1.19. +

    From f1596d76f488e4d82d217418df4191f34b71d117 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Thu, 6 Jan 2022 12:39:37 -0800 Subject: [PATCH 588/752] cmd/compile: fix conv of slice of user-define byte type to string types2 allows the conversion of a slice of a user-defined byte type B (not builtin uint8 or byte) to string. But runtime.slicebytetostring requires a []byte argument, so add in a CONVNOP from []B to []byte if needed. Same for the conversion of a slice of user-defined rune types to string. I made the same change in the transformations of the old typechecker, so as to keep tcConv() and transformConv() in sync. That fixes the bug for -G=0 mode as well. Fixes #23536 Change-Id: Ic79364427f27489187f3f8015bdfbf0769a70d69 Reviewed-on: https://go-review.googlesource.com/c/go/+/376056 Reviewed-by: Matthew Dempsky Reviewed-by: Cuong Manh Le Reviewed-by: Keith Randall Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/noder/transform.go | 25 ++++++++++++++++ src/cmd/compile/internal/typecheck/expr.go | 21 ++++++++++++++ test/fixedbugs/issue23536.go | 22 ++++++++++++++ test/typeparam/issue23536.go | 32 +++++++++++++++++++++ 4 files changed, 100 insertions(+) create mode 100644 test/fixedbugs/issue23536.go create mode 100644 test/typeparam/issue23536.go diff --git a/src/cmd/compile/internal/noder/transform.go b/src/cmd/compile/internal/noder/transform.go index a673484821..6f49106f5e 100644 --- a/src/cmd/compile/internal/noder/transform.go +++ b/src/cmd/compile/internal/noder/transform.go @@ -115,6 +115,31 @@ func transformConv(n *ir.ConvExpr) ir.Node { if n.X.Op() == ir.OLITERAL { return stringtoruneslit(n) } + + case ir.OBYTES2STR: + assert(t.IsSlice()) + assert(t.Elem().Kind() == types.TUINT8) + if t.Elem() != types.ByteType && t.Elem() != types.Types[types.TUINT8] { + // If t is a slice of a user-defined byte type B (not uint8 + // or byte), then add an extra CONVNOP from []B to []byte, so + // that the call to slicebytetostring() added in walk will + // typecheck correctly. + n.X = ir.NewConvExpr(n.X.Pos(), ir.OCONVNOP, types.NewSlice(types.ByteType), n.X) + n.X.SetTypecheck(1) + } + + case ir.ORUNES2STR: + assert(t.IsSlice()) + assert(t.Elem().Kind() == types.TINT32) + if t.Elem() != types.RuneType && t.Elem() != types.Types[types.TINT32] { + // If t is a slice of a user-defined rune type B (not uint32 + // or rune), then add an extra CONVNOP from []B to []rune, so + // that the call to slicerunetostring() added in walk will + // typecheck correctly. + n.X = ir.NewConvExpr(n.X.Pos(), ir.OCONVNOP, types.NewSlice(types.RuneType), n.X) + n.X.SetTypecheck(1) + } + } return n } diff --git a/src/cmd/compile/internal/typecheck/expr.go b/src/cmd/compile/internal/typecheck/expr.go index 9b74bf7a9d..eb316d33db 100644 --- a/src/cmd/compile/internal/typecheck/expr.go +++ b/src/cmd/compile/internal/typecheck/expr.go @@ -466,6 +466,27 @@ func tcConv(n *ir.ConvExpr) ir.Node { if n.X.Op() == ir.OLITERAL { return stringtoruneslit(n) } + + case ir.OBYTES2STR: + if t.Elem() != types.ByteType && t.Elem() != types.Types[types.TUINT8] { + // If t is a slice of a user-defined byte type B (not uint8 + // or byte), then add an extra CONVNOP from []B to []byte, so + // that the call to slicebytetostring() added in walk will + // typecheck correctly. + n.X = ir.NewConvExpr(n.X.Pos(), ir.OCONVNOP, types.NewSlice(types.ByteType), n.X) + n.X.SetTypecheck(1) + } + + case ir.ORUNES2STR: + if t.Elem() != types.RuneType && t.Elem() != types.Types[types.TINT32] { + // If t is a slice of a user-defined rune type B (not uint32 + // or rune), then add an extra CONVNOP from []B to []rune, so + // that the call to slicerunetostring() added in walk will + // typecheck correctly. + n.X = ir.NewConvExpr(n.X.Pos(), ir.OCONVNOP, types.NewSlice(types.RuneType), n.X) + n.X.SetTypecheck(1) + } + } return n } diff --git a/test/fixedbugs/issue23536.go b/test/fixedbugs/issue23536.go new file mode 100644 index 0000000000..07b5033d36 --- /dev/null +++ b/test/fixedbugs/issue23536.go @@ -0,0 +1,22 @@ +// run + +// Copyright 2022 The Go 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 case where a slice of a user-defined byte type (not uint8 or byte) is +// converted to a string. Same for slice of runes. + +package main + +type MyByte byte + +type MyRune rune + +func main() { + var y []MyByte + _ = string(y) + + var z []MyRune + _ = string(z) +} diff --git a/test/typeparam/issue23536.go b/test/typeparam/issue23536.go new file mode 100644 index 0000000000..a4f061802f --- /dev/null +++ b/test/typeparam/issue23536.go @@ -0,0 +1,32 @@ +// run -gcflags=-G=3 + +// Copyright 2022 The Go 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 case where a slice of a user-defined byte type (not uint8 or byte) is +// converted to a string. Same for slice of runes. + +package main + +type MyByte byte + +type MyRune rune + +func f[T []MyByte](x T) string { + return string(x) +} + +func g[T []MyRune](x T) string { + return string(x) +} + +func main() { + var y []MyByte + _ = f(y) + _ = string(y) + + var z []MyRune + _ = g(z) + _ = string(z) +} From be26ca972d2149df09e70789fdf284da01c5e9d8 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 7 Jan 2022 09:54:44 -0500 Subject: [PATCH 589/752] syscall: in TestDirent, make as many ReadDirent calls as are needed MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ReadDirent returns only as many directory entries as will fit in the buffer, and each entry is variable-length — so we have no guarantee in general that a buffer of a given arbitrary size can hold even one entry, let alone all ten entries expected by the test. Instead, iterate calls to ReadDirent until one of the calls returns zero entries and no error, indicating that the directory has been read to completion. Fixes #37323 Change-Id: I7f1cedde7666107256604e4ea1ac13c71f22151a Reviewed-on: https://go-review.googlesource.com/c/go/+/376334 Trust: Bryan Mills Reviewed-by: Ian Lance Taylor Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot --- src/syscall/dirent_test.go | 39 ++++++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 12 deletions(-) diff --git a/src/syscall/dirent_test.go b/src/syscall/dirent_test.go index 6570bf9217..aeb40e57c1 100644 --- a/src/syscall/dirent_test.go +++ b/src/syscall/dirent_test.go @@ -22,7 +22,7 @@ import ( func TestDirent(t *testing.T) { const ( - direntBufSize = 2048 + direntBufSize = 2048 // arbitrary? See https://go.dev/issue/37323. filenameMinSize = 11 ) @@ -37,23 +37,38 @@ func TestDirent(t *testing.T) { } } - buf := bytes.Repeat([]byte("DEADBEAF"), direntBufSize/8) + names := make([]string, 0, 10) + fd, err := syscall.Open(d, syscall.O_RDONLY, 0) if err != nil { t.Fatalf("syscall.open: %v", err) } defer syscall.Close(fd) - n, err := syscall.ReadDirent(fd, buf) - if err != nil { - t.Fatalf("syscall.readdir: %v", err) - } - buf = buf[:n] - names := make([]string, 0, 10) - for len(buf) > 0 { - var bc int - bc, _, names = syscall.ParseDirent(buf, -1, names) - buf = buf[bc:] + buf := bytes.Repeat([]byte{0xCD}, direntBufSize) + for { + n, err := syscall.ReadDirent(fd, buf) + if err == syscall.EINVAL { + // On linux, 'man getdents64' says that EINVAL indicates “result buffer is too small”. + // Try a bigger buffer. + t.Logf("ReadDirent: %v; retrying with larger buffer", err) + buf = bytes.Repeat([]byte{0xCD}, len(buf)*2) + continue + } + if err != nil { + t.Fatalf("syscall.readdir: %v", err) + } + t.Logf("ReadDirent: read %d bytes", n) + if n == 0 { + break + } + + var consumed, count int + consumed, count, names = syscall.ParseDirent(buf[:n], -1, names) + t.Logf("ParseDirent: %d new name(s)", count) + if consumed != n { + t.Fatalf("ParseDirent: consumed %d bytes; expected %d", consumed, n) + } } sort.Strings(names) From c74be77e63c0281abb45dbf9de31fa05a6824934 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 6 Jan 2022 18:02:30 -0800 Subject: [PATCH 590/752] cmd/compile: accept string|[]byte-constrained 2nd argument in append Similarly to what we do for the built-in function `copy`, where we allow a string as 2nd argument to append, also permit a type parameter constrained by string|[]byte. While at it, change date in the manual.go2 test files so that we don't need to constantly correct it when copying a test case from that file into a proper test file. Fixes #50281. Change-Id: I23fed66736aa07bb3c481fe97313e828425ac448 Reviewed-on: https://go-review.googlesource.com/c/go/+/376214 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/builtins.go | 2 +- .../types2/testdata/fixedbugs/issue50281.go2 | 26 +++++++++++++++++++ .../internal/types2/testdata/manual.go2 | 2 +- src/go/types/builtins.go | 2 +- .../types/testdata/fixedbugs/issue50281.go2 | 26 +++++++++++++++++++ src/go/types/testdata/manual.go2 | 2 +- test/typeparam/issue376214.go | 20 ++++++++++++++ 7 files changed, 76 insertions(+), 4 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50281.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50281.go2 create mode 100644 test/typeparam/issue376214.go diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go index fcf02a6975..cea4fd3631 100644 --- a/src/cmd/compile/internal/types2/builtins.go +++ b/src/cmd/compile/internal/types2/builtins.go @@ -101,7 +101,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( if x.mode == invalid { return } - if allString(x.typ) { + if t := structuralString(x.typ); t != nil && isString(t) { if check.Types != nil { sig := makeSig(S, S, x.typ) sig.variadic = true diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50281.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50281.go2 new file mode 100644 index 0000000000..f333e81a70 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50281.go2 @@ -0,0 +1,26 @@ +// Copyright 2022 The Go 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 _[S string | []byte](s S) { + var buf []byte + _ = append(buf, s...) +} + +func _[S ~string | ~[]byte](s S) { + var buf []byte + _ = append(buf, s...) +} + +// test case from issue + +type byteseq interface { + string | []byte +} + +// This should allow to eliminate the two functions above. +func AppendByteString[source byteseq](buf []byte, s source) []byte { + return append(buf, s[1:6]...) +} diff --git a/src/cmd/compile/internal/types2/testdata/manual.go2 b/src/cmd/compile/internal/types2/testdata/manual.go2 index efe13cf8bc..96d4ba67c2 100644 --- a/src/cmd/compile/internal/types2/testdata/manual.go2 +++ b/src/cmd/compile/internal/types2/testdata/manual.go2 @@ -1,4 +1,4 @@ -// Copyright 2021 The Go Authors. All rights reserved. +// Copyright 2022 The Go 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/src/go/types/builtins.go b/src/go/types/builtins.go index 828220f257..35a2d1ae2e 100644 --- a/src/go/types/builtins.go +++ b/src/go/types/builtins.go @@ -102,7 +102,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b if x.mode == invalid { return } - if allString(x.typ) { + if t := structuralString(x.typ); t != nil && isString(t) { if check.Types != nil { sig := makeSig(S, S, x.typ) sig.variadic = true diff --git a/src/go/types/testdata/fixedbugs/issue50281.go2 b/src/go/types/testdata/fixedbugs/issue50281.go2 new file mode 100644 index 0000000000..f333e81a70 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50281.go2 @@ -0,0 +1,26 @@ +// Copyright 2022 The Go 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 _[S string | []byte](s S) { + var buf []byte + _ = append(buf, s...) +} + +func _[S ~string | ~[]byte](s S) { + var buf []byte + _ = append(buf, s...) +} + +// test case from issue + +type byteseq interface { + string | []byte +} + +// This should allow to eliminate the two functions above. +func AppendByteString[source byteseq](buf []byte, s source) []byte { + return append(buf, s[1:6]...) +} diff --git a/src/go/types/testdata/manual.go2 b/src/go/types/testdata/manual.go2 index 25e6f22f94..a7caee9903 100644 --- a/src/go/types/testdata/manual.go2 +++ b/src/go/types/testdata/manual.go2 @@ -1,4 +1,4 @@ -// Copyright 2021 The Go Authors. All rights reserved. +// Copyright 2022 The Go 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/typeparam/issue376214.go b/test/typeparam/issue376214.go new file mode 100644 index 0000000000..8f94f4107d --- /dev/null +++ b/test/typeparam/issue376214.go @@ -0,0 +1,20 @@ +// run -gcflags=-G=3 + +// Copyright 2022 The Go 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 add[S ~string | ~[]byte](buf *[]byte, s S) { + *buf = append(*buf, s...) +} + +func main() { + var buf []byte + add(&buf, "foo") + add(&buf, []byte("bar")) + if string(buf) != "foobar" { + panic("got " + string(buf)) + } +} From 7f3eb6182ba72b1b45cf313a01b9c7d4b374255f Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Fri, 7 Jan 2022 17:11:41 -0500 Subject: [PATCH 591/752] runtime: skip TestSegv traceback check on 386 The VDSO (__kernel_vsyscall) is reachable via asmcgocall(cgo_start_thread) on linux-386, which causes traceback to throw. Fixes #49182. For #50504. Change-Id: Idb78cb8de752203ce0ed63c2dbd2d12847338688 Reviewed-on: https://go-review.googlesource.com/c/go/+/376656 Reviewed-by: Cherry Mui Trust: Michael Pratt Run-TryBot: Michael Pratt --- src/runtime/crash_cgo_test.go | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/src/runtime/crash_cgo_test.go b/src/runtime/crash_cgo_test.go index 058eae1c09..abaed40977 100644 --- a/src/runtime/crash_cgo_test.go +++ b/src/runtime/crash_cgo_test.go @@ -625,12 +625,20 @@ func TestSegv(t *testing.T) { // TODO(golang.org/issue/49182): Skip, runtime // throws while attempting to generate // traceback. - default: - nowant := "runtime: " - if strings.Contains(got, nowant) { - t.Errorf("unexpectedly saw %q in output", nowant) + return + case "linux": + if runtime.GOARCH == "386" { + // TODO(golang.org/issue/50504): Skip, + // runtime throws while attempting to + // generate traceback from VDSO call + // via asmcgocall. + return } } + nowant := "runtime: " + if strings.Contains(got, nowant) { + t.Errorf("unexpectedly saw %q in output", nowant) + } }) } } From 90860e0c3110ac5898dfe8e0e0fafd0aea8d979a Mon Sep 17 00:00:00 2001 From: Damien Neil Date: Mon, 4 Oct 2021 10:20:22 -0700 Subject: [PATCH 592/752] net/http/internal/testcert: use FIPS-compliant certificate Upgrade the test certificate from RSA 1024 (not FIPS-approved) to RSA 2048 (FIPS-approved), allowing tests to pass when the dev.boringcrypto branch FIPS-only mode is enabled. Fixes #48674. Change-Id: I613d2f8d0207bf3683fd0df256bf0167604996c5 Reviewed-on: https://go-review.googlesource.com/c/go/+/353869 Trust: Damien Neil Run-TryBot: Damien Neil Reviewed-by: Filippo Valsorda --- src/net/http/internal/testcert/testcert.go | 69 ++++++++++++++-------- 1 file changed, 44 insertions(+), 25 deletions(-) diff --git a/src/net/http/internal/testcert/testcert.go b/src/net/http/internal/testcert/testcert.go index 5f94704ef5..d510e791d6 100644 --- a/src/net/http/internal/testcert/testcert.go +++ b/src/net/http/internal/testcert/testcert.go @@ -10,37 +10,56 @@ import "strings" // LocalhostCert is a PEM-encoded TLS cert with SAN IPs // "127.0.0.1" and "[::1]", expiring at Jan 29 16:00:00 2084 GMT. // generated from src/crypto/tls: -// go run generate_cert.go --rsa-bits 1024 --host 127.0.0.1,::1,example.com --ca --start-date "Jan 1 00:00:00 1970" --duration=1000000h +// go run generate_cert.go --rsa-bits 2048 --host 127.0.0.1,::1,example.com --ca --start-date "Jan 1 00:00:00 1970" --duration=1000000h var LocalhostCert = []byte(`-----BEGIN CERTIFICATE----- -MIICEzCCAXygAwIBAgIQMIMChMLGrR+QvmQvpwAU6zANBgkqhkiG9w0BAQsFADAS +MIIDOTCCAiGgAwIBAgIQSRJrEpBGFc7tNb1fb5pKFzANBgkqhkiG9w0BAQsFADAS MRAwDgYDVQQKEwdBY21lIENvMCAXDTcwMDEwMTAwMDAwMFoYDzIwODQwMTI5MTYw -MDAwWjASMRAwDgYDVQQKEwdBY21lIENvMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCB -iQKBgQDuLnQAI3mDgey3VBzWnB2L39JUU4txjeVE6myuDqkM/uGlfjb9SjY1bIw4 -iA5sBBZzHi3z0h1YV8QPuxEbi4nW91IJm2gsvvZhIrCHS3l6afab4pZBl2+XsDul -rKBxKKtD1rGxlG4LjncdabFn9gvLZad2bSysqz/qTAUStTvqJQIDAQABo2gwZjAO -BgNVHQ8BAf8EBAMCAqQwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDwYDVR0TAQH/BAUw -AwEB/zAuBgNVHREEJzAlggtleGFtcGxlLmNvbYcEfwAAAYcQAAAAAAAAAAAAAAAA -AAAAATANBgkqhkiG9w0BAQsFAAOBgQCEcetwO59EWk7WiJsG4x8SY+UIAA+flUI9 -tyC4lNhbcF2Idq9greZwbYCqTTTr2XiRNSMLCOjKyI7ukPoPjo16ocHj+P3vZGfs -h1fIw3cSS2OolhloGw/XM6RWPWtPAlGykKLciQrBru5NAPvCMsb/I1DAceTiotQM -fblo6RBxUQ== +MDAwWjASMRAwDgYDVQQKEwdBY21lIENvMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEA6Gba5tHV1dAKouAaXO3/ebDUU4rvwCUg/CNaJ2PT5xLD4N1Vcb8r +bFSW2HXKq+MPfVdwIKR/1DczEoAGf/JWQTW7EgzlXrCd3rlajEX2D73faWJekD0U +aUgz5vtrTXZ90BQL7WvRICd7FlEZ6FPOcPlumiyNmzUqtwGhO+9ad1W5BqJaRI6P +YfouNkwR6Na4TzSj5BrqUfP0FwDizKSJ0XXmh8g8G9mtwxOSN3Ru1QFc61Xyeluk +POGKBV/q6RBNklTNe0gI8usUMlYyoC7ytppNMW7X2vodAelSu25jgx2anj9fDVZu +h7AXF5+4nJS4AAt0n1lNY7nGSsdZas8PbQIDAQABo4GIMIGFMA4GA1UdDwEB/wQE +AwICpDATBgNVHSUEDDAKBggrBgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud +DgQWBBStsdjh3/JCXXYlQryOrL4Sh7BW5TAuBgNVHREEJzAlggtleGFtcGxlLmNv +bYcEfwAAAYcQAAAAAAAAAAAAAAAAAAAAATANBgkqhkiG9w0BAQsFAAOCAQEAxWGI +5NhpF3nwwy/4yB4i/CwwSpLrWUa70NyhvprUBC50PxiXav1TeDzwzLx/o5HyNwsv +cxv3HdkLW59i/0SlJSrNnWdfZ19oTcS+6PtLoVyISgtyN6DpkKpdG1cOkW3Cy2P2 ++tK/tKHRP1Y/Ra0RiDpOAmqn0gCOFGz8+lqDIor/T7MTpibL3IxqWfPrvfVRHL3B +grw/ZQTTIVjjh4JBSW3WyWgNo/ikC1lrVxzl4iPUGptxT36Cr7Zk2Bsg0XqwbOvK +5d+NTDREkSnUbie4GeutujmX3Dsx88UiV6UY/4lHJa6I5leHUNOHahRbpbWeOfs/ +WkBKOclmOV2xlTVuPw== -----END CERTIFICATE-----`) // LocalhostKey is the private key for LocalhostCert. var LocalhostKey = []byte(testingKey(`-----BEGIN RSA TESTING KEY----- -MIICXgIBAAKBgQDuLnQAI3mDgey3VBzWnB2L39JUU4txjeVE6myuDqkM/uGlfjb9 -SjY1bIw4iA5sBBZzHi3z0h1YV8QPuxEbi4nW91IJm2gsvvZhIrCHS3l6afab4pZB -l2+XsDulrKBxKKtD1rGxlG4LjncdabFn9gvLZad2bSysqz/qTAUStTvqJQIDAQAB -AoGAGRzwwir7XvBOAy5tM/uV6e+Zf6anZzus1s1Y1ClbjbE6HXbnWWF/wbZGOpet -3Zm4vD6MXc7jpTLryzTQIvVdfQbRc6+MUVeLKwZatTXtdZrhu+Jk7hx0nTPy8Jcb -uJqFk541aEw+mMogY/xEcfbWd6IOkp+4xqjlFLBEDytgbIECQQDvH/E6nk+hgN4H -qzzVtxxr397vWrjrIgPbJpQvBsafG7b0dA4AFjwVbFLmQcj2PprIMmPcQrooz8vp -jy4SHEg1AkEA/v13/5M47K9vCxmb8QeD/asydfsgS5TeuNi8DoUBEmiSJwma7FXY -fFUtxuvL7XvjwjN5B30pNEbc6Iuyt7y4MQJBAIt21su4b3sjXNueLKH85Q+phy2U -fQtuUE9txblTu14q3N7gHRZB4ZMhFYyDy8CKrN2cPg/Fvyt0Xlp/DoCzjA0CQQDU -y2ptGsuSmgUtWj3NM9xuwYPm+Z/F84K6+ARYiZ6PYj013sovGKUFfYAqVXVlxtIX -qyUBnu3X9ps8ZfjLZO7BAkEAlT4R5Yl6cGhaJQYZHOde3JEMhNRcVFMO8dJDaFeo -f9Oeos0UUothgiDktdQHxdNEwLjQf7lJJBzV+5OtwswCWA== +MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDoZtrm0dXV0Aqi +4Bpc7f95sNRTiu/AJSD8I1onY9PnEsPg3VVxvytsVJbYdcqr4w99V3AgpH/UNzMS +gAZ/8lZBNbsSDOVesJ3euVqMRfYPvd9pYl6QPRRpSDPm+2tNdn3QFAvta9EgJ3sW +URnoU85w+W6aLI2bNSq3AaE771p3VbkGolpEjo9h+i42TBHo1rhPNKPkGupR8/QX +AOLMpInRdeaHyDwb2a3DE5I3dG7VAVzrVfJ6W6Q84YoFX+rpEE2SVM17SAjy6xQy +VjKgLvK2mk0xbtfa+h0B6VK7bmODHZqeP18NVm6HsBcXn7iclLgAC3SfWU1jucZK +x1lqzw9tAgMBAAECggEABWzxS1Y2wckblnXY57Z+sl6YdmLV+gxj2r8Qib7g4ZIk +lIlWR1OJNfw7kU4eryib4fc6nOh6O4AWZyYqAK6tqNQSS/eVG0LQTLTTEldHyVJL +dvBe+MsUQOj4nTndZW+QvFzbcm2D8lY5n2nBSxU5ypVoKZ1EqQzytFcLZpTN7d89 +EPj0qDyrV4NZlWAwL1AygCwnlwhMQjXEalVF1ylXwU3QzyZ/6MgvF6d3SSUlh+sq +XefuyigXw484cQQgbzopv6niMOmGP3of+yV4JQqUSb3IDmmT68XjGd2Dkxl4iPki +6ZwXf3CCi+c+i/zVEcufgZ3SLf8D99kUGE7v7fZ6AQKBgQD1ZX3RAla9hIhxCf+O +3D+I1j2LMrdjAh0ZKKqwMR4JnHX3mjQI6LwqIctPWTU8wYFECSh9klEclSdCa64s +uI/GNpcqPXejd0cAAdqHEEeG5sHMDt0oFSurL4lyud0GtZvwlzLuwEweuDtvT9cJ +Wfvl86uyO36IW8JdvUprYDctrQKBgQDycZ697qutBieZlGkHpnYWUAeImVA878sJ +w44NuXHvMxBPz+lbJGAg8Cn8fcxNAPqHIraK+kx3po8cZGQywKHUWsxi23ozHoxo ++bGqeQb9U661TnfdDspIXia+xilZt3mm5BPzOUuRqlh4Y9SOBpSWRmEhyw76w4ZP +OPxjWYAgwQKBgA/FehSYxeJgRjSdo+MWnK66tjHgDJE8bYpUZsP0JC4R9DL5oiaA +brd2fI6Y+SbyeNBallObt8LSgzdtnEAbjIH8uDJqyOmknNePRvAvR6mP4xyuR+Bv +m+Lgp0DMWTw5J9CKpydZDItc49T/mJ5tPhdFVd+am0NAQnmr1MCZ6nHxAoGABS3Y +LkaC9FdFUUqSU8+Chkd/YbOkuyiENdkvl6t2e52jo5DVc1T7mLiIrRQi4SI8N9bN +/3oJWCT+uaSLX2ouCtNFunblzWHBrhxnZzTeqVq4SLc8aESAnbslKL4i8/+vYZlN +s8xtiNcSvL+lMsOBORSXzpj/4Ot8WwTkn1qyGgECgYBKNTypzAHeLE6yVadFp3nQ +Ckq9yzvP/ib05rvgbvrne00YeOxqJ9gtTrzgh7koqJyX1L4NwdkEza4ilDWpucn0 +xiUZS4SoaJq6ZvcBYS62Yr1t8n09iG47YL8ibgtmH3L+svaotvpVxVK+d7BLevA/ +ZboOWVe3icTy64BT3OQhmg== -----END RSA TESTING KEY-----`)) func testingKey(s string) string { return strings.ReplaceAll(s, "TESTING KEY", "PRIVATE KEY") } From 2639f2f79bda2c3a4e9ef7381ca7de14935e2a4a Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 15 Dec 2021 21:25:50 -0800 Subject: [PATCH 593/752] go/types, types2: better error message for invalid == on type parameters Fixes #48712. Change-Id: I6f214cdfdd1815493f2a04828e8f0097f1d8c124 Reviewed-on: https://go-review.googlesource.com/c/go/+/372734 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/expr.go | 18 ++++++-- .../types2/testdata/fixedbugs/issue48712.go2 | 41 +++++++++++++++++++ src/go/types/expr.go | 18 ++++++-- .../types/testdata/fixedbugs/issue48712.go2 | 41 +++++++++++++++++++ 4 files changed, 110 insertions(+), 8 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue48712.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue48712.go2 diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index 3e3104abb6..0147e2adfd 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -770,10 +770,12 @@ func (check *Checker) comparison(x, y *operand, op syntax.Operator) { xok, _ := x.assignableTo(check, y.typ, nil) yok, _ := y.assignableTo(check, x.typ, nil) if xok || yok { + equality := false defined := false switch op { case syntax.Eql, syntax.Neq: // spec: "The equality operators == and != apply to operands that are comparable." + equality = true defined = Comparable(x.typ) && Comparable(y.typ) || x.isNil() && hasNil(y.typ) || y.isNil() && hasNil(x.typ) case syntax.Lss, syntax.Leq, syntax.Gtr, syntax.Geq: // spec: The ordering operators <, <=, >, and >= apply to operands that are ordered." @@ -782,11 +784,19 @@ func (check *Checker) comparison(x, y *operand, op syntax.Operator) { unreachable() } if !defined { - typ := x.typ - if x.isNil() { - typ = y.typ + if equality && (isTypeParam(x.typ) || isTypeParam(y.typ)) { + typ := x.typ + if isTypeParam(y.typ) { + typ = y.typ + } + err = check.sprintf("%s is not comparable", typ) + } else { + typ := x.typ + if x.isNil() { + typ = y.typ + } + err = check.sprintf("operator %s not defined on %s", op, typ) } - err = check.sprintf("operator %s not defined on %s", op, typ) } } else { err = check.sprintf("mismatched types %s and %s", x.typ, y.typ) diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48712.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48712.go2 new file mode 100644 index 0000000000..bad8712fda --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48712.go2 @@ -0,0 +1,41 @@ +// Copyright 2022 The Go 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 _[P comparable](x, y P) { + _ = x == x + _ = x == y + _ = y == x + _ = y == y + + _ = x /* ERROR operator < not defined on P */ < y +} + +func _[P comparable](x P, y any) { + _ = x == x + _ = x == y + _ = y == x + _ = y == y + + _ = x /* ERROR operator < not defined on P */ < y +} + +func _[P any](x, y P) { + _ = x /* ERROR P is not comparable */ == x + _ = x /* ERROR P is not comparable */ == y + _ = y /* ERROR P is not comparable */ == x + _ = y /* ERROR P is not comparable */ == y + + _ = x /* ERROR operator < not defined on P */ < y +} + +func _[P any](x P, y any) { + _ = x /* ERROR P is not comparable */ == x + _ = x /* ERROR P is not comparable */ == y + _ = y /* ERROR P is not comparable */ == x + _ = y == y + + _ = x /* ERROR operator < not defined on P */ < y +} diff --git a/src/go/types/expr.go b/src/go/types/expr.go index 8ddfb8de7e..73b01f4aa4 100644 --- a/src/go/types/expr.go +++ b/src/go/types/expr.go @@ -729,10 +729,12 @@ func (check *Checker) comparison(x, y *operand, op token.Token) { xok, _ := x.assignableTo(check, y.typ, nil) yok, _ := y.assignableTo(check, x.typ, nil) if xok || yok { + equality := false defined := false switch op { case token.EQL, token.NEQ: // spec: "The equality operators == and != apply to operands that are comparable." + equality = true defined = Comparable(x.typ) && Comparable(y.typ) || x.isNil() && hasNil(y.typ) || y.isNil() && hasNil(x.typ) case token.LSS, token.LEQ, token.GTR, token.GEQ: // spec: The ordering operators <, <=, >, and >= apply to operands that are ordered." @@ -741,11 +743,19 @@ func (check *Checker) comparison(x, y *operand, op token.Token) { unreachable() } if !defined { - typ := x.typ - if x.isNil() { - typ = y.typ + if equality && (isTypeParam(x.typ) || isTypeParam(y.typ)) { + typ := x.typ + if isTypeParam(y.typ) { + typ = y.typ + } + err = check.sprintf("%s is not comparable", typ) + } else { + typ := x.typ + if x.isNil() { + typ = y.typ + } + err = check.sprintf("operator %s not defined on %s", op, typ) } - err = check.sprintf("operator %s not defined on %s", op, typ) code = _UndefinedOp } } else { diff --git a/src/go/types/testdata/fixedbugs/issue48712.go2 b/src/go/types/testdata/fixedbugs/issue48712.go2 new file mode 100644 index 0000000000..bad8712fda --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue48712.go2 @@ -0,0 +1,41 @@ +// Copyright 2022 The Go 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 _[P comparable](x, y P) { + _ = x == x + _ = x == y + _ = y == x + _ = y == y + + _ = x /* ERROR operator < not defined on P */ < y +} + +func _[P comparable](x P, y any) { + _ = x == x + _ = x == y + _ = y == x + _ = y == y + + _ = x /* ERROR operator < not defined on P */ < y +} + +func _[P any](x, y P) { + _ = x /* ERROR P is not comparable */ == x + _ = x /* ERROR P is not comparable */ == y + _ = y /* ERROR P is not comparable */ == x + _ = y /* ERROR P is not comparable */ == y + + _ = x /* ERROR operator < not defined on P */ < y +} + +func _[P any](x P, y any) { + _ = x /* ERROR P is not comparable */ == x + _ = x /* ERROR P is not comparable */ == y + _ = y /* ERROR P is not comparable */ == x + _ = y == y + + _ = x /* ERROR operator < not defined on P */ < y +} From 6df0957060b1315db4fd6a359eefc3ee92fcc198 Mon Sep 17 00:00:00 2001 From: Jonathan Amsterdam Date: Sat, 8 Jan 2022 09:18:24 -0500 Subject: [PATCH 594/752] net/http: map FS Open errors just like Dir When an http.FileServer is given a path like file1/file2 where file1 exists but file2 does not, the proper HTTP status should be NotFound. Some OSes return a "not a directory" error instead, so this must be mapped to NotFound. That mapping was already being done for the Dir FileSystem implementation, as discussed in #18984. But it wasn't for the FS implementation. This CL does the same mapping for FS, by generalizing the function that did it for Dir. Fixes #49552 Change-Id: I61d6aa8ef101158e9674707d44e653f5dedbd040 Reviewed-on: https://go-review.googlesource.com/c/go/+/376874 Trust: Jonathan Amsterdam Run-TryBot: Jonathan Amsterdam Reviewed-by: Emmanuel Odeke TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/net/http/fs.go | 16 +++++++++------- src/net/http/fs_test.go | 23 ++++++++++++++++------- 2 files changed, 25 insertions(+), 14 deletions(-) diff --git a/src/net/http/fs.go b/src/net/http/fs.go index 19b2894bf2..6caee9ed93 100644 --- a/src/net/http/fs.go +++ b/src/net/http/fs.go @@ -42,20 +42,20 @@ import ( // An empty Dir is treated as ".". type Dir string -// mapDirOpenError maps the provided non-nil error from opening name +// mapOpenError maps the provided non-nil error from opening name // to a possibly better non-nil error. In particular, it turns OS-specific errors -// about opening files in non-directories into fs.ErrNotExist. See Issue 18984. -func mapDirOpenError(originalErr error, name string) error { +// about opening files in non-directories into fs.ErrNotExist. See Issues 18984 and 49552. +func mapOpenError(originalErr error, name string, sep rune, stat func(string) (fs.FileInfo, error)) error { if errors.Is(originalErr, fs.ErrNotExist) || errors.Is(originalErr, fs.ErrPermission) { return originalErr } - parts := strings.Split(name, string(filepath.Separator)) + parts := strings.Split(name, string(sep)) for i := range parts { if parts[i] == "" { continue } - fi, err := os.Stat(strings.Join(parts[:i+1], string(filepath.Separator))) + fi, err := stat(strings.Join(parts[:i+1], string(sep))) if err != nil { return originalErr } @@ -79,7 +79,7 @@ func (d Dir) Open(name string) (File, error) { fullName := filepath.Join(dir, filepath.FromSlash(path.Clean("/"+name))) f, err := os.Open(fullName) if err != nil { - return nil, mapDirOpenError(err, fullName) + return nil, mapOpenError(err, fullName, filepath.Separator, os.Stat) } return f, nil } @@ -759,7 +759,9 @@ func (f ioFS) Open(name string) (File, error) { } file, err := f.fsys.Open(name) if err != nil { - return nil, err + return nil, mapOpenError(err, name, '/', func(path string) (fs.FileInfo, error) { + return fs.Stat(f.fsys, path) + }) } return ioFile{file}, nil } diff --git a/src/net/http/fs_test.go b/src/net/http/fs_test.go index 4b01cce72d..d627dfd4be 100644 --- a/src/net/http/fs_test.go +++ b/src/net/http/fs_test.go @@ -1244,10 +1244,19 @@ func TestLinuxSendfileChild(*testing.T) { } } -// Issue 18984: tests that requests for paths beyond files return not-found errors +// Issues 18984, 49552: tests that requests for paths beyond files return not-found errors func TestFileServerNotDirError(t *testing.T) { defer afterTest(t) - ts := httptest.NewServer(FileServer(Dir("testdata"))) + t.Run("Dir", func(t *testing.T) { + testFileServerNotDirError(t, func(path string) FileSystem { return Dir(path) }) + }) + t.Run("FS", func(t *testing.T) { + testFileServerNotDirError(t, func(path string) FileSystem { return FS(os.DirFS(path)) }) + }) +} + +func testFileServerNotDirError(t *testing.T, newfs func(string) FileSystem) { + ts := httptest.NewServer(FileServer(newfs("testdata"))) defer ts.Close() res, err := Get(ts.URL + "/index.html/not-a-file") @@ -1259,9 +1268,9 @@ func TestFileServerNotDirError(t *testing.T) { t.Errorf("StatusCode = %v; want 404", res.StatusCode) } - test := func(name string, dir Dir) { + test := func(name string, fsys FileSystem) { t.Run(name, func(t *testing.T) { - _, err = dir.Open("/index.html/not-a-file") + _, err = fsys.Open("/index.html/not-a-file") if err == nil { t.Fatal("err == nil; want != nil") } @@ -1270,7 +1279,7 @@ func TestFileServerNotDirError(t *testing.T) { errors.Is(err, fs.ErrNotExist)) } - _, err = dir.Open("/index.html/not-a-dir/not-a-file") + _, err = fsys.Open("/index.html/not-a-dir/not-a-file") if err == nil { t.Fatal("err == nil; want != nil") } @@ -1286,8 +1295,8 @@ func TestFileServerNotDirError(t *testing.T) { t.Fatal("get abs path:", err) } - test("RelativePath", Dir("testdata")) - test("AbsolutePath", Dir(absPath)) + test("RelativePath", newfs("testdata")) + test("AbsolutePath", newfs(absPath)) } func TestFileServerCleanPath(t *testing.T) { From a40c7b1c77bb8eaaf42e15703a57b9379efc710c Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Thu, 16 Dec 2021 15:30:47 -0500 Subject: [PATCH 595/752] runtime/pprof: run TestCPUProfileMultithreadMagnitude subtests separately Currently TestCPUProfileMultithreadMagnitude runs two CPU consumption functions in a single profile and then analyzes the results as separate subtests. This works fine, but when debugging failures it makes manual analysis of the profile dump a bit annoying. Refactor the test to collect separate profiles for each subtest for easier future analysis. For #50097. For #50232. Change-Id: Ia1c8bb86aaaf652e64c5e660dcc2da47d2194c2b Reviewed-on: https://go-review.googlesource.com/c/go/+/372800 Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot Reviewed-by: Rhys Hiltner Reviewed-by: Bryan Mills --- src/runtime/pprof/pprof_test.go | 137 ++++++++++++++++---------------- 1 file changed, 70 insertions(+), 67 deletions(-) diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index d32046379a..b8b1382ad1 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -79,10 +79,6 @@ func cpuHog2(x int) int { return foo } -func cpuHog3(x int) int { - return cpuHog0(x, 1e5) -} - // Return a list of functions that we don't want to ever appear in CPU // profiles. For gccgo, that list includes the sigprof handler itself. func avoidFunctions() []string { @@ -158,8 +154,6 @@ func TestCPUProfileMultithreadMagnitude(t *testing.T) { maxDiff = 0.40 } - parallelism := runtime.GOMAXPROCS(0) - // This test compares the process's total CPU time against the CPU // profiler's view of time spent in direct execution of user code. // Background work, especially from the garbage collector, adds noise to @@ -168,69 +162,78 @@ func TestCPUProfileMultithreadMagnitude(t *testing.T) { defer debug.SetGCPercent(debug.SetGCPercent(-1)) runtime.GC() - var cpuTime1, cpuTimeN time.Duration - matches := matchAndAvoidStacks(stackContains, []string{"runtime/pprof.cpuHog1", "runtime/pprof.cpuHog3"}, avoidFunctions()) - p := testCPUProfile(t, matches, func(dur time.Duration) { - cpuTime1 = diffCPUTime(t, func() { - // Consume CPU in one goroutine - cpuHogger(cpuHog1, &salt1, dur) + compare := func(a, b time.Duration, maxDiff float64) error { + if a <= 0 || b <= 0 { + return fmt.Errorf("Expected both time reports to be positive") + } + + if a < b { + a, b = b, a + } + + diff := float64(a-b) / float64(a) + if diff > maxDiff { + return fmt.Errorf("CPU usage reports are too different (limit -%.1f%%, got -%.1f%%)", maxDiff*100, diff*100) + } + + return nil + } + + for _, tc := range []struct { + name string + workers int + }{ + { + name: "serial", + workers: 1, + }, + { + name: "parallel", + workers: runtime.GOMAXPROCS(0), + }, + } { + // check that the OS's perspective matches what the Go runtime measures. + t.Run(tc.name, func(t *testing.T) { + t.Logf("Running with %d workers", tc.workers) + + var cpuTime time.Duration + matches := matchAndAvoidStacks(stackContains, []string{"runtime/pprof.cpuHog1"}, avoidFunctions()) + p := testCPUProfile(t, matches, func(dur time.Duration) { + cpuTime = diffCPUTime(t, func() { + var wg sync.WaitGroup + var once sync.Once + for i := 0; i < tc.workers; i++ { + wg.Add(1) + go func() { + defer wg.Done() + var salt = 0 + cpuHogger(cpuHog1, &salt, dur) + once.Do(func() { salt1 = salt }) + }() + } + wg.Wait() + }) + }) + + for i, unit := range []string{"count", "nanoseconds"} { + if have, want := p.SampleType[i].Unit, unit; have != want { + t.Errorf("pN SampleType[%d]; %q != %q", i, have, want) + } + } + + var value time.Duration + for _, sample := range p.Sample { + if stackContains("runtime/pprof.cpuHog1", uintptr(sample.Value[0]), sample.Location, sample.Label) { + value += time.Duration(sample.Value[1]) * time.Nanosecond + } + } + + t.Logf("compare %s vs %s", cpuTime, value) + if err := compare(cpuTime, value, maxDiff); err != nil { + t.Errorf("compare got %v want nil", err) + } }) - - cpuTimeN = diffCPUTime(t, func() { - // Next, consume CPU in several goroutines - var wg sync.WaitGroup - var once sync.Once - for i := 0; i < parallelism; i++ { - wg.Add(1) - go func() { - defer wg.Done() - var salt = 0 - cpuHogger(cpuHog3, &salt, dur) - once.Do(func() { salt1 = salt }) - }() - } - wg.Wait() - }) - }) - - for i, unit := range []string{"count", "nanoseconds"} { - if have, want := p.SampleType[i].Unit, unit; have != want { - t.Errorf("pN SampleType[%d]; %q != %q", i, have, want) - } } - - var value1, valueN time.Duration - for _, sample := range p.Sample { - if stackContains("runtime/pprof.cpuHog1", uintptr(sample.Value[0]), sample.Location, sample.Label) { - value1 += time.Duration(sample.Value[1]) * time.Nanosecond - } - if stackContains("runtime/pprof.cpuHog3", uintptr(sample.Value[0]), sample.Location, sample.Label) { - valueN += time.Duration(sample.Value[1]) * time.Nanosecond - } - } - - compare := func(a, b time.Duration, maxDiff float64) func(*testing.T) { - return func(t *testing.T) { - t.Logf("compare %s vs %s", a, b) - if a <= 0 || b <= 0 { - t.Errorf("Expected both time reports to be positive") - return - } - - if a < b { - a, b = b, a - } - - diff := float64(a-b) / float64(a) - if diff > maxDiff { - t.Errorf("CPU usage reports are too different (limit -%.1f%%, got -%.1f%%)", maxDiff*100, diff*100) - } - } - } - - // check that the OS's perspective matches what the Go runtime measures - t.Run("serial execution OS vs pprof", compare(cpuTime1, value1, maxDiff)) - t.Run("parallel execution OS vs pprof", compare(cpuTimeN, valueN, maxDiff)) } // containsInlinedCall reports whether the function body for the function f is From 931e84af4055dbcf91e986601d99e00c57136330 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Wed, 29 Dec 2021 07:08:55 -0800 Subject: [PATCH 596/752] cmd/compile: fix interaction between generics and inlining Finally figured out how to deal with the interaction between generics and inlining. The problem has been: what to do if you inline a function that uses a new instantiated type that hasn't been seen in the current package? This might mean that you need to do another round of function/method instantiatiations after inlining, which might lead to more inlining, etc. (which is what we currently do, but it's not clear when you can stop the inlining/instantiation loop). We had thought that one solution was to export instantiated types (even if not marked as exportable) if they are referenced in exported inlineable functions. But that was quite complex and required changing the export format. But I realized that we really only need to make sure the relevant dictionaries and shape instantiations for the instantiated types are exported, not the instantiated type itself and its wrappers. The instantiated type is naturally created as needed, and the wrappers are generated automatically while writing out run-time type (making use of the exported dictionaries and shape instantiations). So, we just have to make sure that those dictionaries and shape instantiations are exported, and then they will be available without any extra round of instantiations after inlining. We now do this in crawler.go. This is especially needed when the instantiated type is only put in an interface, so relevant dictionaries/shape instantiations are not directly referenced and therefore exported, but are still needed for the itab. This fix avoids the phase ordering problem where we might have to keep creating new type instantiations and instantiated methods after each round of inlining we do. Removed the extra round of instantiation/inlining that were added in the previous fix. The existing tests test/typeparam{geninline.go,structinit.go} already test this situation of inlining a function referencing a new instantiated type. Added the original example from issue 50121 as test (has 5 packages), since it found a problem with this code that the current simpler test for 50121 did not find. Change-Id: Iac5d0dddf4be19376f6de36ee20a83f0d8f213b5 Reviewed-on: https://go-review.googlesource.com/c/go/+/375494 Reviewed-by: Keith Randall Trust: Dan Scales --- src/cmd/compile/internal/gc/main.go | 10 ---- src/cmd/compile/internal/noder/irgen.go | 2 +- src/cmd/compile/internal/noder/stencil.go | 49 +++++-------------- .../compile/internal/reflectdata/reflect.go | 24 ++++++--- src/cmd/compile/internal/typecheck/crawler.go | 33 ++++++++++++- test/typeparam/issue50121b.dir/a.go | 15 ++++++ test/typeparam/issue50121b.dir/b.go | 11 +++++ test/typeparam/issue50121b.dir/c.go | 13 +++++ test/typeparam/issue50121b.dir/d.go | 13 +++++ test/typeparam/issue50121b.dir/main.go | 12 +++++ test/typeparam/issue50121b.go | 7 +++ 11 files changed, 134 insertions(+), 55 deletions(-) create mode 100644 test/typeparam/issue50121b.dir/a.go create mode 100644 test/typeparam/issue50121b.dir/b.go create mode 100644 test/typeparam/issue50121b.dir/c.go create mode 100644 test/typeparam/issue50121b.dir/d.go create mode 100644 test/typeparam/issue50121b.dir/main.go create mode 100644 test/typeparam/issue50121b.go diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go index 669e53d932..96c6730803 100644 --- a/src/cmd/compile/internal/gc/main.go +++ b/src/cmd/compile/internal/gc/main.go @@ -245,16 +245,6 @@ func Main(archInit func(*ssagen.ArchInfo)) { base.Timer.Start("fe", "inlining") if base.Flag.LowerL != 0 { inline.InlinePackage() - // If any new fully-instantiated types were referenced during - // inlining, we need to create needed instantiations. - if len(typecheck.GetInstTypeList()) > 0 { - // typecheck.IncrementalAddrtaken must be false when loading - // an inlined body. See comment in typecheck.ImportedBody function. - old := typecheck.IncrementalAddrtaken - typecheck.IncrementalAddrtaken = false - noder.BuildInstantiations(false) - typecheck.IncrementalAddrtaken = old - } } noder.MakeWrappers(typecheck.Target) // must happen after inlining diff --git a/src/cmd/compile/internal/noder/irgen.go b/src/cmd/compile/internal/noder/irgen.go index 344a2639ac..52224c4046 100644 --- a/src/cmd/compile/internal/noder/irgen.go +++ b/src/cmd/compile/internal/noder/irgen.go @@ -328,7 +328,7 @@ Outer: // Create any needed instantiations of generic functions and transform // existing and new functions to use those instantiations. - BuildInstantiations(true) + BuildInstantiations() // Remove all generic functions from g.target.Decl, since they have been // used for stenciling, but don't compile. Generic functions will already diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go index d3006d40f8..4c6eaf3fb0 100644 --- a/src/cmd/compile/internal/noder/stencil.go +++ b/src/cmd/compile/internal/noder/stencil.go @@ -9,7 +9,6 @@ package noder import ( "cmd/compile/internal/base" - "cmd/compile/internal/inline" "cmd/compile/internal/ir" "cmd/compile/internal/objw" "cmd/compile/internal/reflectdata" @@ -40,34 +39,29 @@ func infoPrint(format string, a ...interface{}) { var geninst genInst -func BuildInstantiations(preinliningMainScan bool) { - if geninst.instInfoMap == nil { - geninst.instInfoMap = make(map[*types.Sym]*instInfo) - } - geninst.buildInstantiations(preinliningMainScan) +func BuildInstantiations() { + geninst.instInfoMap = make(map[*types.Sym]*instInfo) + geninst.buildInstantiations() + geninst.instInfoMap = nil } // buildInstantiations scans functions for generic function calls and methods, and // creates the required instantiations. It also creates instantiated methods for all // fully-instantiated generic types that have been encountered already or new ones -// that are encountered during the instantiation process. If preinliningMainScan is -// true, it scans all declarations in typecheck.Target.Decls first, before scanning -// any new instantiations created. If preinliningMainScan is false, we do not scan -// any existing decls - we only scan method instantiations for any new -// fully-instantiated types that we saw during inlining. -func (g *genInst) buildInstantiations(preinliningMainScan bool) { +// that are encountered during the instantiation process. It scans all declarations +// in typecheck.Target.Decls first, before scanning any new instantiations created. +func (g *genInst) buildInstantiations() { // Instantiate the methods of instantiated generic types that we have seen so far. g.instantiateMethods() - if preinliningMainScan { - n := len(typecheck.Target.Decls) - for i := 0; i < n; i++ { - g.scanForGenCalls(typecheck.Target.Decls[i]) - } + // Scan all currentdecls for call to generic functions/methods. + n := len(typecheck.Target.Decls) + for i := 0; i < n; i++ { + g.scanForGenCalls(typecheck.Target.Decls[i]) } // Scan all new instantiations created due to g.instantiateMethods() and the - // scan of current decls (if done). This loop purposely runs until no new + // scan of current decls. This loop purposely runs until no new // instantiations are created. for i := 0; i < len(g.newInsts); i++ { g.scanForGenCalls(g.newInsts[i]) @@ -82,10 +76,6 @@ func (g *genInst) buildInstantiations(preinliningMainScan bool) { for _, fun := range g.newInsts { info := g.instInfoMap[fun.Sym()] g.dictPass(info) - if !preinliningMainScan { - // Prepare for the round of inlining below. - inline.CanInline(fun.(*ir.Func)) - } if doubleCheck { ir.Visit(info.fun, func(n ir.Node) { if n.Op() != ir.OCONVIFACE { @@ -103,21 +93,6 @@ func (g *genInst) buildInstantiations(preinliningMainScan bool) { ir.Dump(fmt.Sprintf("\ndictpass %v", info.fun), info.fun) } } - if !preinliningMainScan { - // Extra round of inlining for the new instantiations (only if - // preinliningMainScan is false, which means we have already done the - // main round of inlining) - for _, fun := range g.newInsts { - inline.InlineCalls(fun.(*ir.Func)) - // New instantiations created during inlining should run - // ComputeAddrTaken directly, since we are past the main pass - // that did ComputeAddrTaken(). We could instead do this - // incrementally during stenciling (for all instantiations, - // including main ones before inlining), since we have the - // type information. - typecheck.ComputeAddrtaken(fun.(*ir.Func).Body) - } - } assert(l == len(g.newInsts)) g.newInsts = nil } diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go index b1e2902385..eb1d7b0e07 100644 --- a/src/cmd/compile/internal/reflectdata/reflect.go +++ b/src/cmd/compile/internal/reflectdata/reflect.go @@ -1928,11 +1928,17 @@ func methodWrapper(rcvr *types.Type, method *types.Field, forItab bool) *obj.LSy sym := typecheck.MakeFuncInstSym(ir.MethodSym(methodrcvr, method.Sym), targs, false, true) if sym.Def == nil { - // Currently we make sure that we have all the instantiations - // we need by generating them all in ../noder/stencil.go:instantiateMethods - // TODO: maybe there's a better, more incremental way to generate - // only the instantiations we need? - base.Fatalf("instantiation %s not found", sym.Name) + // Currently we make sure that we have all the + // instantiations we need by generating them all in + // ../noder/stencil.go:instantiateMethods + // Extra instantiations because of an inlined function + // should have been exported, and so available via + // Resolve. + in := typecheck.Resolve(ir.NewIdent(src.NoXPos, sym)) + if in.Op() == ir.ONONAME { + base.Fatalf("instantiation %s not found", sym.Name) + } + sym = in.Sym() } target := ir.AsNode(sym.Def) call = ir.NewCallExpr(base.Pos, ir.OCALL, target, args) @@ -2058,8 +2064,14 @@ func getDictionary(gf *types.Sym, targs []*types.Type) ir.Node { sym := typecheck.MakeDictSym(gf, targs, true) // Dictionary should already have been generated by instantiateMethods(). + // Extra dictionaries needed because of an inlined function should have been + // exported, and so available via Resolve. if lsym := sym.Linksym(); len(lsym.P) == 0 { - base.Fatalf("Dictionary should have already been generated: %s.%s", sym.Pkg.Path, sym.Name) + in := typecheck.Resolve(ir.NewIdent(src.NoXPos, sym)) + if in.Op() == ir.ONONAME { + base.Fatalf("Dictionary should have already been generated: %s.%s", sym.Pkg.Path, sym.Name) + } + sym = in.Sym() } // Make (or reuse) a node referencing the dictionary symbol. diff --git a/src/cmd/compile/internal/typecheck/crawler.go b/src/cmd/compile/internal/typecheck/crawler.go index ae6542d071..5a9649e7a1 100644 --- a/src/cmd/compile/internal/typecheck/crawler.go +++ b/src/cmd/compile/internal/typecheck/crawler.go @@ -222,7 +222,38 @@ func (p *crawler) markInlBody(n *ir.Name) { doFlood = func(n ir.Node) { t := n.Type() if t != nil { - if t.HasTParam() || t.IsFullyInstantiated() { + if t.IsFullyInstantiated() && !t.HasShape() && !t.IsInterface() && t.Methods().Len() > 0 { + // For any fully-instantiated type, the relevant + // dictionaries and shape instantiations will have + // already been created. Make sure that they are + // exported, so that any other package that inlines + // this function will have them available for import, + // and so will not need another round of method and + // dictionary instantiation after inlining. + baseType := t.OrigSym().Def.(*ir.Name).Type() + shapes := make([]*types.Type, len(t.RParams())) + for i, t1 := range t.RParams() { + shapes[i] = Shapify(t1, i) + } + for j := range t.Methods().Slice() { + baseNname := baseType.Methods().Slice()[j].Nname.(*ir.Name) + dictsym := MakeDictSym(baseNname.Sym(), t.RParams(), true) + Export(dictsym.Def.(*ir.Name)) + methsym := MakeFuncInstSym(baseNname.Sym(), shapes, false, true) + methNode := methsym.Def.(*ir.Name) + Export(methNode) + if HaveInlineBody(methNode.Func) { + // Export the body as well if + // instantiation is inlineable. + methNode.Func.SetExportInline(true) + } + } + } + + if t.HasTParam() { + // If any generic types are used, then make sure that + // the methods of the generic type are exported and + // scanned for other possible exports. p.markGeneric(t) } if base.Debug.Unified == 0 { diff --git a/test/typeparam/issue50121b.dir/a.go b/test/typeparam/issue50121b.dir/a.go new file mode 100644 index 0000000000..f2b706e0fd --- /dev/null +++ b/test/typeparam/issue50121b.dir/a.go @@ -0,0 +1,15 @@ +// Copyright 2022 The Go 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 + +import ( + "constraints" +) + +type Builder[T constraints.Integer] struct{} + +func (r Builder[T]) New() T { + return T(42) +} diff --git a/test/typeparam/issue50121b.dir/b.go b/test/typeparam/issue50121b.dir/b.go new file mode 100644 index 0000000000..20f9b38b5f --- /dev/null +++ b/test/typeparam/issue50121b.dir/b.go @@ -0,0 +1,11 @@ +// Copyright 2022 The Go 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 IntBuilder = a.Builder[int]{} diff --git a/test/typeparam/issue50121b.dir/c.go b/test/typeparam/issue50121b.dir/c.go new file mode 100644 index 0000000000..ee9ff9fff7 --- /dev/null +++ b/test/typeparam/issue50121b.dir/c.go @@ -0,0 +1,13 @@ +// Copyright 2022 The Go 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 c + +import ( + "b" +) + +func BuildInt() int { + return b.IntBuilder.New() +} diff --git a/test/typeparam/issue50121b.dir/d.go b/test/typeparam/issue50121b.dir/d.go new file mode 100644 index 0000000000..3020381736 --- /dev/null +++ b/test/typeparam/issue50121b.dir/d.go @@ -0,0 +1,13 @@ +// Copyright 2022 The Go 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 d + +import ( + "c" +) + +func BuildInt() int { + return c.BuildInt() +} diff --git a/test/typeparam/issue50121b.dir/main.go b/test/typeparam/issue50121b.dir/main.go new file mode 100644 index 0000000000..4b6ae414c4 --- /dev/null +++ b/test/typeparam/issue50121b.dir/main.go @@ -0,0 +1,12 @@ +package main + +import ( + "d" + "fmt" +) + +func main() { + if got, want := d.BuildInt(), 42; got != want { + panic(fmt.Sprintf("got %d, want %d", got, want)) + } +} diff --git a/test/typeparam/issue50121b.go b/test/typeparam/issue50121b.go new file mode 100644 index 0000000000..76930e5e4f --- /dev/null +++ b/test/typeparam/issue50121b.go @@ -0,0 +1,7 @@ +// rundir -G=3 + +// 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 From 9e7ea3566e662ba498d64cb63146575202a053ee Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 7 Jan 2022 16:35:31 -0500 Subject: [PATCH 597/752] runtime: expand TestGdbPythonCgo skip to include mips64le The failure mode in #37794 does not match the failure mode described in #18784. However, since the test is currently skipped on all other MIPS variants, it may be that they suffer from the same underlying GDB bug. Ideally one of the Go MIPS maintainers should file an upstream bug and remove the skip once it is fixed; in the meantime, there is no point in continuing to let the test fail on just one of the four MIPS variants. For #37794 Change-Id: I570f51cc04cbb7ef1ed7efd526e26886af53bfb6 Reviewed-on: https://go-review.googlesource.com/c/go/+/376654 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Cherry Mui TryBot-Result: Gopher Robot --- src/runtime/runtime-gdb_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/runtime/runtime-gdb_test.go b/src/runtime/runtime-gdb_test.go index 63d3160ee4..7e8723e15f 100644 --- a/src/runtime/runtime-gdb_test.go +++ b/src/runtime/runtime-gdb_test.go @@ -153,8 +153,8 @@ func TestGdbPython(t *testing.T) { } func TestGdbPythonCgo(t *testing.T) { - if runtime.GOARCH == "mips" || runtime.GOARCH == "mipsle" || runtime.GOARCH == "mips64" { - testenv.SkipFlaky(t, 18784) + if strings.HasPrefix(runtime.GOARCH, "mips") { + testenv.SkipFlaky(t, 37794) } testGdbPython(t, true) } From 933f6685f7d33f3865d6ef062cbb0944d3f5d2fc Mon Sep 17 00:00:00 2001 From: Matthew Dempsky Date: Thu, 16 Dec 2021 12:55:15 -0800 Subject: [PATCH 598/752] cmd/compile: unique LinkString for renamed, embedded fields Using type aliases, it's possible to create structs with embedded fields that have no corresponding type literal notation. However, we still need to generate a unique name for these types to use for linker symbols. This CL introduces a new "struct{ Name = Type }" syntax for use in LinkString formatting to represent these types. Fixes #50190. Change-Id: I025ceb09a86e00b7583d3b9885d612f5d6cb44fe Reviewed-on: https://go-review.googlesource.com/c/go/+/372914 Run-TryBot: Matthew Dempsky Trust: Matthew Dempsky TryBot-Result: Gopher Robot Reviewed-by: Dan Scales Trust: Dan Scales Reviewed-by: Cuong Manh Le Reviewed-by: Robert Griesemer --- src/cmd/compile/internal/types/fmt.go | 37 +++++++++++++++++++++++++-- test/fixedbugs/issue50190.go | 21 +++++++++++++++ 2 files changed, 56 insertions(+), 2 deletions(-) create mode 100644 test/fixedbugs/issue50190.go diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go index 3198a1f53c..1399483424 100644 --- a/src/cmd/compile/internal/types/fmt.go +++ b/src/cmd/compile/internal/types/fmt.go @@ -631,6 +631,7 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty } var name string + nameSep := " " if verb != 'S' { s := f.Sym @@ -639,9 +640,41 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty s = OrigSym(s) } - if s != nil && f.Embedded == 0 { + if s != nil { if funarg != FunargNone { name = fmt.Sprint(f.Nname) + } else if f.Embedded != 0 { + // Using type aliases and embedded fields, it's possible to + // construct types that can't be directly represented as a + // type literal. For example, given "type Int = int" (#50190), + // it would be incorrect to format "struct{ Int }" as either + // "struct{ int }" or "struct{ Int int }", because those each + // represent other, distinct types. + // + // So for the purpose of LinkString (i.e., fmtTypeID), we use + // the non-standard syntax "struct{ Int = int }" to represent + // embedded fields that have been renamed through the use of + // type aliases. + if mode == fmtTypeID { + // Compute styp, the symbol that would normally be used as + // the field name when embedding f.Type. + // TODO(mdempsky): Check for other occurences of this logic + // and deduplicate. + typ := f.Type + if typ.Sym() == nil && typ.IsPtr() { + typ = typ.Elem() + } + styp := typ.Sym() + if styp != nil && IsExported(styp.Name) { + styp = LocalPkg.Lookup(styp.Name) + } + + // If embedded field was renamed, use syntax extension. + if s != styp { + name = sconv(s, 0, mode) + nameSep = " = " + } + } } else if verb == 'L' { name = s.Name if name == ".F" { @@ -658,7 +691,7 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty if name != "" { b.WriteString(name) - b.WriteString(" ") + b.WriteString(nameSep) } if f.IsDDD() { diff --git a/test/fixedbugs/issue50190.go b/test/fixedbugs/issue50190.go new file mode 100644 index 0000000000..01ff6eacaa --- /dev/null +++ b/test/fixedbugs/issue50190.go @@ -0,0 +1,21 @@ +// 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 + +type int float32 + +type Int = int + +type A = struct{ int } +type B = struct{ Int } + +func main() { + var x, y interface{} = A{}, B{} + if x == y { + panic("FAIL") + } +} From 7de2249a08aab44c512d0ea86f50481d76e135f1 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Tue, 28 Dec 2021 18:40:12 -0800 Subject: [PATCH 599/752] cmd/compile, test: updated comments in crawler.go, added test Added a test to make sure that the private methods of a local generic type are properly exported, if there is a global variable with that type. Added comments in crawler.go, to give more detail and to give more about the overall purpose. Fixed one place where t.isFullyInstantiated() should be replaced by isPtrFullyInstantiated(t), so that we catch pointers to generic types that may be used as a method receiver. Change-Id: I9c42d14eb6ebe14d249df7c8fa39e889f7cd3f22 Reviewed-on: https://go-review.googlesource.com/c/go/+/374754 Reviewed-by: Matthew Dempsky Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/typecheck/crawler.go | 38 ++++++++++++++----- test/typeparam/gencrawler.dir/a.go | 27 +++++++++++++ test/typeparam/gencrawler.dir/main.go | 12 ++++++ test/typeparam/gencrawler.go | 10 +++++ test/typeparam/gencrawler.out | 2 + 5 files changed, 80 insertions(+), 9 deletions(-) create mode 100644 test/typeparam/gencrawler.dir/a.go create mode 100644 test/typeparam/gencrawler.dir/main.go create mode 100644 test/typeparam/gencrawler.go create mode 100644 test/typeparam/gencrawler.out diff --git a/src/cmd/compile/internal/typecheck/crawler.go b/src/cmd/compile/internal/typecheck/crawler.go index 5a9649e7a1..cdb1c46509 100644 --- a/src/cmd/compile/internal/typecheck/crawler.go +++ b/src/cmd/compile/internal/typecheck/crawler.go @@ -11,11 +11,22 @@ import ( ) // crawlExports crawls the type/object graph rooted at the given list of exported -// objects. It descends through all parts of types and follows any methods on defined -// types. Any functions that are found to be potentially callable by importers are -// marked with ExportInline, so that iexport.go knows to re-export their inline body. -// Also, any function or global referenced by a function marked by ExportInline() is -// marked for export (whether its name is exported or not). +// objects (which are variables, functions, and types). It descends through all parts +// of types and follows methods on defined types. Any functions that are found to be +// potentially callable by importers directly or after inlining are marked with +// ExportInline, so that iexport.go knows to export their inline body. +// +// The overall purpose of crawlExports is to AVOID exporting inlineable methods +// that cannot actually be referenced, thereby reducing the size of the exports +// significantly. +// +// For non-generic defined types reachable from global variables, we only set +// ExportInline for exported methods. For defined types that are directly named or are +// embedded recursively in such a type, we set ExportInline for all methods, since +// these types can be embedded in another local type. For instantiated types that are +// used anywhere in a inlineable function, we set ExportInline on all methods of the +// base generic type, since all methods will be needed for creating any instantiated +// type. func crawlExports(exports []*ir.Name) { p := crawler{ marked: make(map[*types.Type]bool), @@ -170,10 +181,12 @@ func (p *crawler) markEmbed(t *types.Type) { } } -// markGeneric takes an instantiated type or a base generic type t, and -// marks all the methods of the base generic type of t. If a base generic -// type is written to export file, even if not explicitly marked for export, -// all of its methods need to be available for instantiation if needed. +// markGeneric takes an instantiated type or a base generic type t, and marks all the +// methods of the base generic type of t. If a base generic type is written out for +// export, even if not explicitly marked for export, then all of its methods need to +// be available for instantiation, since we always create all methods of a specified +// instantiated type. Non-exported methods must generally be instantiated, since they may +// be called by the exported methods or other generic function in the same package. func (p *crawler) markGeneric(t *types.Type) { if t.IsPtr() { t = t.Elem() @@ -222,6 +235,9 @@ func (p *crawler) markInlBody(n *ir.Name) { doFlood = func(n ir.Node) { t := n.Type() if t != nil { + if t.IsPtr() { + t = t.Elem() + } if t.IsFullyInstantiated() && !t.HasShape() && !t.IsInterface() && t.Methods().Len() > 0 { // For any fully-instantiated type, the relevant // dictionaries and shape instantiations will have @@ -287,6 +303,10 @@ func (p *crawler) markInlBody(n *ir.Name) { switch n.Class { case ir.PFUNC: p.markInlBody(n) + // Note: this Export() and the one below seem unneeded, + // since any function/extern name encountered in an + // exported function body will be exported + // automatically via qualifiedIdent() in iexport.go. Export(n) case ir.PEXTERN: Export(n) diff --git a/test/typeparam/gencrawler.dir/a.go b/test/typeparam/gencrawler.dir/a.go new file mode 100644 index 0000000000..50d6b4adeb --- /dev/null +++ b/test/typeparam/gencrawler.dir/a.go @@ -0,0 +1,27 @@ +// 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 + +var V val[int] + +type val[T any] struct { + valx T +} + +func (v *val[T]) Print() { + v.print1() +} + +func (v *val[T]) print1() { + println(v.valx) +} + +func (v *val[T]) fnprint1() { + println(v.valx) +} + +func FnPrint[T any](v *val[T]) { + v.fnprint1() +} diff --git a/test/typeparam/gencrawler.dir/main.go b/test/typeparam/gencrawler.dir/main.go new file mode 100644 index 0000000000..063de7f350 --- /dev/null +++ b/test/typeparam/gencrawler.dir/main.go @@ -0,0 +1,12 @@ +// 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" + +func main() { + a.V.Print() + a.FnPrint(&a.V) +} diff --git a/test/typeparam/gencrawler.go b/test/typeparam/gencrawler.go new file mode 100644 index 0000000000..7c268aed51 --- /dev/null +++ b/test/typeparam/gencrawler.go @@ -0,0 +1,10 @@ +// rundir -G=3 + +// 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. + +// Testing that all methods of a private generic type are exported, if a variable +// with that type is exported. + +package ignored diff --git a/test/typeparam/gencrawler.out b/test/typeparam/gencrawler.out new file mode 100644 index 0000000000..aa47d0d46d --- /dev/null +++ b/test/typeparam/gencrawler.out @@ -0,0 +1,2 @@ +0 +0 From 55d10acb72c2dc5524aae69ade560f3cf308a864 Mon Sep 17 00:00:00 2001 From: Matthew Dempsky Date: Mon, 10 Jan 2022 19:18:39 +0000 Subject: [PATCH 600/752] Revert "cmd/compile: unique LinkString for renamed, embedded fields" This reverts CL 372914. Reason for revert: missing synchronization Change-Id: I7ebb6de082cebb73741d803ff00e3465bbafab81 Reviewed-on: https://go-review.googlesource.com/c/go/+/377379 Trust: Dan Scales Reviewed-by: Bryan Mills Reviewed-by: Dan Scales Trust: Matthew Dempsky --- src/cmd/compile/internal/types/fmt.go | 37 ++------------------------- test/fixedbugs/issue50190.go | 21 --------------- 2 files changed, 2 insertions(+), 56 deletions(-) delete mode 100644 test/fixedbugs/issue50190.go diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go index 1399483424..3198a1f53c 100644 --- a/src/cmd/compile/internal/types/fmt.go +++ b/src/cmd/compile/internal/types/fmt.go @@ -631,7 +631,6 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty } var name string - nameSep := " " if verb != 'S' { s := f.Sym @@ -640,41 +639,9 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty s = OrigSym(s) } - if s != nil { + if s != nil && f.Embedded == 0 { if funarg != FunargNone { name = fmt.Sprint(f.Nname) - } else if f.Embedded != 0 { - // Using type aliases and embedded fields, it's possible to - // construct types that can't be directly represented as a - // type literal. For example, given "type Int = int" (#50190), - // it would be incorrect to format "struct{ Int }" as either - // "struct{ int }" or "struct{ Int int }", because those each - // represent other, distinct types. - // - // So for the purpose of LinkString (i.e., fmtTypeID), we use - // the non-standard syntax "struct{ Int = int }" to represent - // embedded fields that have been renamed through the use of - // type aliases. - if mode == fmtTypeID { - // Compute styp, the symbol that would normally be used as - // the field name when embedding f.Type. - // TODO(mdempsky): Check for other occurences of this logic - // and deduplicate. - typ := f.Type - if typ.Sym() == nil && typ.IsPtr() { - typ = typ.Elem() - } - styp := typ.Sym() - if styp != nil && IsExported(styp.Name) { - styp = LocalPkg.Lookup(styp.Name) - } - - // If embedded field was renamed, use syntax extension. - if s != styp { - name = sconv(s, 0, mode) - nameSep = " = " - } - } } else if verb == 'L' { name = s.Name if name == ".F" { @@ -691,7 +658,7 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty if name != "" { b.WriteString(name) - b.WriteString(nameSep) + b.WriteString(" ") } if f.IsDDD() { diff --git a/test/fixedbugs/issue50190.go b/test/fixedbugs/issue50190.go deleted file mode 100644 index 01ff6eacaa..0000000000 --- a/test/fixedbugs/issue50190.go +++ /dev/null @@ -1,21 +0,0 @@ -// 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 - -type int float32 - -type Int = int - -type A = struct{ int } -type B = struct{ Int } - -func main() { - var x, y interface{} = A{}, B{} - if x == y { - panic("FAIL") - } -} From 8b9b365493220a7bfd87fd3c27301e43baa35a0d Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Sun, 9 Jan 2022 20:20:43 -0800 Subject: [PATCH 601/752] cmd/compile: use exact constant in go_asm.h Fixes #50523 Change-Id: Idab1b44d106250e9301d90ee6571f0ea51242dd9 Reviewed-on: https://go-review.googlesource.com/c/go/+/377074 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor Reviewed-by: Liz Fong-Jones Reviewed-by: Emmanuel Odeke Trust: Emmanuel Odeke TryBot-Result: Gopher Robot Reviewed-by: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/gc/export.go | 2 +- test/asmhdr.dir/main.go | 12 +++++++++--- test/asmhdr.dir/main.s | 3 +++ 3 files changed, 13 insertions(+), 4 deletions(-) diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go index eed438705a..c9acfc1710 100644 --- a/src/cmd/compile/internal/gc/export.go +++ b/src/cmd/compile/internal/gc/export.go @@ -31,7 +31,7 @@ func dumpasmhdr() { if t == constant.Float || t == constant.Complex { break } - fmt.Fprintf(b, "#define const_%s %v\n", n.Sym().Name, n.Val()) + fmt.Fprintf(b, "#define const_%s %v\n", n.Sym().Name, n.Val().ExactString()) case ir.OTYPE: t := n.Type() diff --git a/test/asmhdr.dir/main.go b/test/asmhdr.dir/main.go index 808b5de7bb..4e1813d2ed 100644 --- a/test/asmhdr.dir/main.go +++ b/test/asmhdr.dir/main.go @@ -16,12 +16,15 @@ const ( bigInt = 0xffffffffffffffff stringVal = "test" + + longStringVal = "this_is_a_string_constant_longer_than_seventy_characters_which_used_to_fail_see_issue_50253" ) var ( - smallIntAsm int64 - bigIntAsm uint64 - stringAsm [len(stringVal)]byte + smallIntAsm int64 + bigIntAsm uint64 + stringAsm [len(stringVal)]byte + longStringAsm [len(longStringVal)]byte ) type typ struct { @@ -46,6 +49,9 @@ func main() { if stringVal != string(stringAsm[:]) { println("stringVal", stringVal, "!=", string(stringAsm[:])) } + if longStringVal != string(longStringAsm[:]) { + println("longStringVal", longStringVal, "!=", string(longStringAsm[:])) + } // We also include boolean consts in go_asm.h, but they're // defined to be "true" or "false", and it's not clear how to diff --git a/test/asmhdr.dir/main.s b/test/asmhdr.dir/main.s index 7e2d8e7abd..bc2aa99b0b 100644 --- a/test/asmhdr.dir/main.s +++ b/test/asmhdr.dir/main.s @@ -14,6 +14,9 @@ GLOBL ·bigIntAsm(SB),RODATA,$8 DATA ·stringAsm(SB)/4, $const_stringVal GLOBL ·stringAsm(SB),RODATA,$4 +DATA ·longStringAsm(SB)/91, $const_longStringVal +GLOBL ·longStringAsm(SB),RODATA,$91 + DATA ·typSize(SB)/8, $typ__size GLOBL ·typSize(SB),RODATA,$8 From 1f411e9b6d8849014653c89a9df77b8aadd082e6 Mon Sep 17 00:00:00 2001 From: Roland Shoemaker Date: Fri, 7 Jan 2022 12:18:30 -0800 Subject: [PATCH 602/752] testing: only snapshot coverage during fuzzing Only snapshot/reset coverage counters when we are actually fuzzing. This prevents a race when running corpus/seed values during the testing phase. Fixes #50488 Change-Id: I7dd5a0353a296c0b13eede29ad9af7c78814fa2d Reviewed-on: https://go-review.googlesource.com/c/go/+/376554 Trust: Katie Hockman Reviewed-by: Katie Hockman Trust: Roland Shoemaker Run-TryBot: Roland Shoemaker TryBot-Result: Gopher Robot --- .../testdata/script/test_fuzz_test_race.txt | 38 +++++++++++++++++++ src/testing/fuzz.go | 6 ++- 2 files changed, 42 insertions(+), 2 deletions(-) create mode 100644 src/cmd/go/testdata/script/test_fuzz_test_race.txt diff --git a/src/cmd/go/testdata/script/test_fuzz_test_race.txt b/src/cmd/go/testdata/script/test_fuzz_test_race.txt new file mode 100644 index 0000000000..0bbc1fdd7d --- /dev/null +++ b/src/cmd/go/testdata/script/test_fuzz_test_race.txt @@ -0,0 +1,38 @@ +# Test that when both race detection and coverage instrumentation are enabled, +# and seed values are being executed, the race detector isn't mistakenly +# triggered. + +[short] skip +[!fuzz] skip + +# Test with coverage instrumentation enbaled (-fuzz) and race instrumentation +# but without actually fuzzing the target (by using a non-matching pattern) +go test -fuzz=xxx -race -v +! stderr 'race detected during execution of test' + +# Test with just race instrumentation enabled +go test -race -v +! stderr 'race detected during execution of test' + +# Test with coverage and race instrumentation enabled, and a matching fuzz +# pattern +go test -fuzz=FuzzRace -race -v -fuzztime=200x +! stderr 'race detected during execution of test' + +-- go.mod -- +module test + +-- race_test.go -- +package race + +import "testing" + +func FuzzRace(f *testing.F) { + for i := 0; i < 100; i++ { + f.Add(i) + } + + f.Fuzz(func(t *testing.T, i int) { + t.Parallel() + }) +} \ No newline at end of file diff --git a/src/testing/fuzz.go b/src/testing/fuzz.go index 037d531acf..e1d7544f7a 100644 --- a/src/testing/fuzz.go +++ b/src/testing/fuzz.go @@ -327,8 +327,10 @@ func (f *F) Fuzz(ff any) { // we make sure it is called right before the tRunner function // exits, regardless of whether it was executed cleanly, panicked, // or if the fuzzFn called t.Fatal. - defer f.fuzzContext.deps.SnapshotCoverage() - f.fuzzContext.deps.ResetCoverage() + if f.testContext.isFuzzing { + defer f.fuzzContext.deps.SnapshotCoverage() + f.fuzzContext.deps.ResetCoverage() + } fn.Call(args) }) <-t.signal From 6019a52d4dab7c243ee9088c3522c821c0c95cfa Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Sat, 8 Jan 2022 13:01:37 -0800 Subject: [PATCH 603/752] go/types, types2: better error message when using *interface instead of interface - detect *interface case and report specific error - replaced switch with sequence of if's for more clarity - fixed isInterfacePtr: it applies to all interfaces, incl. type parameters - reviewed/fixed all uses of isInterfacePtr - adjusted error messages to be consistently of the format "type %s is pointer to interface, not interface" Fixes #48312. Change-Id: Ic3c8cfcf93ad57ecdb60f6a727cce9e1aa4afb5d Reviewed-on: https://go-review.googlesource.com/c/go/+/376914 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/call.go | 74 +++++++++++-------- src/cmd/compile/internal/types2/lookup.go | 10 +-- src/cmd/compile/internal/types2/operand.go | 2 +- .../types2/testdata/check/methodsets.src | 12 +-- .../types2/testdata/fixedbugs/issue47747.go2 | 4 +- .../types2/testdata/fixedbugs/issue48312.go2 | 20 +++++ src/go/types/call.go | 74 +++++++++++-------- src/go/types/lookup.go | 10 +-- src/go/types/operand.go | 2 +- src/go/types/testdata/check/methodsets.src | 12 +-- .../types/testdata/fixedbugs/issue47747.go2 | 4 +- .../types/testdata/fixedbugs/issue48312.go2 | 20 +++++ test/fixedbugs/issue48471.go | 2 +- test/method2.go | 2 +- 14 files changed, 155 insertions(+), 93 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue48312.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue48312.go2 diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go index d93805e9c7..bd62e825af 100644 --- a/src/cmd/compile/internal/types2/call.go +++ b/src/cmd/compile/internal/types2/call.go @@ -531,41 +531,51 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) { obj, index, indirect = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, sel) if obj == nil { - switch { - case index != nil: + if index != nil { // TODO(gri) should provide actual type where the conflict happens check.errorf(e.Sel, "ambiguous selector %s.%s", x.expr, sel) - case indirect: - check.errorf(e.Sel, "cannot call pointer method %s on %s", sel, x.typ) - default: - var why string - if tpar, _ := x.typ.(*TypeParam); tpar != nil { - // Type parameter bounds don't specify fields, so don't mention "field". - if tname := tpar.iface().obj; tname != nil { - why = check.sprintf("interface %s has no method %s", tname.name, sel) - } else { - why = check.sprintf("type bound for %s has no method %s", x.typ, sel) - } - } else { - why = check.sprintf("type %s has no field or method %s", x.typ, sel) - } - - // Check if capitalization of sel matters and provide better error message in that case. - if len(sel) > 0 { - var changeCase string - if r := rune(sel[0]); unicode.IsUpper(r) { - changeCase = string(unicode.ToLower(r)) + sel[1:] - } else { - changeCase = string(unicode.ToUpper(r)) + sel[1:] - } - if obj, _, _ = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, changeCase); obj != nil { - why += ", but does have " + changeCase - } - } - - check.errorf(e.Sel, "%s.%s undefined (%s)", x.expr, sel, why) - + goto Error } + + if indirect { + check.errorf(e.Sel, "cannot call pointer method %s on %s", sel, x.typ) + goto Error + } + + if isInterfacePtr(x.typ) { + check.errorf(e.Sel, "%s.%s undefined (type %s is pointer to interface, not interface)", x.expr, sel, x.typ) + goto Error + } + + var why string + if tpar, _ := x.typ.(*TypeParam); tpar != nil { + // Type parameter bounds don't specify fields, so don't mention "field". + // TODO(gri) Type constraints may have accessible fields now. Revisit this. + if tname := tpar.iface().obj; tname != nil { + why = check.sprintf("interface %s has no method %s", tname.name, sel) + } else { + why = check.sprintf("type bound for %s has no method %s", x.typ, sel) + } + } else { + why = check.sprintf("type %s has no field or method %s", x.typ, sel) + } + + // Check if capitalization of sel matters and provide better error message in that case. + // TODO(gri) This code only looks at the first character but LookupFieldOrMethod has an + // (internal) mechanism for case-insensitive lookup. Should use that instead. + if len(sel) > 0 { + var changeCase string + if r := rune(sel[0]); unicode.IsUpper(r) { + changeCase = string(unicode.ToLower(r)) + sel[1:] + } else { + changeCase = string(unicode.ToUpper(r)) + sel[1:] + } + if obj, _, _ = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, changeCase); obj != nil { + why += ", but does have " + changeCase + } + } + + check.errorf(e.Sel, "%s.%s undefined (%s)", x.expr, sel, why) goto Error } diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index 0cce3fdc3f..aa1ab8ac98 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -448,12 +448,12 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string // an extra formatting option for types2.Type that doesn't print out // 'func'. r = strings.Replace(r, "^^func", "", -1) - } else if IsInterface(T) && !isTypeParam(T) { + } else if IsInterface(T) { if isInterfacePtr(V) { - r = fmt.Sprintf("(%s is pointer to interface, not interface)", V) + r = fmt.Sprintf("(type %s is pointer to interface, not interface)", V) } - } else if isInterfacePtr(T) && !isTypeParam(T) { - r = fmt.Sprintf("(%s is pointer to interface, not interface)", T) + } else if isInterfacePtr(T) { + r = fmt.Sprintf("(type %s is pointer to interface, not interface)", T) } if r == "" { r = fmt.Sprintf("(missing %s)", mname) @@ -463,7 +463,7 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string func isInterfacePtr(T Type) bool { p, _ := under(T).(*Pointer) - return p != nil && IsInterface(p.base) && !isTypeParam(p.base) + return p != nil && IsInterface(p.base) } // assertableTo reports whether a value of type V can be asserted to have type T. diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go index f6bd0291ec..69e3a0a832 100644 --- a/src/cmd/compile/internal/types2/operand.go +++ b/src/cmd/compile/internal/types2/operand.go @@ -317,7 +317,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er if check != nil && check.conf.CompilerErrorMessages { if isInterfacePtr(Tu) { if reason != nil { - *reason = check.sprintf("%s does not implement %s (%s is pointer to interface, not interface)", x.typ, T, T) + *reason = check.sprintf("%s does not implement %s (type %s is pointer to interface, not interface)", x.typ, T, T) } return false, _InvalidIfaceAssign } diff --git a/src/cmd/compile/internal/types2/testdata/check/methodsets.src b/src/cmd/compile/internal/types2/testdata/check/methodsets.src index 9fb10deb9a..b0eb14cf50 100644 --- a/src/cmd/compile/internal/types2/testdata/check/methodsets.src +++ b/src/cmd/compile/internal/types2/testdata/check/methodsets.src @@ -196,9 +196,9 @@ func issue5918() { _ func(error) string = error.Error perr = &err - _ = perr.Error /* ERROR "no field or method" */ () - _ func() string = perr.Error /* ERROR "no field or method" */ - _ func(*error) string = (*error).Error /* ERROR "no field or method" */ + _ = perr.Error /* ERROR "type \*error is pointer to interface, not interface" */ () + _ func() string = perr.Error /* ERROR "type \*error is pointer to interface, not interface" */ + _ func(*error) string = (*error).Error /* ERROR "type \*error is pointer to interface, not interface" */ ) type T *interface{ m() int } @@ -207,8 +207,8 @@ func issue5918() { _ = (*x).m() _ = (*x).m - _ = x.m /* ERROR "no field or method" */ () - _ = x.m /* ERROR "no field or method" */ - _ = T.m /* ERROR "no field or method" */ + _ = x.m /* ERROR "type T is pointer to interface, not interface" */ () + _ = x.m /* ERROR "type T is pointer to interface, not interface" */ + _ = T.m /* ERROR "type T is pointer to interface, not interface" */ ) } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47747.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47747.go2 index 6a2e787bf9..edde497f5a 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47747.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47747.go2 @@ -20,7 +20,7 @@ func _[P interface{ m() }](x P) { x.m() // (&x).m doesn't exist because &x is of type *P // and pointers to type parameters don't have methods - (&x).m /* ERROR \*P has no field or method m */ () + (&x).m /* ERROR type \*P is pointer to interface, not interface */ () } @@ -29,7 +29,7 @@ type T2 interface{ m() } func _(x *T2) { // x.m doesn't exists because x is of type *T2 // and pointers to interfaces don't have methods - x.m /* ERROR \*T2 has no field or method m */() + x.m /* ERROR type \*T2 is pointer to interface, not interface */() } // Test case 1 from issue diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48312.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48312.go2 new file mode 100644 index 0000000000..6e5911d0aa --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48312.go2 @@ -0,0 +1,20 @@ +// Copyright 2022 The Go 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 interface{ m() } +type P *T + +func _(p *T) { + p.m /* ERROR type \*T is pointer to interface, not interface */ () +} + +func _(p P) { + p.m /* ERROR type P is pointer to interface, not interface */ () +} + +func _[P T](p *P) { + p.m /* ERROR type \*P is pointer to interface, not interface */ () +} diff --git a/src/go/types/call.go b/src/go/types/call.go index ec6efd2379..a904b3df91 100644 --- a/src/go/types/call.go +++ b/src/go/types/call.go @@ -533,40 +533,52 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) { obj, index, indirect = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, sel) if obj == nil { - switch { - case index != nil: + if index != nil { // TODO(gri) should provide actual type where the conflict happens check.errorf(e.Sel, _AmbiguousSelector, "ambiguous selector %s.%s", x.expr, sel) - case indirect: - check.errorf(e.Sel, _InvalidMethodExpr, "cannot call pointer method %s on %s", sel, x.typ) - default: - var why string - if tpar, _ := x.typ.(*TypeParam); tpar != nil { - // Type parameter bounds don't specify fields, so don't mention "field". - if tname := tpar.iface().obj; tname != nil { - why = check.sprintf("interface %s has no method %s", tname.name, sel) - } else { - why = check.sprintf("type bound for %s has no method %s", x.typ, sel) - } - } else { - why = check.sprintf("type %s has no field or method %s", x.typ, sel) - } - - // Check if capitalization of sel matters and provide better error message in that case. - if len(sel) > 0 { - var changeCase string - if r := rune(sel[0]); unicode.IsUpper(r) { - changeCase = string(unicode.ToLower(r)) + sel[1:] - } else { - changeCase = string(unicode.ToUpper(r)) + sel[1:] - } - if obj, _, _ = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, changeCase); obj != nil { - why += ", but does have " + changeCase - } - } - - check.errorf(e.Sel, _MissingFieldOrMethod, "%s.%s undefined (%s)", x.expr, sel, why) + goto Error } + + if indirect { + check.errorf(e.Sel, _InvalidMethodExpr, "cannot call pointer method %s on %s", sel, x.typ) + goto Error + } + + if isInterfacePtr(x.typ) { + check.errorf(e.Sel, _InvalidMethodExpr, "%s.%s undefined (type %s is pointer to interface, not interface)", x.expr, sel, x.typ) + goto Error + } + + var why string + if tpar, _ := x.typ.(*TypeParam); tpar != nil { + // Type parameter bounds don't specify fields, so don't mention "field". + // TODO(gri) Type constraints may have accessible fields now. Revisit this. + if tname := tpar.iface().obj; tname != nil { + why = check.sprintf("interface %s has no method %s", tname.name, sel) + } else { + why = check.sprintf("type bound for %s has no method %s", x.typ, sel) + } + } else { + why = check.sprintf("type %s has no field or method %s", x.typ, sel) + } + + // Check if capitalization of sel matters and provide better error message in that case. + // TODO(gri) This code only looks at the first character but LookupFieldOrMethod should + // have an (internal) mechanism for case-insensitive lookup that we should use + // instead (see types2). + if len(sel) > 0 { + var changeCase string + if r := rune(sel[0]); unicode.IsUpper(r) { + changeCase = string(unicode.ToLower(r)) + sel[1:] + } else { + changeCase = string(unicode.ToUpper(r)) + sel[1:] + } + if obj, _, _ = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, changeCase); obj != nil { + why += ", but does have " + changeCase + } + } + + check.errorf(e.Sel, _MissingFieldOrMethod, "%s.%s undefined (%s)", x.expr, sel, why) goto Error } diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go index e593351804..1b820d5403 100644 --- a/src/go/types/lookup.go +++ b/src/go/types/lookup.go @@ -422,12 +422,12 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string // an extra formatting option for types2.Type that doesn't print out // 'func'. r = strings.Replace(r, "^^func", "", -1) - } else if IsInterface(T) && !isTypeParam(T) { + } else if IsInterface(T) { if isInterfacePtr(V) { - r = fmt.Sprintf("(%s is pointer to interface, not interface)", V) + r = fmt.Sprintf("(type %s is pointer to interface, not interface)", V) } - } else if isInterfacePtr(T) && !isTypeParam(T) { - r = fmt.Sprintf("(%s is pointer to interface, not interface)", T) + } else if isInterfacePtr(T) { + r = fmt.Sprintf("(type %s is pointer to interface, not interface)", T) } if r == "" { r = fmt.Sprintf("(missing %s)", mname) @@ -437,7 +437,7 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string func isInterfacePtr(T Type) bool { p, _ := under(T).(*Pointer) - return p != nil && IsInterface(p.base) && !isTypeParam(T) + return p != nil && IsInterface(p.base) } // assertableTo reports whether a value of type V can be asserted to have type T. diff --git a/src/go/types/operand.go b/src/go/types/operand.go index 06ecbf1410..d669981cf2 100644 --- a/src/go/types/operand.go +++ b/src/go/types/operand.go @@ -308,7 +308,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er if check != nil && compilerErrorMessages { if isInterfacePtr(Tu) { if reason != nil { - *reason = check.sprintf("%s does not implement %s (%s is pointer to interface, not interface)", x.typ, T, T) + *reason = check.sprintf("%s does not implement %s (type %s is pointer to interface, not interface)", x.typ, T, T) } return false, _InvalidIfaceAssign } diff --git a/src/go/types/testdata/check/methodsets.src b/src/go/types/testdata/check/methodsets.src index 9fb10deb9a..b0eb14cf50 100644 --- a/src/go/types/testdata/check/methodsets.src +++ b/src/go/types/testdata/check/methodsets.src @@ -196,9 +196,9 @@ func issue5918() { _ func(error) string = error.Error perr = &err - _ = perr.Error /* ERROR "no field or method" */ () - _ func() string = perr.Error /* ERROR "no field or method" */ - _ func(*error) string = (*error).Error /* ERROR "no field or method" */ + _ = perr.Error /* ERROR "type \*error is pointer to interface, not interface" */ () + _ func() string = perr.Error /* ERROR "type \*error is pointer to interface, not interface" */ + _ func(*error) string = (*error).Error /* ERROR "type \*error is pointer to interface, not interface" */ ) type T *interface{ m() int } @@ -207,8 +207,8 @@ func issue5918() { _ = (*x).m() _ = (*x).m - _ = x.m /* ERROR "no field or method" */ () - _ = x.m /* ERROR "no field or method" */ - _ = T.m /* ERROR "no field or method" */ + _ = x.m /* ERROR "type T is pointer to interface, not interface" */ () + _ = x.m /* ERROR "type T is pointer to interface, not interface" */ + _ = T.m /* ERROR "type T is pointer to interface, not interface" */ ) } diff --git a/src/go/types/testdata/fixedbugs/issue47747.go2 b/src/go/types/testdata/fixedbugs/issue47747.go2 index 6a2e787bf9..edde497f5a 100644 --- a/src/go/types/testdata/fixedbugs/issue47747.go2 +++ b/src/go/types/testdata/fixedbugs/issue47747.go2 @@ -20,7 +20,7 @@ func _[P interface{ m() }](x P) { x.m() // (&x).m doesn't exist because &x is of type *P // and pointers to type parameters don't have methods - (&x).m /* ERROR \*P has no field or method m */ () + (&x).m /* ERROR type \*P is pointer to interface, not interface */ () } @@ -29,7 +29,7 @@ type T2 interface{ m() } func _(x *T2) { // x.m doesn't exists because x is of type *T2 // and pointers to interfaces don't have methods - x.m /* ERROR \*T2 has no field or method m */() + x.m /* ERROR type \*T2 is pointer to interface, not interface */() } // Test case 1 from issue diff --git a/src/go/types/testdata/fixedbugs/issue48312.go2 b/src/go/types/testdata/fixedbugs/issue48312.go2 new file mode 100644 index 0000000000..6e5911d0aa --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue48312.go2 @@ -0,0 +1,20 @@ +// Copyright 2022 The Go 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 interface{ m() } +type P *T + +func _(p *T) { + p.m /* ERROR type \*T is pointer to interface, not interface */ () +} + +func _(p P) { + p.m /* ERROR type P is pointer to interface, not interface */ () +} + +func _[P T](p *P) { + p.m /* ERROR type \*P is pointer to interface, not interface */ () +} diff --git a/test/fixedbugs/issue48471.go b/test/fixedbugs/issue48471.go index 88caeede15..ba6245ab41 100644 --- a/test/fixedbugs/issue48471.go +++ b/test/fixedbugs/issue48471.go @@ -32,7 +32,7 @@ func g() { i = new(T2) // ERROR "cannot use new\(T2\) \(.*type \*T2\) as type I in assignment:\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\)\n\t\twant M\(int\)" i = new(T3) // ERROR "cannot use new\(T3\) \(.*type \*T3\) as type I in assignment:\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\)\n\t\twant M\(int\)" i = T4{} // ERROR "cannot use T4\{\} \(.*type T4\) as type I in assignment:\n\tT4 does not implement I \(M method has pointer receiver\)" - i = new(I) // ERROR "cannot use new\(I\) \(.*type \*I\) as type I in assignment:\n\t\*I does not implement I \(\*I is pointer to interface, not interface\)" + i = new(I) // ERROR "cannot use new\(I\) \(.*type \*I\) as type I in assignment:\n\t\*I does not implement I \(type \*I is pointer to interface, not interface\)" _ = i.(*T2) // ERROR "impossible type assertion: i.\(\*T2\)\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\)\n\t\twant M\(int\)" _ = i.(*T3) // ERROR "impossible type assertion: i.\(\*T3\)\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\)\n\t\twant M\(int\)" var t *T4 diff --git a/test/method2.go b/test/method2.go index 2a92136d6c..0a497b4b84 100644 --- a/test/method2.go +++ b/test/method2.go @@ -28,7 +28,7 @@ type Val interface { val() int } -var _ = (*Val).val // ERROR "method" +var _ = (*Val).val // ERROR "method|type \*Val is pointer to interface, not interface" var v Val var pv = &v From 91edf2b7f2fe219f1af1df4031a210d8160da47c Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Sat, 8 Jan 2022 14:39:43 -0800 Subject: [PATCH 604/752] go/types, types2: better error message for type parameter field access Fixes #50516. Also call DefPredeclaredTestFuncs in TestFixedbugs so it can be run independently again. Change-Id: I78d4cc11790b1543a2545a7ab297a223b3d5e3c8 Reviewed-on: https://go-review.googlesource.com/c/go/+/376954 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/call.go | 43 +++++++----------- src/cmd/compile/internal/types2/check_test.go | 11 +++-- .../types2/testdata/check/typeparams.go2 | 6 +-- .../types2/testdata/fixedbugs/issue50417.go2 | 2 +- .../types2/testdata/fixedbugs/issue50516.go2 | 13 ++++++ src/go/types/call.go | 45 +++++++------------ src/go/types/check_test.go | 11 +++-- src/go/types/testdata/check/typeparams.go2 | 6 +-- .../types/testdata/fixedbugs/issue50417.go2 | 2 +- .../types/testdata/fixedbugs/issue50516.go2 | 13 ++++++ 10 files changed, 79 insertions(+), 73 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50516.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50516.go2 diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go index bd62e825af..1c3bf48b08 100644 --- a/src/cmd/compile/internal/types2/call.go +++ b/src/cmd/compile/internal/types2/call.go @@ -542,39 +542,26 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) { goto Error } - if isInterfacePtr(x.typ) { - check.errorf(e.Sel, "%s.%s undefined (type %s is pointer to interface, not interface)", x.expr, sel, x.typ) - goto Error - } - var why string - if tpar, _ := x.typ.(*TypeParam); tpar != nil { - // Type parameter bounds don't specify fields, so don't mention "field". - // TODO(gri) Type constraints may have accessible fields now. Revisit this. - if tname := tpar.iface().obj; tname != nil { - why = check.sprintf("interface %s has no method %s", tname.name, sel) - } else { - why = check.sprintf("type bound for %s has no method %s", x.typ, sel) - } + if isInterfacePtr(x.typ) { + why = check.sprintf("type %s is pointer to interface, not interface", x.typ) } else { why = check.sprintf("type %s has no field or method %s", x.typ, sel) - } - - // Check if capitalization of sel matters and provide better error message in that case. - // TODO(gri) This code only looks at the first character but LookupFieldOrMethod has an - // (internal) mechanism for case-insensitive lookup. Should use that instead. - if len(sel) > 0 { - var changeCase string - if r := rune(sel[0]); unicode.IsUpper(r) { - changeCase = string(unicode.ToLower(r)) + sel[1:] - } else { - changeCase = string(unicode.ToUpper(r)) + sel[1:] - } - if obj, _, _ = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, changeCase); obj != nil { - why += ", but does have " + changeCase + // Check if capitalization of sel matters and provide better error message in that case. + // TODO(gri) This code only looks at the first character but LookupFieldOrMethod has an + // (internal) mechanism for case-insensitive lookup. Should use that instead. + if len(sel) > 0 { + var changeCase string + if r := rune(sel[0]); unicode.IsUpper(r) { + changeCase = string(unicode.ToLower(r)) + sel[1:] + } else { + changeCase = string(unicode.ToUpper(r)) + sel[1:] + } + if obj, _, _ = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, changeCase); obj != nil { + why += ", but does have " + changeCase + } } } - check.errorf(e.Sel, "%s.%s undefined (%s)", x.expr, sel, why) goto Error } diff --git a/src/cmd/compile/internal/types2/check_test.go b/src/cmd/compile/internal/types2/check_test.go index 1868ad0c6e..7efa512164 100644 --- a/src/cmd/compile/internal/types2/check_test.go +++ b/src/cmd/compile/internal/types2/check_test.go @@ -295,10 +295,13 @@ func TestManual(t *testing.T) { // TODO(gri) go/types has extra TestLongConstants and TestIndexRepresentability tests -func TestCheck(t *testing.T) { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/check", 55, false) } // TODO(gri) narrow column tolerance -func TestSpec(t *testing.T) { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/spec", 0, false) } -func TestExamples(t *testing.T) { testDirFiles(t, "testdata/examples", 0, false) } -func TestFixedbugs(t *testing.T) { testDirFiles(t, "testdata/fixedbugs", 0, false) } +func TestCheck(t *testing.T) { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/check", 55, false) } // TODO(gri) narrow column tolerance +func TestSpec(t *testing.T) { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/spec", 0, false) } +func TestExamples(t *testing.T) { testDirFiles(t, "testdata/examples", 0, false) } +func TestFixedbugs(t *testing.T) { + DefPredeclaredTestFuncs() + testDirFiles(t, "testdata/fixedbugs", 0, false) +} func testDirFiles(t *testing.T, dir string, colDelta uint, manual bool) { testenv.MustHaveGoBuild(t) diff --git a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 index 007157ea0f..ef58241519 100644 --- a/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 +++ b/src/cmd/compile/internal/types2/testdata/check/typeparams.go2 @@ -519,13 +519,13 @@ func _[P C[P]] (x P) { type I interface {} func _[P I] (x P) { - x.m /* ERROR interface I has no method m */ () + x.m /* ERROR type P has no field or method m */ () } func _[P interface{}] (x P) { - x.m /* ERROR type bound for P has no method m */ () + x.m /* ERROR type P has no field or method m */ () } func _[P any] (x P) { - x.m /* ERROR type bound for P has no method m */ () + x.m /* ERROR type P has no field or method m */ () } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50417.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50417.go2 index c05987e5ea..b6454ab003 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50417.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50417.go2 @@ -58,7 +58,7 @@ type PSfm *Sfm func f3[P interface{ PSfm }](p P) { _ = p.f p.f = 0 - p.m /* ERROR type bound for P has no method m */ () + p.m /* ERROR type P has no field or method m */ () } var _ = f3[PSfm] diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50516.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50516.go2 new file mode 100644 index 0000000000..f73015e2be --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50516.go2 @@ -0,0 +1,13 @@ +// Copyright 2022 The Go 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 _[P struct{ f int }](x P) { + _ = x.g // ERROR type P has no field or method g +} + +func _[P struct{ f int } | struct{ g int }](x P) { + _ = x.g // ERROR type P has no field or method g +} diff --git a/src/go/types/call.go b/src/go/types/call.go index a904b3df91..4a31ec2586 100644 --- a/src/go/types/call.go +++ b/src/go/types/call.go @@ -544,40 +544,27 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) { goto Error } - if isInterfacePtr(x.typ) { - check.errorf(e.Sel, _InvalidMethodExpr, "%s.%s undefined (type %s is pointer to interface, not interface)", x.expr, sel, x.typ) - goto Error - } - var why string - if tpar, _ := x.typ.(*TypeParam); tpar != nil { - // Type parameter bounds don't specify fields, so don't mention "field". - // TODO(gri) Type constraints may have accessible fields now. Revisit this. - if tname := tpar.iface().obj; tname != nil { - why = check.sprintf("interface %s has no method %s", tname.name, sel) - } else { - why = check.sprintf("type bound for %s has no method %s", x.typ, sel) - } + if isInterfacePtr(x.typ) { + why = check.sprintf("type %s is pointer to interface, not interface", x.typ) } else { why = check.sprintf("type %s has no field or method %s", x.typ, sel) - } - - // Check if capitalization of sel matters and provide better error message in that case. - // TODO(gri) This code only looks at the first character but LookupFieldOrMethod should - // have an (internal) mechanism for case-insensitive lookup that we should use - // instead (see types2). - if len(sel) > 0 { - var changeCase string - if r := rune(sel[0]); unicode.IsUpper(r) { - changeCase = string(unicode.ToLower(r)) + sel[1:] - } else { - changeCase = string(unicode.ToUpper(r)) + sel[1:] - } - if obj, _, _ = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, changeCase); obj != nil { - why += ", but does have " + changeCase + // Check if capitalization of sel matters and provide better error message in that case. + // TODO(gri) This code only looks at the first character but LookupFieldOrMethod should + // have an (internal) mechanism for case-insensitive lookup that we should use + // instead (see types2). + if len(sel) > 0 { + var changeCase string + if r := rune(sel[0]); unicode.IsUpper(r) { + changeCase = string(unicode.ToLower(r)) + sel[1:] + } else { + changeCase = string(unicode.ToUpper(r)) + sel[1:] + } + if obj, _, _ = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, changeCase); obj != nil { + why += ", but does have " + changeCase + } } } - check.errorf(e.Sel, _MissingFieldOrMethod, "%s.%s undefined (%s)", x.expr, sel, why) goto Error } diff --git a/src/go/types/check_test.go b/src/go/types/check_test.go index e296d13be9..81ea81ca4e 100644 --- a/src/go/types/check_test.go +++ b/src/go/types/check_test.go @@ -376,10 +376,13 @@ func TestIssue47243_TypedRHS(t *testing.T) { testFiles(t, &StdSizes{4, 4}, []string{"p.go"}, [][]byte{[]byte(src)}, false, nil) } -func TestCheck(t *testing.T) { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/check", false) } -func TestSpec(t *testing.T) { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/spec", false) } -func TestExamples(t *testing.T) { testDirFiles(t, "testdata/examples", false) } -func TestFixedbugs(t *testing.T) { testDirFiles(t, "testdata/fixedbugs", false) } +func TestCheck(t *testing.T) { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/check", false) } +func TestSpec(t *testing.T) { DefPredeclaredTestFuncs(); testDirFiles(t, "testdata/spec", false) } +func TestExamples(t *testing.T) { testDirFiles(t, "testdata/examples", false) } +func TestFixedbugs(t *testing.T) { + DefPredeclaredTestFuncs() + testDirFiles(t, "testdata/fixedbugs", false) +} func testDirFiles(t *testing.T, dir string, manual bool) { testenv.MustHaveGoBuild(t) diff --git a/src/go/types/testdata/check/typeparams.go2 b/src/go/types/testdata/check/typeparams.go2 index e3aca4ccb0..6d63d598d9 100644 --- a/src/go/types/testdata/check/typeparams.go2 +++ b/src/go/types/testdata/check/typeparams.go2 @@ -518,13 +518,13 @@ func _[P C[P]] (x P) { type I interface {} func _[P I] (x P) { - x.m /* ERROR interface I has no method m */ () + x.m /* ERROR type P has no field or method m */ () } func _[P interface{}] (x P) { - x.m /* ERROR type bound for P has no method m */ () + x.m /* ERROR type P has no field or method m */ () } func _[P any] (x P) { - x.m /* ERROR type bound for P has no method m */ () + x.m /* ERROR type P has no field or method m */ () } diff --git a/src/go/types/testdata/fixedbugs/issue50417.go2 b/src/go/types/testdata/fixedbugs/issue50417.go2 index c05987e5ea..b6454ab003 100644 --- a/src/go/types/testdata/fixedbugs/issue50417.go2 +++ b/src/go/types/testdata/fixedbugs/issue50417.go2 @@ -58,7 +58,7 @@ type PSfm *Sfm func f3[P interface{ PSfm }](p P) { _ = p.f p.f = 0 - p.m /* ERROR type bound for P has no method m */ () + p.m /* ERROR type P has no field or method m */ () } var _ = f3[PSfm] diff --git a/src/go/types/testdata/fixedbugs/issue50516.go2 b/src/go/types/testdata/fixedbugs/issue50516.go2 new file mode 100644 index 0000000000..f73015e2be --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50516.go2 @@ -0,0 +1,13 @@ +// Copyright 2022 The Go 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 _[P struct{ f int }](x P) { + _ = x.g // ERROR type P has no field or method g +} + +func _[P struct{ f int } | struct{ g int }](x P) { + _ = x.g // ERROR type P has no field or method g +} From 4ceb5a94d83b823fe7c3e4d25541854759651933 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 10 Jan 2022 10:33:16 -0800 Subject: [PATCH 605/752] go/types, types2: refer to type parameter if so for interface pointer errors Follow-up on comment in CL 376914. Also: - add missing check != nil test in assignableTo - use check.sprintf rather than fmt.Sprintf in missingMethodReason For #48312. Change-Id: Ie209b4101a7f2c279e42a59987d0068079c8b69f Reviewed-on: https://go-review.googlesource.com/c/go/+/377375 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/call.go | 2 +- src/cmd/compile/internal/types2/lookup.go | 23 ++++++++++++------- src/cmd/compile/internal/types2/operand.go | 2 +- .../types2/testdata/fixedbugs/issue47747.go2 | 2 +- .../types2/testdata/fixedbugs/issue48312.go2 | 2 +- src/go/types/call.go | 2 +- src/go/types/lookup.go | 23 ++++++++++++------- src/go/types/operand.go | 2 +- .../types/testdata/fixedbugs/issue47747.go2 | 2 +- .../types/testdata/fixedbugs/issue48312.go2 | 2 +- 10 files changed, 38 insertions(+), 24 deletions(-) diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go index 1c3bf48b08..ea1c27aa2b 100644 --- a/src/cmd/compile/internal/types2/call.go +++ b/src/cmd/compile/internal/types2/call.go @@ -544,7 +544,7 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) { var why string if isInterfacePtr(x.typ) { - why = check.sprintf("type %s is pointer to interface, not interface", x.typ) + why = check.interfacePtrError(x.typ) } else { why = check.sprintf("type %s has no field or method %s", x.typ, sel) // Check if capitalization of sel matters and provide better error message in that case. diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index aa1ab8ac98..5428b667a5 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -7,7 +7,6 @@ package types2 import ( - "fmt" "strings" ) @@ -429,17 +428,17 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string if wrongType != nil { if Identical(m.typ, wrongType.typ) { if m.Name() == wrongType.Name() { - r = fmt.Sprintf("(%s has pointer receiver)", mname) + r = check.sprintf("(%s has pointer receiver)", mname) } else { - r = fmt.Sprintf("(missing %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", + r = check.sprintf("(missing %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) } } else { if check.conf.CompilerErrorMessages { - r = fmt.Sprintf("(wrong type for %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", + r = check.sprintf("(wrong type for %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) } else { - r = fmt.Sprintf("(wrong type for %s: have %s, want %s)", + r = check.sprintf("(wrong type for %s: have %s, want %s)", mname, wrongType.typ, m.typ) } } @@ -450,13 +449,13 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string r = strings.Replace(r, "^^func", "", -1) } else if IsInterface(T) { if isInterfacePtr(V) { - r = fmt.Sprintf("(type %s is pointer to interface, not interface)", V) + r = "(" + check.interfacePtrError(V) + ")" } } else if isInterfacePtr(T) { - r = fmt.Sprintf("(type %s is pointer to interface, not interface)", T) + r = "(" + check.interfacePtrError(T) + ")" } if r == "" { - r = fmt.Sprintf("(missing %s)", mname) + r = check.sprintf("(missing %s)", mname) } return r } @@ -466,6 +465,14 @@ func isInterfacePtr(T Type) bool { return p != nil && IsInterface(p.base) } +func (check *Checker) interfacePtrError(T Type) string { + assert(isInterfacePtr(T)) + if p, _ := under(T).(*Pointer); isTypeParam(p.base) { + return check.sprintf("type %s is pointer to type parameter, not type parameter", T) + } + return check.sprintf("type %s is pointer to interface, not interface", T) +} + // assertableTo reports whether a value of type V can be asserted to have type T. // It returns (nil, false) as affirmative answer. Otherwise it returns a missing // method required by V and whether it is missing or just has the wrong type. diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go index 69e3a0a832..1eb24d136b 100644 --- a/src/cmd/compile/internal/types2/operand.go +++ b/src/cmd/compile/internal/types2/operand.go @@ -292,7 +292,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er if Ti, ok := Tu.(*Interface); ok && Tp == nil { if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* !Implements(V, Ti) */ { if reason != nil { - if check.conf.CompilerErrorMessages { + if check != nil && check.conf.CompilerErrorMessages { *reason = check.sprintf("%s does not implement %s %s", x.typ, T, check.missingMethodReason(x.typ, T, m, wrongType)) } else { diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47747.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47747.go2 index edde497f5a..6f09fc2f57 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47747.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue47747.go2 @@ -20,7 +20,7 @@ func _[P interface{ m() }](x P) { x.m() // (&x).m doesn't exist because &x is of type *P // and pointers to type parameters don't have methods - (&x).m /* ERROR type \*P is pointer to interface, not interface */ () + (&x).m /* ERROR type \*P is pointer to type parameter, not type parameter */ () } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48312.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48312.go2 index 6e5911d0aa..2fdb7cad94 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48312.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48312.go2 @@ -16,5 +16,5 @@ func _(p P) { } func _[P T](p *P) { - p.m /* ERROR type \*P is pointer to interface, not interface */ () + p.m /* ERROR type \*P is pointer to type parameter, not type parameter */ () } diff --git a/src/go/types/call.go b/src/go/types/call.go index 4a31ec2586..d5b83451c4 100644 --- a/src/go/types/call.go +++ b/src/go/types/call.go @@ -546,7 +546,7 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) { var why string if isInterfacePtr(x.typ) { - why = check.sprintf("type %s is pointer to interface, not interface", x.typ) + why = check.interfacePtrError(x.typ) } else { why = check.sprintf("type %s has no field or method %s", x.typ, sel) // Check if capitalization of sel matters and provide better error message in that case. diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go index 1b820d5403..598f615247 100644 --- a/src/go/types/lookup.go +++ b/src/go/types/lookup.go @@ -7,7 +7,6 @@ package types import ( - "fmt" "strings" ) @@ -403,17 +402,17 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string if wrongType != nil { if Identical(m.typ, wrongType.typ) { if m.Name() == wrongType.Name() { - r = fmt.Sprintf("(%s has pointer receiver)", mname) + r = check.sprintf("(%s has pointer receiver)", mname) } else { - r = fmt.Sprintf("(missing %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", + r = check.sprintf("(missing %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) } } else { if compilerErrorMessages { - r = fmt.Sprintf("(wrong type for %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", + r = check.sprintf("(wrong type for %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) } else { - r = fmt.Sprintf("(wrong type for %s: have %s, want %s)", + r = check.sprintf("(wrong type for %s: have %s, want %s)", mname, wrongType.typ, m.typ) } } @@ -424,13 +423,13 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string r = strings.Replace(r, "^^func", "", -1) } else if IsInterface(T) { if isInterfacePtr(V) { - r = fmt.Sprintf("(type %s is pointer to interface, not interface)", V) + r = "(" + check.interfacePtrError(V) + ")" } } else if isInterfacePtr(T) { - r = fmt.Sprintf("(type %s is pointer to interface, not interface)", T) + r = "(" + check.interfacePtrError(T) + ")" } if r == "" { - r = fmt.Sprintf("(missing %s)", mname) + r = check.sprintf("(missing %s)", mname) } return r } @@ -440,6 +439,14 @@ func isInterfacePtr(T Type) bool { return p != nil && IsInterface(p.base) } +func (check *Checker) interfacePtrError(T Type) string { + assert(isInterfacePtr(T)) + if p, _ := under(T).(*Pointer); isTypeParam(p.base) { + return check.sprintf("type %s is pointer to type parameter, not type parameter", T) + } + return check.sprintf("type %s is pointer to interface, not interface", T) +} + // assertableTo reports whether a value of type V can be asserted to have type T. // It returns (nil, false) as affirmative answer. Otherwise it returns a missing // method required by V and whether it is missing or just has the wrong type. diff --git a/src/go/types/operand.go b/src/go/types/operand.go index d669981cf2..d119b5ee7b 100644 --- a/src/go/types/operand.go +++ b/src/go/types/operand.go @@ -282,7 +282,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er if Ti, ok := Tu.(*Interface); ok && Tp == nil { if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* Implements(V, Ti) */ { if reason != nil { - if compilerErrorMessages { + if check != nil && compilerErrorMessages { *reason = check.sprintf("%s does not implement %s %s", x.typ, T, check.missingMethodReason(x.typ, T, m, wrongType)) } else { diff --git a/src/go/types/testdata/fixedbugs/issue47747.go2 b/src/go/types/testdata/fixedbugs/issue47747.go2 index edde497f5a..6f09fc2f57 100644 --- a/src/go/types/testdata/fixedbugs/issue47747.go2 +++ b/src/go/types/testdata/fixedbugs/issue47747.go2 @@ -20,7 +20,7 @@ func _[P interface{ m() }](x P) { x.m() // (&x).m doesn't exist because &x is of type *P // and pointers to type parameters don't have methods - (&x).m /* ERROR type \*P is pointer to interface, not interface */ () + (&x).m /* ERROR type \*P is pointer to type parameter, not type parameter */ () } diff --git a/src/go/types/testdata/fixedbugs/issue48312.go2 b/src/go/types/testdata/fixedbugs/issue48312.go2 index 6e5911d0aa..2fdb7cad94 100644 --- a/src/go/types/testdata/fixedbugs/issue48312.go2 +++ b/src/go/types/testdata/fixedbugs/issue48312.go2 @@ -16,5 +16,5 @@ func _(p P) { } func _[P T](p *P) { - p.m /* ERROR type \*P is pointer to interface, not interface */ () + p.m /* ERROR type \*P is pointer to type parameter, not type parameter */ () } From 90a8482a176b8cf47e8b24a3459f0a24e038f675 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Fri, 3 Dec 2021 16:10:10 -0800 Subject: [PATCH 606/752] test: re-enable most go/tests that were disabled because of types2 differences I made the default be that, where there are differences between types2 and -G=0 error messages, we want errorcheck tests to pass types2. Typically, we can get errorcheck to pass on types2 and -G=0 if they give the same number of error messages on the same lines, just different wording. If they give a different number of error messages, then I made types2 pass. I added an exception list for -G=0 to cover those cases where -G=0 and types give different numbers of error messages. Because types2 does not run if there are syntax errors, for several tests, I had to split the tests into two parts in order to get all the indicated errors to be reported in types2 (bug228.go, bug388.go, issue11610.go, issue14520.go) I tried to preserve the GCCGO labeling correctly (but may have gotten some wrong). When types2 now matches where a GCCGO error previously occurred, I transformed GCCGO_ERROR -> ERROR. When types2 no longer reports an error in a certain place, I transformed ERROR -> GCCGO_ERROR. When types2 reports an error in a new place, I used GC_ERROR. The remaining entries in types2Failures are things that I think we probably still need to fix - either actually missing errors in types2, or cases where types2 gives worse errors than -G=0. Change-Id: I7f01e82b322b16094096b67d7ed2bb39b410c34f Reviewed-on: https://go-review.googlesource.com/c/go/+/372854 Trust: Dan Scales Reviewed-by: Matthew Dempsky --- test/fixedbugs/bug176.go | 7 +- test/fixedbugs/bug195.go | 8 +-- test/fixedbugs/bug228.go | 6 +- test/fixedbugs/bug228a.go | 13 ++++ test/fixedbugs/bug231.go | 12 ++-- test/fixedbugs/bug255.go | 10 +-- test/fixedbugs/bug388.go | 10 --- test/fixedbugs/bug388a.go | 23 +++++++ test/fixedbugs/bug412.go | 6 +- test/fixedbugs/issue11590.go | 6 +- test/fixedbugs/issue11610.go | 1 - test/fixedbugs/issue11610a.go | 11 +++ test/fixedbugs/issue11614.go | 6 +- test/fixedbugs/issue14520.go | 3 - test/fixedbugs/issue14520a.go | 10 +++ test/fixedbugs/issue17038.go | 2 +- test/fixedbugs/issue19012.go | 4 +- test/fixedbugs/issue21979.go | 39 ++++++----- test/fixedbugs/issue23732.go | 10 +-- test/fixedbugs/issue25958.go | 4 +- test/fixedbugs/issue28079b.go | 4 +- test/fixedbugs/issue28268.go | 4 +- test/fixedbugs/issue33460.go | 12 ++-- test/fixedbugs/issue4232.go | 44 ++++++------ test/fixedbugs/issue4452.go | 2 +- test/fixedbugs/issue4510.dir/f1.go | 2 +- test/fixedbugs/issue4510.dir/f2.go | 2 +- test/fixedbugs/issue7525.go | 4 +- test/fixedbugs/issue7525b.go | 4 +- test/fixedbugs/issue7525c.go | 4 +- test/fixedbugs/issue7525d.go | 4 +- test/fixedbugs/issue7525e.go | 4 +- test/import1.go | 4 +- test/import6.go | 5 +- test/initializerr.go | 22 +++--- test/run.go | 107 +++++++++++++---------------- test/typecheck.go | 2 +- 37 files changed, 227 insertions(+), 194 deletions(-) create mode 100644 test/fixedbugs/bug228a.go create mode 100644 test/fixedbugs/bug388a.go create mode 100644 test/fixedbugs/issue11610a.go create mode 100644 test/fixedbugs/issue14520a.go diff --git a/test/fixedbugs/bug176.go b/test/fixedbugs/bug176.go index 7001dd081e..61e63c7656 100644 --- a/test/fixedbugs/bug176.go +++ b/test/fixedbugs/bug176.go @@ -8,7 +8,6 @@ package main var x int -var a = []int{ x: 1} // ERROR "constant" -var b = [...]int{x: 1} // GCCGO_ERROR "constant" -var c = map[int]int{ x: 1} - +var a = []int{x: 1} // ERROR "constant" +var b = [...]int{x: 1} // ERROR "constant" +var c = map[int]int{x: 1} diff --git a/test/fixedbugs/bug195.go b/test/fixedbugs/bug195.go index 6d8578d6cb..4a3bf0db81 100644 --- a/test/fixedbugs/bug195.go +++ b/test/fixedbugs/bug195.go @@ -11,14 +11,14 @@ type I2 int type I3 interface{ int } // ERROR "interface" -type S struct { - x interface{ S } // ERROR "interface" +type S struct { // GC_ERROR "invalid recursive type" + x interface{ S } // GCCGO_ERROR "interface" } -type I4 interface { // GC_ERROR "invalid recursive type I4\n\tLINE: I4 refers to\n\tLINE: I4$" +type I4 interface { // GC_ERROR "invalid recursive type I4\n\tLINE:.* I4 refers to\n\tLINE:.* I4$" I4 // GCCGO_ERROR "interface" } -type I5 interface { // GC_ERROR "invalid recursive type I5\n\tLINE: I5 refers to\n\tLINE+4: I6 refers to\n\tLINE: I5$" +type I5 interface { // GC_ERROR "invalid recursive type I5\n\tLINE:.* I5 refers to\n\tLINE+4:.* I6 refers to\n\tLINE:.* I5$" I6 } diff --git a/test/fixedbugs/bug228.go b/test/fixedbugs/bug228.go index 50e895917f..5c0e7e5122 100644 --- a/test/fixedbugs/bug228.go +++ b/test/fixedbugs/bug228.go @@ -6,14 +6,10 @@ package main -func f(x int, y ...int) // ok +func f(x int, y ...int) // ok func g(x int, y float32) (...) // ERROR "[.][.][.]" -func h(x, y ...int) // ERROR "[.][.][.]" - -func i(x int, y ...int, z float32) // ERROR "[.][.][.]" - var x ...int; // ERROR "[.][.][.]|syntax|type" type T ...int; // ERROR "[.][.][.]|syntax|type" diff --git a/test/fixedbugs/bug228a.go b/test/fixedbugs/bug228a.go new file mode 100644 index 0000000000..c42b0bffb7 --- /dev/null +++ b/test/fixedbugs/bug228a.go @@ -0,0 +1,13 @@ +// errorcheck + +// 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 + +func f(x int, y ...int) // ok + +func h(x, y ...int) // ERROR "[.][.][.]" + +func i(x int, y ...int, z float32) // ERROR "[.][.][.]" diff --git a/test/fixedbugs/bug231.go b/test/fixedbugs/bug231.go index f64ddc3e75..db0d536db7 100644 --- a/test/fixedbugs/bug231.go +++ b/test/fixedbugs/bug231.go @@ -6,17 +6,19 @@ package main -type I interface { m() } -type T struct { m func() } -type M struct {} +type I interface{ m() } +type T struct{ m func() } +type M struct{} + func (M) m() {} func main() { var t T var m M var i I - + i = m - i = t // ERROR "not a method|has no methods" "does not implement I" + // types2 does not give extra error "T.m is a field, not a method" + i = t // ERROR "not a method|has no methods|does not implement I" _ = i } diff --git a/test/fixedbugs/bug255.go b/test/fixedbugs/bug255.go index 458fb972b2..38df7813c9 100644 --- a/test/fixedbugs/bug255.go +++ b/test/fixedbugs/bug255.go @@ -8,13 +8,13 @@ package main var a [10]int // ok var b [1e1]int // ok -var c [1.5]int // ERROR "truncated" -var d ["abc"]int // ERROR "invalid array bound|not numeric" -var e [nil]int // ERROR "use of untyped nil|invalid array bound|not numeric" +var c [1.5]int // ERROR "truncated|must be integer" +var d ["abc"]int // ERROR "invalid array bound|not numeric|must be integer" +var e [nil]int // ERROR "use of untyped nil|invalid array bound|not numeric|must be constant" var f [e]int // ok: error already reported for e -var g [1 << 65]int // ERROR "array bound is too large|overflows" +var g [1 << 65]int // ERROR "array bound is too large|overflows|must be integer" var h [len(a)]int // ok func ff() string -var i [len([1]string{ff()})]int // ERROR "non-constant array bound|not constant" +var i [len([1]string{ff()})]int // ERROR "non-constant array bound|not constant|must be constant" diff --git a/test/fixedbugs/bug388.go b/test/fixedbugs/bug388.go index 2d508501e0..a060c9fd5a 100644 --- a/test/fixedbugs/bug388.go +++ b/test/fixedbugs/bug388.go @@ -13,16 +13,6 @@ func foo(runtime.UintType, i int) { // ERROR "cannot declare name runtime.UintT println(i, runtime.UintType) // GCCGO_ERROR "undefined identifier" } -func bar(i int) { - runtime.UintType := i // ERROR "non-name runtime.UintType|non-name on left side|undefined identifier" - println(runtime.UintType) // GCCGO_ERROR "invalid use of type|undefined identifier" -} - -func baz() { - main.i := 1 // ERROR "non-name main.i|non-name on left side" - println(main.i) // GCCGO_ERROR "no fields or methods" -} - func qux() { var main.i // ERROR "unexpected [.]|expected type" println(main.i) diff --git a/test/fixedbugs/bug388a.go b/test/fixedbugs/bug388a.go new file mode 100644 index 0000000000..fca6d9c1e4 --- /dev/null +++ b/test/fixedbugs/bug388a.go @@ -0,0 +1,23 @@ +// errorcheck + +// 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. + +// Issue 2231 + +package main +import "runtime" + +func bar(i int) { + runtime.UintType := i // ERROR "non-name runtime.UintType|non-name on left side|undefined" + println(runtime.UintType) // ERROR "invalid use of type|undefined" +} + +func baz() { + main.i := 1 // ERROR "non-name main.i|non-name on left side|undefined" + println(main.i) // ERROR "no fields or methods|undefined" +} + +func main() { +} diff --git a/test/fixedbugs/bug412.go b/test/fixedbugs/bug412.go index 183fb7e4af..26ac45fbb4 100644 --- a/test/fixedbugs/bug412.go +++ b/test/fixedbugs/bug412.go @@ -7,10 +7,10 @@ package p type t struct { - x int // GCCGO_ERROR "duplicate field name .x." - x int // GC_ERROR "duplicate field x" + x int // GCCGO_ERROR "duplicate field name .x." + x int // GC_ERROR "duplicate field x|x redeclared" } func f(t *t) int { - return t.x // GC_ERROR "ambiguous selector t.x" + return t.x } diff --git a/test/fixedbugs/issue11590.go b/test/fixedbugs/issue11590.go index f2a955f96d..9f89783343 100644 --- a/test/fixedbugs/issue11590.go +++ b/test/fixedbugs/issue11590.go @@ -6,6 +6,6 @@ package p -var _ = int8(4) * 300 // ERROR "constant 300 overflows int8" "constant 1200 overflows int8|integer constant overflow" -var _ = complex64(1) * 1e200 // ERROR "constant 1e\+200 overflows complex64|complex real part overflow" -var _ = complex128(1) * 1e500 // ERROR "constant 1e\+500 overflows complex128|complex real part overflow" +var _ = int8(4) * 300 // ERROR "overflows int8" +var _ = complex64(1) * 1e200 // ERROR "complex real part overflow|overflows complex64" +var _ = complex128(1) * 1e500 // ERROR "complex real part overflow|overflows complex128" diff --git a/test/fixedbugs/issue11610.go b/test/fixedbugs/issue11610.go index 7ebfae6709..8d68c98f2d 100644 --- a/test/fixedbugs/issue11610.go +++ b/test/fixedbugs/issue11610.go @@ -8,7 +8,6 @@ // following an empty import. package a -import"" // ERROR "import path is empty" var? // ERROR "invalid character U\+003F '\?'|invalid character 0x3f in input file" var x int // ERROR "unexpected var|expected identifier|expected type" diff --git a/test/fixedbugs/issue11610a.go b/test/fixedbugs/issue11610a.go new file mode 100644 index 0000000000..bbf60b6b04 --- /dev/null +++ b/test/fixedbugs/issue11610a.go @@ -0,0 +1,11 @@ +// errorcheck + +// 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. + +// Test an internal compiler error on ? symbol in declaration +// following an empty import. + +package a +import"" // ERROR "import path is empty|invalid import path \(empty string\)" diff --git a/test/fixedbugs/issue11614.go b/test/fixedbugs/issue11614.go index 6ea463b7fe..e8d6badfb9 100644 --- a/test/fixedbugs/issue11614.go +++ b/test/fixedbugs/issue11614.go @@ -11,15 +11,15 @@ package main type I interface { - int // ERROR "interface contains embedded non-interface" + int // ERROR "interface contains embedded non-interface|embedding non-interface type int requires" } func n() { - (I) + (I) // GC_ERROR "is not an expression" } func m() { - (interface{int}) // ERROR "interface contains embedded non-interface" "type interface { int } is not an expression" + (interface{int}) // ERROR "interface contains embedded non-interface|embedding non-interface type int requires" "type interface { int } is not an expression|\(interface{int}\) \(type\) is not an expression" } func main() { diff --git a/test/fixedbugs/issue14520.go b/test/fixedbugs/issue14520.go index 0b840ff4be..29cc270deb 100644 --- a/test/fixedbugs/issue14520.go +++ b/test/fixedbugs/issue14520.go @@ -6,9 +6,6 @@ package f -import /* // ERROR "import path" */ ` -bogus` - func f(x int /* // GC_ERROR "unexpected newline" */) // GCCGO_ERROR "expected .*\).*|expected declaration" diff --git a/test/fixedbugs/issue14520a.go b/test/fixedbugs/issue14520a.go new file mode 100644 index 0000000000..bb45d7e186 --- /dev/null +++ b/test/fixedbugs/issue14520a.go @@ -0,0 +1,10 @@ +// errorcheck + +// 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 f + +import /* // ERROR "import path" */ ` +bogus` diff --git a/test/fixedbugs/issue17038.go b/test/fixedbugs/issue17038.go index 4d7422c60c..1b65ffc1f0 100644 --- a/test/fixedbugs/issue17038.go +++ b/test/fixedbugs/issue17038.go @@ -6,4 +6,4 @@ package main -const A = complex(0()) // ERROR "cannot call non-function" "not enough arguments" +const A = complex(0()) // ERROR "cannot call non-function" diff --git a/test/fixedbugs/issue19012.go b/test/fixedbugs/issue19012.go index 158618aa27..77b2236063 100644 --- a/test/fixedbugs/issue19012.go +++ b/test/fixedbugs/issue19012.go @@ -13,9 +13,9 @@ package main func f(x int, y uint) { if true { - return "a" > 10 // ERROR "^too many arguments to return$|return with value in function with no return|mismatched types" + return "a" > 10 // ERROR "^too many arguments to return$|return with value in function with no return|no result values expected|mismatched types" } - return "gopher" == true, 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 with value in function with no return|no result values expected|mismatched types" } func main() { diff --git a/test/fixedbugs/issue21979.go b/test/fixedbugs/issue21979.go index addf786c03..c6575a3928 100644 --- a/test/fixedbugs/issue21979.go +++ b/test/fixedbugs/issue21979.go @@ -7,39 +7,40 @@ package p func f() { - _ = 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" + _ = bool("") // ERROR "cannot convert .. \(.*untyped string.*\) to type bool|invalid type conversion" + _ = bool(1) // ERROR "cannot convert 1 \(.*untyped int.*\) to type bool|invalid type conversion" + _ = bool(1.0) // ERROR "cannot convert 1.* \(.*untyped float.*\) to type bool|invalid type conversion" + _ = bool(-4 + 2i) // ERROR "cannot convert -4 \+ 2i \(.*untyped complex.*\) to type bool|invalid type conversion" - _ = string(true) // ERROR "cannot convert true \(type untyped bool\) to type string|invalid type conversion" + _ = string(true) // ERROR "cannot convert true \(.*untyped bool.*\) to type string|invalid type conversion" _ = string(-1) - _ = 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" + _ = string(1.0) // ERROR "cannot convert 1.* \(.*untyped float.*\) to type string|invalid type conversion" + _ = string(-4 + 2i) // ERROR "cannot convert -4 \+ 2i \(.*untyped complex.*\) to type string|invalid type conversion" - _ = 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("") // ERROR "cannot convert .. \(.*untyped string.*\) to type int|invalid type conversion" + _ = int(true) // ERROR "cannot convert true \(.*untyped bool.*\) to type int|invalid type conversion" _ = int(-1) _ = int(1) _ = int(1.0) - _ = int(-4 + 2i) // ERROR "truncated to integer" + _ = int(-4 + 2i) // ERROR "truncated to integer|cannot convert -4 \+ 2i \(.*untyped complex.*\) to type int" - _ = 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("") // ERROR "cannot convert .. \(.*untyped string.*\) to type uint|invalid type conversion" + _ = uint(true) // ERROR "cannot convert true \(.*untyped bool.*\) to type uint|invalid type conversion" + _ = uint(-1) // ERROR "constant -1 overflows uint|integer constant overflow|cannot convert -1 \(untyped int constant\) to type uint" _ = uint(1) _ = uint(1.0) - _ = uint(-4 + 2i) // ERROR "constant -4 overflows uint" "truncated to integer" + // types1 reports extra error "truncated to integer" + _ = uint(-4 + 2i) // ERROR "constant -4 overflows uint|truncated to integer|cannot convert -4 \+ 2i \(untyped complex constant.*\) to type uint" - _ = 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("") // ERROR "cannot convert .. \(.*untyped string.*\) to type float64|invalid type conversion" + _ = float64(true) // ERROR "cannot convert true \(.*untyped bool.*\) to type float64|invalid type conversion" _ = float64(-1) _ = float64(1) _ = float64(1.0) - _ = float64(-4 + 2i) // ERROR "truncated to" + _ = float64(-4 + 2i) // ERROR "truncated to|cannot convert -4 \+ 2i \(.*untyped complex.*\) to type float64" - _ = 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("") // ERROR "cannot convert .. \(.*untyped string.*\) to type complex128|invalid type conversion" + _ = complex128(true) // ERROR "cannot convert true \(.*untyped bool.*\) to type complex128|invalid type conversion" _ = complex128(-1) _ = complex128(1) _ = complex128(1.0) diff --git a/test/fixedbugs/issue23732.go b/test/fixedbugs/issue23732.go index db2d182234..79b60e26df 100644 --- a/test/fixedbugs/issue23732.go +++ b/test/fixedbugs/issue23732.go @@ -24,19 +24,19 @@ func main() { _ = Foo{ // GCCGO_ERROR "too few expressions" 1, 2, - 3, // GC_ERROR "too few values in Foo{...}" - } + 3, + } // GC_ERROR "too few values in" _ = Foo{ 1, 2, 3, - Bar{"A", "B"}, // ERROR "too many values in Bar{...}|too many expressions" + Bar{"A", "B"}, // ERROR "too many values in|too many expressions" } _ = Foo{ // GCCGO_ERROR "too few expressions" 1, 2, - Bar{"A", "B"}, // ERROR "too many values in Bar{...}|too many expressions" "too few values in Foo{...}" - } + Bar{"A", "B"}, // ERROR "too many values in|too many expressions" + } // GC_ERROR "too few values in" } diff --git a/test/fixedbugs/issue25958.go b/test/fixedbugs/issue25958.go index 90fcee15fd..91358f83fe 100644 --- 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|expected .*<-.* or .*=" "not used" - case (chan struct{})(done): // ERROR "must be receive|expected .*<-.* or .*=" + case done: // ERROR "must be receive|expected .*<-.* or .*=|must be send or receive|not used" + case (chan struct{})(done): // ERROR "must be receive|expected .*<-.* or .*=|must be send or receive" } } diff --git a/test/fixedbugs/issue28079b.go b/test/fixedbugs/issue28079b.go index 54c9db994b..69d1a2f480 100644 --- 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|array bound is not constant" +type T [uintptr(unsafe.Pointer(nil))]int // ERROR "non-constant array bound|array bound is not constant|must be constant" func f() { - _ = complex(1< Date: Tue, 11 Jan 2022 10:22:40 +0100 Subject: [PATCH 607/752] cmd/go: skip TestScript/test_fuzz_test_race on !race Skip the test on targets which don't support the race detector. This fixes the linux-386-longtest builder after CL 376554. Updates #50488 Change-Id: I08bf6f72cc0731761d49121eb7cfaa8b53906d37 Reviewed-on: https://go-review.googlesource.com/c/go/+/377634 Trust: Tobias Klauser Run-TryBot: Tobias Klauser TryBot-Result: Gopher Robot Reviewed-by: Katie Hockman Trust: Katie Hockman Run-TryBot: Katie Hockman --- src/cmd/go/testdata/script/test_fuzz_test_race.txt | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/testdata/script/test_fuzz_test_race.txt b/src/cmd/go/testdata/script/test_fuzz_test_race.txt index 0bbc1fdd7d..9d39cd684e 100644 --- a/src/cmd/go/testdata/script/test_fuzz_test_race.txt +++ b/src/cmd/go/testdata/script/test_fuzz_test_race.txt @@ -4,8 +4,9 @@ [short] skip [!fuzz] skip +[!race] skip -# Test with coverage instrumentation enbaled (-fuzz) and race instrumentation +# Test with coverage instrumentation enabled (-fuzz) and race instrumentation # but without actually fuzzing the target (by using a non-matching pattern) go test -fuzz=xxx -race -v ! stderr 'race detected during execution of test' @@ -35,4 +36,4 @@ func FuzzRace(f *testing.F) { f.Fuzz(func(t *testing.T, i int) { t.Parallel() }) -} \ No newline at end of file +} From c7fa66179b51bc90612f564f2cb3afbc1b21d511 Mon Sep 17 00:00:00 2001 From: "Paul E. Murphy" Date: Mon, 10 Jan 2022 10:57:16 -0600 Subject: [PATCH 608/752] test: workaround SIGILL on issue11656 on aix For some reason, aix sometimes executes the bogus function body. This should never happen as it lives in a no-execute section. It might be a transient permission blip as the heap grows. Add a small function to cleanup and synchronize the icache before jumping to the bogus function to ensure it causes a panic, not SIGILL. Fixes #44583 Change-Id: Iadca62d82bfb70fc62088705dac42a880a1208fa Reviewed-on: https://go-review.googlesource.com/c/go/+/377314 Trust: Bryan Mills Run-TryBot: Paul Murphy TryBot-Result: Gopher Robot Reviewed-by: Cherry Mui --- test/fixedbugs/issue11656.dir/asm.go | 10 +++ test/fixedbugs/issue11656.dir/asm_generic.go | 11 +++ test/fixedbugs/issue11656.dir/asm_ppc64.s | 13 ++++ test/fixedbugs/issue11656.dir/asm_ppc64le.s | 13 ++++ test/fixedbugs/issue11656.dir/issue11656.go | 75 ++++++++++++++++++ test/fixedbugs/issue11656.go | 81 ++------------------ 6 files changed, 129 insertions(+), 74 deletions(-) create mode 100644 test/fixedbugs/issue11656.dir/asm.go create mode 100644 test/fixedbugs/issue11656.dir/asm_generic.go create mode 100644 test/fixedbugs/issue11656.dir/asm_ppc64.s create mode 100644 test/fixedbugs/issue11656.dir/asm_ppc64le.s create mode 100644 test/fixedbugs/issue11656.dir/issue11656.go diff --git a/test/fixedbugs/issue11656.dir/asm.go b/test/fixedbugs/issue11656.dir/asm.go new file mode 100644 index 0000000000..cdcb064dc5 --- /dev/null +++ b/test/fixedbugs/issue11656.dir/asm.go @@ -0,0 +1,10 @@ +// Copyright 2022 The Go 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:build ppc64 || ppc64le +// +build ppc64 ppc64le + +package main + +func syncIcache(p uintptr) diff --git a/test/fixedbugs/issue11656.dir/asm_generic.go b/test/fixedbugs/issue11656.dir/asm_generic.go new file mode 100644 index 0000000000..104d44dfeb --- /dev/null +++ b/test/fixedbugs/issue11656.dir/asm_generic.go @@ -0,0 +1,11 @@ +// Copyright 2022 The Go 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:build !ppc64 && !ppc64le +// +build !ppc64,!ppc64le + +package main + +func syncIcache(p uintptr) { +} diff --git a/test/fixedbugs/issue11656.dir/asm_ppc64.s b/test/fixedbugs/issue11656.dir/asm_ppc64.s new file mode 100644 index 0000000000..125a197ed8 --- /dev/null +++ b/test/fixedbugs/issue11656.dir/asm_ppc64.s @@ -0,0 +1,13 @@ +// Copyright 2022 The Go 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 syncIcache(p uintptr) +TEXT main·syncIcache(SB), NOSPLIT|NOFRAME, $0-0 + SYNC + MOVD (R3), R3 + ICBI (R3) + ISYNC + RET diff --git a/test/fixedbugs/issue11656.dir/asm_ppc64le.s b/test/fixedbugs/issue11656.dir/asm_ppc64le.s new file mode 100644 index 0000000000..125a197ed8 --- /dev/null +++ b/test/fixedbugs/issue11656.dir/asm_ppc64le.s @@ -0,0 +1,13 @@ +// Copyright 2022 The Go 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 syncIcache(p uintptr) +TEXT main·syncIcache(SB), NOSPLIT|NOFRAME, $0-0 + SYNC + MOVD (R3), R3 + ICBI (R3) + ISYNC + RET diff --git a/test/fixedbugs/issue11656.dir/issue11656.go b/test/fixedbugs/issue11656.dir/issue11656.go new file mode 100644 index 0000000000..a5a52df698 --- /dev/null +++ b/test/fixedbugs/issue11656.dir/issue11656.go @@ -0,0 +1,75 @@ +// 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 main + +import ( + "encoding/binary" + "runtime" + "runtime/debug" + "unsafe" +) + +func main() { + debug.SetPanicOnFault(true) + defer func() { + if err := recover(); err == nil { + panic("not panicking") + } + pc, _, _, _ := runtime.Caller(10) + f := runtime.FuncForPC(pc) + if f == nil || f.Name() != "main.f" { + if f == nil { + println("no func for ", unsafe.Pointer(pc)) + } else { + println("found func:", f.Name()) + } + panic("cannot find main.f on stack") + } + }() + f(20) +} + +func f(n int) { + if n > 0 { + f(n - 1) + } + var f struct { + x uintptr + } + + // 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": + ill = append(ill[:0], 0x89, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00) // MOVL AX, 0 + case "arm": + 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, 0xf90003ff) // MOVD ZR, (ZR) + case "ppc64": + binary.BigEndian.PutUint32(ill, 0xf8000000) // MOVD R0, (R0) + case "ppc64le": + binary.LittleEndian.PutUint32(ill, 0xf8000000) // MOVD R0, (R0) + case "mips", "mips64": + binary.BigEndian.PutUint32(ill, 0xfc000000) // MOVV R0, (R0) + case "mipsle", "mips64le": + binary.LittleEndian.PutUint32(ill, 0xfc000000) // MOVV R0, (R0) + case "s390x": + 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])) + p := &f + fn := *(*func())(unsafe.Pointer(&p)) + syncIcache(f.x) + fn() +} diff --git a/test/fixedbugs/issue11656.go b/test/fixedbugs/issue11656.go index 85fe720b30..dba8e35439 100644 --- a/test/fixedbugs/issue11656.go +++ b/test/fixedbugs/issue11656.go @@ -1,89 +1,22 @@ -// run +// runindir -// Copyright 2015 The Go Authors. All rights reserved. +// Copyright 2022 The Go 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 11656: runtime: jump to bad PC missing good traceback + // windows doesn't work, because Windows exception handling // delivers signals based on the current PC, and that current PC // doesn't go into the Go runtime. -// +build !windows // 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 +//go:build !windows && !wasm && !gccgo +// +build !windows,!wasm,!gccgo -import ( - "encoding/binary" - "runtime" - "runtime/debug" - "unsafe" -) - -func main() { - debug.SetPanicOnFault(true) - defer func() { - if err := recover(); err == nil { - panic("not panicking") - } - pc, _, _, _ := runtime.Caller(10) - f := runtime.FuncForPC(pc) - if f == nil || f.Name() != "main.f" { - if f == nil { - println("no func for ", unsafe.Pointer(pc)) - } else { - println("found func:", f.Name()) - } - panic("cannot find main.f on stack") - } - }() - f(20) -} - -func f(n int) { - if n > 0 { - f(n - 1) - } - var f struct { - x uintptr - } - - // 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": - ill = append(ill[:0], 0x89, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00) // MOVL AX, 0 - case "arm": - 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, 0xf90003ff) // MOVD ZR, (ZR) - case "ppc64": - binary.BigEndian.PutUint32(ill, 0xf8000000) // MOVD R0, (R0) - case "ppc64le": - binary.LittleEndian.PutUint32(ill, 0xf8000000) // MOVD R0, (R0) - case "mips", "mips64": - binary.BigEndian.PutUint32(ill, 0xfc000000) // MOVV R0, (R0) - case "mipsle", "mips64le": - binary.LittleEndian.PutUint32(ill, 0xfc000000) // MOVV R0, (R0) - case "s390x": - 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])) - p := &f - fn := *(*func())(unsafe.Pointer(&p)) - fn() -} +package ignored From 1cc3c735802f93eaf74b21795b8027163318ace1 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Thu, 6 Jan 2022 15:25:01 -0500 Subject: [PATCH 609/752] runtime: improve asanread/asanwrite nosplit comment Explain the conditions under which they are called on stacks that cannot grow. Change-Id: I08ee5480face7fbedeccc09e55b8149c5a793c2e Reviewed-on: https://go-review.googlesource.com/c/go/+/376036 Trust: Austin Clements Reviewed-by: Ian Lance Taylor Reviewed-by: Cherry Mui Reviewed-by: Fannie Zhang --- src/runtime/asan.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/runtime/asan.go b/src/runtime/asan.go index 26656cd975..5f1e6370d2 100644 --- a/src/runtime/asan.go +++ b/src/runtime/asan.go @@ -26,8 +26,9 @@ func ASanWrite(addr unsafe.Pointer, len int) { // Private interface for the runtime. const asanenabled = true -// Mark asan(read, write) as NOSPLIT, because they may run -// on stacks that cannot grow. See issue #50391. +// asan{read,write} are nosplit because they may be called between +// fork and exec, when the stack must not grow. See issue #50391. + //go:nosplit func asanread(addr unsafe.Pointer, sz uintptr) { sp := getcallersp() From 1abe9c1c73739786bb927342c4072e229affea8f Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Wed, 5 Jan 2022 15:20:50 -0800 Subject: [PATCH 610/752] cmd/compile: print "internal compiler error" message for all compiler panics Change hidePanic (now renamed handlePanic) to print out the "internal compiler error" message for all panics and runtime exceptions, similar to what we already do for the SSA backend in ssa.Compile(). Previously, hidePanic would not catch panics/exceptions unless it wanted to completely hide the panic because there had already been some compiler errors. Tested by manually inserting a seg fault in the compiler, and verifying that the seg fault is cause and "internal compiler error" message (with stack trace) is displayed proeprly. Updates #50423 Change-Id: Ibe846012e147fcdcc63ac147aae4bdfc47bf5a58 Reviewed-on: https://go-review.googlesource.com/c/go/+/376057 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: Russ Cox --- src/cmd/compile/internal/gc/main.go | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go index 96c6730803..4c4a724cdf 100644 --- a/src/cmd/compile/internal/gc/main.go +++ b/src/cmd/compile/internal/gc/main.go @@ -35,18 +35,18 @@ import ( "sort" ) -func hidePanic() { - 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 { - if err == "-h" { - panic(err) - } - base.ErrorExit() +// handlePanic ensures that we print out an "internal compiler error" for any panic +// or runtime exception during front-end compiler processing (unless there have +// already been some compiler errors). It may also be invoked from the explicit panic in +// hcrash(), in which case, we pass the panic on through. +func handlePanic() { + if err := recover(); err != nil { + if err == "-h" { + // Force real panic now with -h option (hcrash) - the error + // information will have already been printed. + panic(err) } + base.Fatalf("panic: %v", err) } } @@ -56,7 +56,7 @@ func hidePanic() { func Main(archInit func(*ssagen.ArchInfo)) { base.Timer.Start("fe", "init") - defer hidePanic() + defer handlePanic() archInit(&ssagen.Arch) From a20724d63425ccb871c57d45e2401af2401518bc Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 11 Jan 2022 12:53:25 -0500 Subject: [PATCH 611/752] go/types, types2: mention type decl scopes in Info.Scopes documentation We now may have a scope associated with a type declaration, so need to update our API documentation accordingly. Change-Id: Ic66dc3b7cd1969b25fb7c4bee986d76ab3544042 Reviewed-on: https://go-review.googlesource.com/c/go/+/377655 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/api.go | 1 + src/go/types/api.go | 1 + 2 files changed, 2 insertions(+) diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go index 4ea3989c39..fe754db7a4 100644 --- a/src/cmd/compile/internal/types2/api.go +++ b/src/cmd/compile/internal/types2/api.go @@ -265,6 +265,7 @@ type Info struct { // // *syntax.File // *syntax.FuncType + // *syntax.TypeDecl // *syntax.BlockStmt // *syntax.IfStmt // *syntax.SwitchStmt diff --git a/src/go/types/api.go b/src/go/types/api.go index 51d58c49aa..a2cc289fbc 100644 --- a/src/go/types/api.go +++ b/src/go/types/api.go @@ -260,6 +260,7 @@ type Info struct { // // *ast.File // *ast.FuncType + // *ast.TypeSpec // *ast.BlockStmt // *ast.IfStmt // *ast.SwitchStmt From ad7eae21d5e75a0b1fe89db5f299490d6273c4cf Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Tue, 11 Jan 2022 09:14:38 -0800 Subject: [PATCH 612/752] cmd/compile: resolve dictionaries/shape methods in markInlBody, if needed Issue #50552 is due to a problem with my recent improvement in the interaction between generics and inlining. In markInlBody(), we now mark dictionaries and shape methods for export, so they will be available for any package that inlines the current inlineable function. But we need to make sure that the dictionary and method symbols have actually been resolved into Nodes (looked up in the import data), if they are not already defined, so we can then mark them for export. Improved header comment on Resolve(). Fixes #50552 Change-Id: I89e52d39d3b9894591d2ad6eb3a8ed3bb5f1e0a0 Reviewed-on: https://go-review.googlesource.com/c/go/+/377714 Reviewed-by: Keith Randall Trust: Dan Scales --- src/cmd/compile/internal/typecheck/crawler.go | 20 ++++++++++++++----- .../compile/internal/typecheck/typecheck.go | 6 +++++- test/run.go | 1 + test/typeparam/issue50552.dir/a.go | 16 +++++++++++++++ test/typeparam/issue50552.dir/main.go | 20 +++++++++++++++++++ test/typeparam/issue50552.go | 7 +++++++ 6 files changed, 64 insertions(+), 6 deletions(-) create mode 100644 test/typeparam/issue50552.dir/a.go create mode 100644 test/typeparam/issue50552.dir/main.go create mode 100644 test/typeparam/issue50552.go diff --git a/src/cmd/compile/internal/typecheck/crawler.go b/src/cmd/compile/internal/typecheck/crawler.go index cdb1c46509..87dc5165fd 100644 --- a/src/cmd/compile/internal/typecheck/crawler.go +++ b/src/cmd/compile/internal/typecheck/crawler.go @@ -8,6 +8,7 @@ import ( "cmd/compile/internal/base" "cmd/compile/internal/ir" "cmd/compile/internal/types" + "cmd/internal/src" ) // crawlExports crawls the type/object graph rooted at the given list of exported @@ -241,11 +242,12 @@ func (p *crawler) markInlBody(n *ir.Name) { if t.IsFullyInstantiated() && !t.HasShape() && !t.IsInterface() && t.Methods().Len() > 0 { // For any fully-instantiated type, the relevant // dictionaries and shape instantiations will have - // already been created. Make sure that they are - // exported, so that any other package that inlines - // this function will have them available for import, - // and so will not need another round of method and - // dictionary instantiation after inlining. + // already been created or are in the import data. + // Make sure that they are exported, so that any + // other package that inlines this function will have + // them available for import, and so will not need + // another round of method and dictionary + // instantiation after inlining. baseType := t.OrigSym().Def.(*ir.Name).Type() shapes := make([]*types.Type, len(t.RParams())) for i, t1 := range t.RParams() { @@ -254,8 +256,16 @@ func (p *crawler) markInlBody(n *ir.Name) { for j := range t.Methods().Slice() { baseNname := baseType.Methods().Slice()[j].Nname.(*ir.Name) dictsym := MakeDictSym(baseNname.Sym(), t.RParams(), true) + if dictsym.Def == nil { + in := Resolve(ir.NewIdent(src.NoXPos, dictsym)) + dictsym = in.Sym() + } Export(dictsym.Def.(*ir.Name)) methsym := MakeFuncInstSym(baseNname.Sym(), shapes, false, true) + if methsym.Def == nil { + in := Resolve(ir.NewIdent(src.NoXPos, methsym)) + methsym = in.Sym() + } methNode := methsym.Def.(*ir.Name) Export(methNode) if HaveInlineBody(methNode.Func) { diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go index 42970f6a5e..f6be298667 100644 --- a/src/cmd/compile/internal/typecheck/typecheck.go +++ b/src/cmd/compile/internal/typecheck/typecheck.go @@ -129,7 +129,11 @@ const ( var typecheckdefstack []*ir.Name -// Resolve ONONAME to definition, if any. +// Resolve resolves an ONONAME node to a definition, if any. If n is not an ONONAME node, +// Resolve returns n unchanged. If n is an ONONAME node and not in the same package, +// then n.Sym() is resolved using import data. Otherwise, Resolve returns +// n.Sym().Def. An ONONAME node can be created using ir.NewIdent(), so an imported +// symbol can be resolved via Resolve(ir.NewIdent(src.NoXPos, sym)). func Resolve(n ir.Node) (res ir.Node) { if n == nil || n.Op() != ir.ONONAME { return n diff --git a/test/run.go b/test/run.go index 278d5efce9..75073993b8 100644 --- a/test/run.go +++ b/test/run.go @@ -2178,6 +2178,7 @@ var unifiedFailures = setOf( "typeparam/typeswitch2.go", // duplicate case failure due to stenciling "typeparam/typeswitch3.go", // duplicate case failure due to stenciling "typeparam/typeswitch4.go", // duplicate case failure due to stenciling + "typeparam/issue50552.go", // gives missing method for instantiated type ) func setOf(keys ...string) map[string]bool { diff --git a/test/typeparam/issue50552.dir/a.go b/test/typeparam/issue50552.dir/a.go new file mode 100644 index 0000000000..89b9bcb877 --- /dev/null +++ b/test/typeparam/issue50552.dir/a.go @@ -0,0 +1,16 @@ +package a + +type Builder[T any] struct{} + +func (r Builder[T]) New() T { + var v T + return v +} + +func (r Builder[T]) New2() T { + return r.New() +} + +func BuildInt() int { + return Builder[int]{}.New() +} diff --git a/test/typeparam/issue50552.dir/main.go b/test/typeparam/issue50552.dir/main.go new file mode 100644 index 0000000000..047c27e5e1 --- /dev/null +++ b/test/typeparam/issue50552.dir/main.go @@ -0,0 +1,20 @@ +// Copyright 2022 The Go 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" + "fmt" +) + +func BuildInt() int { + return a.BuildInt() +} + +func main() { + if got, want := BuildInt(), 0; got != want { + panic(fmt.Sprintf("got %d, want %d", got, want)) + } +} diff --git a/test/typeparam/issue50552.go b/test/typeparam/issue50552.go new file mode 100644 index 0000000000..87b4ff46c1 --- /dev/null +++ b/test/typeparam/issue50552.go @@ -0,0 +1,7 @@ +// compiledir -G=3 + +// 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 From 13c912d19252b9225fa96b9a5557575bbaffb570 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Fri, 7 Jan 2022 12:22:24 -0800 Subject: [PATCH 613/752] cmd/compile: in typ0(), load base type before checking s.Def The loading of the base type in typ0() may cause s.Def to be defined for the instantiated type, so load the base type before checking s.Def. Fixes #50486 Change-Id: Ic039bc8f774dda534f4ccd1f920220b7a10dede6 Reviewed-on: https://go-review.googlesource.com/c/go/+/377094 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: Keith Randall --- src/cmd/compile/internal/noder/types.go | 13 ++-- test/typeparam/issue50486.dir/goerror_fp.go | 75 +++++++++++++++++++++ test/typeparam/issue50486.dir/main.go | 16 +++++ test/typeparam/issue50486.go | 7 ++ 4 files changed, 107 insertions(+), 4 deletions(-) create mode 100644 test/typeparam/issue50486.dir/goerror_fp.go create mode 100644 test/typeparam/issue50486.dir/main.go create mode 100644 test/typeparam/issue50486.go diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go index ed816b4955..3f3c9566ca 100644 --- a/src/cmd/compile/internal/noder/types.go +++ b/src/cmd/compile/internal/noder/types.go @@ -113,6 +113,15 @@ func (g *irgen) typ0(typ types2.Type) *types.Type { // based on the names of the type arguments. instName := g.instTypeName2(typ.Obj().Name(), typ.TypeArgs()) s := g.pkg(typ.Obj().Pkg()).Lookup(instName) + + // Make sure the base generic type exists in type1 (it may + // not yet if we are referecing an imported generic type, as + // opposed to a generic type declared in this package). Make + // sure to do this lookup before checking s.Def, in case + // s.Def gets defined while importing base (if an imported + // type). (Issue #50486). + base := g.obj(typ.Origin().Obj()) + if s.Def != nil { // We have already encountered this instantiation. // Use the type we previously created, since there @@ -120,10 +129,6 @@ func (g *irgen) typ0(typ types2.Type) *types.Type { return s.Def.Type() } - // Make sure the base generic type exists in type1 (it may - // not yet if we are referecing an imported generic type, as - // opposed to a generic type declared in this package). - base := g.obj(typ.Origin().Obj()) if base.Class == ir.PAUTO { // If the base type is a local type, we want to pop // this instantiated type symbol/definition when we diff --git a/test/typeparam/issue50486.dir/goerror_fp.go b/test/typeparam/issue50486.dir/goerror_fp.go new file mode 100644 index 0000000000..fec9095f79 --- /dev/null +++ b/test/typeparam/issue50486.dir/goerror_fp.go @@ -0,0 +1,75 @@ +// Copyright 2022 The Go 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 goerror_fp + +type Seq[T any] []T + +func (r Seq[T]) Size() int { + return len(r) +} + +func (r Seq[T]) Append(items ...T) Seq[T] { + tail := Seq[T](items) + ret := make(Seq[T], r.Size()+tail.Size()) + + for i := range r { + ret[i] = r[i] + } + + for i := range tail { + ret[i+r.Size()] = tail[i] + } + + return ret +} + +func (r Seq[T]) Iterator() Iterator[T] { + idx := 0 + + return Iterator[T]{ + IsHasNext: func() bool { + return idx < r.Size() + }, + GetNext: func() T { + ret := r[idx] + idx++ + return ret + }, + } +} + +type Iterator[T any] struct { + IsHasNext func() bool + GetNext func() T +} + +func (r Iterator[T]) ToSeq() Seq[T] { + ret := Seq[T]{} + for r.HasNext() { + ret = append(ret, r.Next()) + } + return ret +} + +func (r Iterator[T]) Map(f func(T) any) Iterator[any] { + return MakeIterator(r.HasNext, func() any { + return f(r.Next()) + }) +} + +func (r Iterator[T]) HasNext() bool { + return r.IsHasNext() +} + +func (r Iterator[T]) Next() T { + return r.GetNext() +} + +func MakeIterator[T any](has func() bool, next func() T) Iterator[T] { + return Iterator[T]{ + IsHasNext: has, + GetNext: next, + } +} diff --git a/test/typeparam/issue50486.dir/main.go b/test/typeparam/issue50486.dir/main.go new file mode 100644 index 0000000000..db5f1c3223 --- /dev/null +++ b/test/typeparam/issue50486.dir/main.go @@ -0,0 +1,16 @@ +package main + +import fp "goerror_fp" + +func Fold[A, B any](zero B, a A, f func(B, A) B) B { + return f(zero, a) +} + +func main() { + + var v any = "hello" + Fold(fp.Seq[any]{}, v, func(seq fp.Seq[any], v any) fp.Seq[any] { + return seq.Append(v) + }) + +} diff --git a/test/typeparam/issue50486.go b/test/typeparam/issue50486.go new file mode 100644 index 0000000000..87b4ff46c1 --- /dev/null +++ b/test/typeparam/issue50486.go @@ -0,0 +1,7 @@ +// compiledir -G=3 + +// 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 From 1ee70da3125cb6339c1bcb0c127cd97a9e1dbe90 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Sat, 8 Jan 2022 10:33:35 -0800 Subject: [PATCH 614/752] cmd/compile: fix the names of methods created during type substitution The names given to methods of types created during type substitution were possible incorrect when the type parameters themselves were nested types. Fixes #50485 Change-Id: I7e0043ed22c26406a5f9d8d51d9e928770a678f6 Reviewed-on: https://go-review.googlesource.com/c/go/+/377494 Reviewed-by: Keith Randall Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/typecheck/subr.go | 24 ++- test/typeparam/issue50485.dir/a.go | 239 +++++++++++++++++++++ test/typeparam/issue50485.dir/main.go | 9 + test/typeparam/issue50485.go | 7 + 4 files changed, 277 insertions(+), 2 deletions(-) create mode 100644 test/typeparam/issue50485.dir/a.go create mode 100644 test/typeparam/issue50485.dir/main.go create mode 100644 test/typeparam/issue50485.go diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go index da5e9645ea..04a4ed392f 100644 --- a/src/cmd/compile/internal/typecheck/subr.go +++ b/src/cmd/compile/internal/typecheck/subr.go @@ -976,7 +976,9 @@ func makeInstName1(name string, targs []*types.Type, hasBrackets bool) string { // function that helps implement a method of an instantiated type). For method nodes // on shape types, we prepend "nofunc.", because method nodes for shape types will // have no body, and we want to avoid a name conflict with the shape-based function -// that helps implement the same method for fully-instantiated types. +// that helps implement the same method for fully-instantiated types. Function names +// are also created at the end of (*Tsubster).typ1, so we append "nofunc" there as +// well, as needed. func MakeFuncInstSym(gf *types.Sym, targs []*types.Type, isMethodNode, hasBrackets bool) *types.Sym { nm := makeInstName1(gf.Name, targs, hasBrackets) if targs[0].HasShape() && isMethodNode { @@ -1273,7 +1275,25 @@ func (ts *Tsubster) typ1(t *types.Type) *types.Type { for i, f := range t.Methods().Slice() { t2 := ts.typ1(f.Type) oldsym := f.Nname.Sym() - newsym := MakeFuncInstSym(oldsym, ts.Targs, true, true) + + // Use the name of the substituted receiver to create the + // method name, since the receiver name may have many levels + // of nesting (brackets) with type names to be substituted. + recvType := t2.Recv().Type + var nm string + if recvType.IsPtr() { + recvType = recvType.Elem() + nm = "(*" + recvType.Sym().Name + ")." + f.Sym.Name + } else { + nm = recvType.Sym().Name + "." + f.Sym.Name + } + if recvType.RParams()[0].HasShape() { + // We add "nofunc" to methods of shape type to avoid + // conflict with the name of the shape-based helper + // function. See header comment of MakeFuncInstSym. + nm = "nofunc." + nm + } + newsym := oldsym.Pkg.Lookup(nm) var nname *ir.Name if newsym.Def != nil { nname = newsym.Def.(*ir.Name) diff --git a/test/typeparam/issue50485.dir/a.go b/test/typeparam/issue50485.dir/a.go new file mode 100644 index 0000000000..3a7c71a711 --- /dev/null +++ b/test/typeparam/issue50485.dir/a.go @@ -0,0 +1,239 @@ +package a + +import "fmt" + +type ImplicitOrd interface { + ~int | ~int8 | ~int16 | ~int32 | ~int64 | + ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | + ~float32 | ~float64 | + ~string +} + +func LessGiven[T ImplicitOrd]() Ord[T] { + return LessFunc[T](func(a, b T) bool { + return a < b + }) +} + +type Eq[T any] interface { + Eqv(a T, b T) bool +} + +type Ord[T any] interface { + Eq[T] + Less(a T, b T) bool +} + +type LessFunc[T any] func(a, b T) bool + +func (r LessFunc[T]) Eqv(a, b T) bool { + return r(a, b) == false && r(b, a) == false +} + +func (r LessFunc[T]) Less(a, b T) bool { + return r(a, b) +} + +type Option[T any] struct { + v *T +} + +func (r Option[T]) IsDefined() bool { + return r.v != nil +} + +func (r Option[T]) IsEmpty() bool { + return !r.IsDefined() +} + +func (r Option[T]) Get() T { + return *r.v +} + +func (r Option[T]) String() string { + if r.IsDefined() { + return fmt.Sprintf("Some(%v)", r.v) + } else { + return "None" + } +} + +func (r Option[T]) OrElse(t T) T { + if r.IsDefined() { + return *r.v + } + return t +} + +func (r Option[T]) Recover(f func() T) Option[T] { + if r.IsDefined() { + return r + } + t := f() + return Option[T]{&t} +} + +type Func1[A1, R any] func(a1 A1) R + +type Func2[A1, A2, R any] func(a1 A1, a2 A2) R + +func (r Func2[A1, A2, R]) Curried() Func1[A1, Func1[A2, R]] { + return func(a1 A1) Func1[A2, R] { + return Func1[A2, R](func(a2 A2) R { + return r(a1, a2) + }) + } +} + +type HList interface { + sealed() +} + +// Header is constrains interface type, enforce Head type of Cons is HT +type Header[HT any] interface { + HList + Head() HT +} + +// Cons means H :: T +// zero value of Cons[H,T] is not allowed. +// so Cons defined as interface type +type Cons[H any, T HList] interface { + HList + Head() H + Tail() T +} + +type Nil struct { +} + +func (r Nil) Head() Nil { + return r +} + +func (r Nil) Tail() Nil { + return r +} + +func (r Nil) String() string { + return "Nil" +} + +func (r Nil) sealed() { + +} + +type hlistImpl[H any, T HList] struct { + head H + tail T +} + +func (r hlistImpl[H, T]) Head() H { + return r.head +} + +func (r hlistImpl[H, T]) Tail() T { + return r.tail +} + +func (r hlistImpl[H, T]) String() string { + return fmt.Sprintf("%v :: %v", r.head, r.tail) +} + +func (r hlistImpl[H, T]) sealed() { + +} + +func hlist[H any, T HList](h H, t T) Cons[H, T] { + return hlistImpl[H, T]{h, t} +} + +func Concat[H any, T HList](h H, t T) Cons[H, T] { + return hlist(h, t) +} + +func Empty() Nil { + return Nil{} +} +func Some[T any](v T) Option[T] { + return Option[T]{}.Recover(func() T { + return v + }) +} + +func None[T any]() Option[T] { + return Option[T]{} +} + +func Ap[T, U any](t Option[Func1[T, U]], a Option[T]) Option[U] { + return FlatMap(t, func(f Func1[T, U]) Option[U] { + return Map(a, f) + }) +} + +func Map[T, U any](opt Option[T], f func(v T) U) Option[U] { + return FlatMap(opt, func(v T) Option[U] { + return Some(f(v)) + }) +} + +func FlatMap[T, U any](opt Option[T], fn func(v T) Option[U]) Option[U] { + if opt.IsDefined() { + return fn(opt.Get()) + } + return None[U]() +} + +type ApplicativeFunctor1[H Header[HT], HT, A, R any] struct { + h Option[H] + fn Option[Func1[A, R]] +} + +func (r ApplicativeFunctor1[H, HT, A, R]) ApOption(a Option[A]) Option[R] { + return Ap(r.fn, a) +} + +func (r ApplicativeFunctor1[H, HT, A, R]) Ap(a A) Option[R] { + return r.ApOption(Some(a)) +} + +func Applicative1[A, R any](fn Func1[A, R]) ApplicativeFunctor1[Nil, Nil, A, R] { + return ApplicativeFunctor1[Nil, Nil, A, R]{Some(Empty()), Some(fn)} +} + +type ApplicativeFunctor2[H Header[HT], HT, A1, A2, R any] struct { + h Option[H] + fn Option[Func1[A1, Func1[A2, R]]] +} + +func (r ApplicativeFunctor2[H, HT, A1, A2, R]) ApOption(a Option[A1]) ApplicativeFunctor1[Cons[A1, H], A1, A2, R] { + + nh := FlatMap(r.h, func(hv H) Option[Cons[A1, H]] { + return Map(a, func(av A1) Cons[A1, H] { + return Concat(av, hv) + }) + }) + + return ApplicativeFunctor1[Cons[A1, H], A1, A2, R]{nh, Ap(r.fn, a)} +} +func (r ApplicativeFunctor2[H, HT, A1, A2, R]) Ap(a A1) ApplicativeFunctor1[Cons[A1, H], A1, A2, R] { + + return r.ApOption(Some(a)) + +} + +func Applicative2[A1, A2, R any](fn Func2[A1, A2, R]) ApplicativeFunctor2[Nil, Nil, A1, A2, R] { + return ApplicativeFunctor2[Nil, Nil, A1, A2, R]{Some(Empty()), Some(fn.Curried())} +} +func OrdOption[T any](m Ord[T]) Ord[Option[T]] { + return LessFunc[Option[T]](func(t1 Option[T], t2 Option[T]) bool { + if !t1.IsDefined() && !t2.IsDefined() { + return false + } + return Applicative2(m.Less).ApOption(t1).ApOption(t2).OrElse(!t1.IsDefined()) + }) +} + +func Given[T ImplicitOrd]() Ord[T] { + return LessGiven[T]() +} diff --git a/test/typeparam/issue50485.dir/main.go b/test/typeparam/issue50485.dir/main.go new file mode 100644 index 0000000000..88a765bfe9 --- /dev/null +++ b/test/typeparam/issue50485.dir/main.go @@ -0,0 +1,9 @@ +package main + +import ( + "a" +) + +func main() { + _ = a.OrdOption(a.Given[int]()) +} diff --git a/test/typeparam/issue50485.go b/test/typeparam/issue50485.go new file mode 100644 index 0000000000..87b4ff46c1 --- /dev/null +++ b/test/typeparam/issue50485.go @@ -0,0 +1,7 @@ +// compiledir -G=3 + +// 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 From 8070e70d64c5f82f1cf4c2079d97766e5da9775e Mon Sep 17 00:00:00 2001 From: Emmanuel T Odeke Date: Mon, 10 Jan 2022 23:04:22 -0800 Subject: [PATCH 615/752] cmd/compile/types2, go/types: add position for "have" in failed interface satisfaction With this change, we shall now see: *myS does not implement S (wrong type for DoSomething method) have DoSomething() (string, error) at ./main.go:9:14 want DoSomething() (int, error) instead of previously: *myS does not implement S (wrong type for DoSomething method) have DoSomething() (string, error) want DoSomething() (int, error) Fixes #42841 Fixes #45813 Change-Id: I66990929e39b0d36f2e91da0d92f60586a9b84e5 Reviewed-on: https://go-review.googlesource.com/c/go/+/373634 Trust: Robert Findley Trust: Emmanuel Odeke Run-TryBot: Emmanuel Odeke TryBot-Result: Gopher Robot Reviewed-by: Robert Griesemer --- src/cmd/compile/internal/types2/lookup.go | 14 +++++++------- .../internal/types2/testdata/check/issues.src | 2 +- src/go/types/lookup.go | 15 ++++++++------- test/fixedbugs/issue48471.go | 8 ++++---- 4 files changed, 20 insertions(+), 19 deletions(-) diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index 5428b667a5..2b710040a4 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -428,18 +428,18 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string if wrongType != nil { if Identical(m.typ, wrongType.typ) { if m.Name() == wrongType.Name() { - r = check.sprintf("(%s has pointer receiver)", mname) + r = check.sprintf("(%s has pointer receiver) at %s", mname, wrongType.Pos()) } else { - r = check.sprintf("(missing %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", - mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) + r = check.sprintf("(missing %s)\n\t\thave %s^^%s at %s\n\t\twant %s^^%s", + mname, wrongType.Name(), wrongType.typ, wrongType.Pos(), m.Name(), m.typ) } } else { if check.conf.CompilerErrorMessages { - r = check.sprintf("(wrong type for %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", - mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) + r = check.sprintf("(wrong type for %s)\n\t\thave %s^^%s at %s\n\t\twant %s^^%s", + mname, wrongType.Name(), wrongType.typ, wrongType.Pos(), m.Name(), m.typ) } else { - r = check.sprintf("(wrong type for %s: have %s, want %s)", - mname, wrongType.typ, m.typ) + r = check.sprintf("(wrong type for %s)\n\thave %s at %s\n\twant %s", + mname, wrongType.typ, wrongType.Pos(), m.typ) } } // This is a hack to print the function type without the leading diff --git a/src/cmd/compile/internal/types2/testdata/check/issues.src b/src/cmd/compile/internal/types2/testdata/check/issues.src index f4b6199b82..868df46bd9 100644 --- a/src/cmd/compile/internal/types2/testdata/check/issues.src +++ b/src/cmd/compile/internal/types2/testdata/check/issues.src @@ -137,7 +137,7 @@ func issue10260() { T1{}.foo /* ERROR cannot call pointer method foo on T1 */ () x.Foo /* ERROR "x.Foo undefined \(type I1 has no field or method Foo, but does have foo\)" */ () - _ = i2. /* ERROR impossible type assertion: i2.\(\*T1\)\n\t\*T1 does not implement I2 \(wrong type for method foo: have func\(\), want func\(x int\)\) */ (*T1) + _ = i2. /* ERROR impossible type assertion: i2.\(\*T1\)\n\t\*T1 does not implement I2 \(wrong type for method foo\)\n\thave func\(\) at \w+.+\d+.\d+\n\twant func\(x int\) */ (*T1) i1 = i0 /* ERROR cannot use .* missing method foo */ i1 = t0 /* ERROR cannot use .* missing method foo */ diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go index 598f615247..b9c5048b5d 100644 --- a/src/go/types/lookup.go +++ b/src/go/types/lookup.go @@ -400,20 +400,21 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string mname = "method " + m.Name() } if wrongType != nil { + pos := check.fset.Position(wrongType.Pos()) if Identical(m.typ, wrongType.typ) { if m.Name() == wrongType.Name() { - r = check.sprintf("(%s has pointer receiver)", mname) + r = check.sprintf("(%s has pointer receiver) at %s", mname, pos) } else { - r = check.sprintf("(missing %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", - mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) + r = check.sprintf("(missing %s)\n\t\thave %s^^%s at %s\n\t\twant %s^^%s", + mname, wrongType.Name(), wrongType.typ, pos, m.Name(), m.typ) } } else { if compilerErrorMessages { - r = check.sprintf("(wrong type for %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", - mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) + r = check.sprintf("(wrong type for %s)\n\t\thave %s^^%s at %s\n\t\twant %s^^%s", + mname, wrongType.Name(), wrongType.typ, pos, m.Name(), m.typ) } else { - r = check.sprintf("(wrong type for %s: have %s, want %s)", - mname, wrongType.typ, m.typ) + r = check.sprintf("(wrong type for %s)\n\thave %s at %s\nwant %s", + mname, wrongType.typ, pos, m.typ) } } // This is a hack to print the function type without the leading diff --git a/test/fixedbugs/issue48471.go b/test/fixedbugs/issue48471.go index ba6245ab41..8c5d3d4efa 100644 --- a/test/fixedbugs/issue48471.go +++ b/test/fixedbugs/issue48471.go @@ -29,12 +29,12 @@ func g() { var i I i = new(T) // ERROR "cannot use new\(T\) \(.*type \*T\) as type I in assignment:\n\t\*T does not implement I \(missing M method\)" i = I(new(T)) // ERROR "cannot convert new\(T\) \(.*type \*T\) to type I:\n\t\*T does not implement I \(missing M method\)" - i = new(T2) // ERROR "cannot use new\(T2\) \(.*type \*T2\) as type I in assignment:\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\)\n\t\twant M\(int\)" - i = new(T3) // ERROR "cannot use new\(T3\) \(.*type \*T3\) as type I in assignment:\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\)\n\t\twant M\(int\)" + i = new(T2) // ERROR "cannot use new\(T2\) \(.*type \*T2\) as type I in assignment:\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\) at \w+.+\d.\d+\n\t\twant M\(int\)" + i = new(T3) // ERROR "cannot use new\(T3\) \(.*type \*T3\) as type I in assignment:\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\) at \w+.+\d.\d+\n\t\twant M\(int\)" i = T4{} // ERROR "cannot use T4\{\} \(.*type T4\) as type I in assignment:\n\tT4 does not implement I \(M method has pointer receiver\)" i = new(I) // ERROR "cannot use new\(I\) \(.*type \*I\) as type I in assignment:\n\t\*I does not implement I \(type \*I is pointer to interface, not interface\)" - _ = i.(*T2) // ERROR "impossible type assertion: i.\(\*T2\)\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\)\n\t\twant M\(int\)" - _ = i.(*T3) // ERROR "impossible type assertion: i.\(\*T3\)\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\)\n\t\twant M\(int\)" + _ = i.(*T2) // ERROR "impossible type assertion: i.\(\*T2\)\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\) at \w+.+\d.\d+\n\t\twant M\(int\)" + _ = i.(*T3) // ERROR "impossible type assertion: i.\(\*T3\)\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\) at \w+.+\d.\d+\n\t\twant M\(int\)" var t *T4 t = i // ERROR "cannot use i \(variable of type I\) as type \*T4 in assignment:\n\tneed type assertion" _ = i From 9bce08999a4122a28daf99cde7f22cb023b79660 Mon Sep 17 00:00:00 2001 From: Roland Shoemaker Date: Wed, 25 Aug 2021 13:50:24 -0700 Subject: [PATCH 616/752] all: add a handful of fuzz targets Adds simple fuzz targets to archive/tar, archive/zip, compress/gzip, encoding/json, image/jpeg, image/gif, and image/png. Change-Id: Ide1a8de88a9421e786eeeaea3bb93f41e0bae347 Reviewed-on: https://go-review.googlesource.com/c/go/+/352109 Trust: Katie Hockman Reviewed-by: Katie Hockman Trust: Roland Shoemaker Run-TryBot: Roland Shoemaker TryBot-Result: Gopher Robot --- src/archive/tar/fuzz_test.go | 97 ++++++++++++++++++++++++++++++++++ src/archive/zip/fuzz_test.go | 81 ++++++++++++++++++++++++++++ src/compress/gzip/fuzz_test.go | 92 ++++++++++++++++++++++++++++++++ src/encoding/json/fuzz_test.go | 83 +++++++++++++++++++++++++++++ src/image/gif/fuzz_test.go | 61 +++++++++++++++++++++ src/image/jpeg/fuzz_test.go | 61 +++++++++++++++++++++ src/image/png/fuzz_test.go | 68 ++++++++++++++++++++++++ 7 files changed, 543 insertions(+) create mode 100644 src/archive/tar/fuzz_test.go create mode 100644 src/archive/zip/fuzz_test.go create mode 100644 src/compress/gzip/fuzz_test.go create mode 100644 src/encoding/json/fuzz_test.go create mode 100644 src/image/gif/fuzz_test.go create mode 100644 src/image/jpeg/fuzz_test.go create mode 100644 src/image/png/fuzz_test.go diff --git a/src/archive/tar/fuzz_test.go b/src/archive/tar/fuzz_test.go new file mode 100644 index 0000000000..069602aa21 --- /dev/null +++ b/src/archive/tar/fuzz_test.go @@ -0,0 +1,97 @@ +// 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. + +//go:build !android +// +build !android + +package tar + +import ( + "bytes" + "internal/testenv" + "io" + "os" + "path/filepath" + "strings" + "testing" +) + +var constrainedBuilders = map[string]bool{ + "windows-386-2012": true, + "windows-386-2008": true, + "js-wasm": true, + "android-amd64-emu": true, +} + +func FuzzReader(f *testing.F) { + if constrainedBuilders[testenv.Builder()] { + f.Skip("builder is memory constrained") + } + testdata, err := os.ReadDir("testdata") + if err != nil { + f.Fatalf("failed to read testdata directory: %s", err) + } + for _, de := range testdata { + if de.IsDir() { + continue + } + if strings.Contains(de.Name(), "big") { + // skip large archives so we don't kill builders with restricted + // memory + continue + } + b, err := os.ReadFile(filepath.Join("testdata", de.Name())) + if err != nil { + f.Fatalf("failed to read testdata: %s", err) + } + f.Add(b) + } + + f.Fuzz(func(t *testing.T, b []byte) { + r := NewReader(bytes.NewReader(b)) + type file struct { + header *Header + content []byte + } + files := []file{} + for { + hdr, err := r.Next() + if err == io.EOF { + break + } + if err != nil { + return + } + buf := bytes.NewBuffer(nil) + if _, err := io.Copy(buf, r); err != nil { + continue + } + files = append(files, file{header: hdr, content: buf.Bytes()}) + } + + // If we were unable to read anything out of the archive don't + // bother trying to roundtrip it. + if len(files) == 0 { + return + } + + out := bytes.NewBuffer(nil) + w := NewWriter(out) + for _, f := range files { + if err := w.WriteHeader(f.header); err != nil { + t.Fatalf("unable to write previously parsed header: %s", err) + } + if _, err := w.Write(f.content); err != nil { + t.Fatalf("unable to write previously parsed content: %s", err) + } + } + if err := w.Close(); err != nil { + t.Fatalf("Unable to write archive: %s", err) + } + + // TODO: We may want to check if the archive roundtrips. This would require + // taking into account addition of the two zero trailer blocks that Writer.Close + // appends. + }) +} diff --git a/src/archive/zip/fuzz_test.go b/src/archive/zip/fuzz_test.go new file mode 100644 index 0000000000..7dffde69bf --- /dev/null +++ b/src/archive/zip/fuzz_test.go @@ -0,0 +1,81 @@ +// 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 zip + +import ( + "bytes" + "io" + "os" + "path/filepath" + "testing" +) + +func FuzzReader(f *testing.F) { + testdata, err := os.ReadDir("testdata") + if err != nil { + f.Fatalf("failed to read testdata directory: %s", err) + } + for _, de := range testdata { + if de.IsDir() { + continue + } + b, err := os.ReadFile(filepath.Join("testdata", de.Name())) + if err != nil { + f.Fatalf("failed to read testdata: %s", err) + } + f.Add(b) + } + + f.Fuzz(func(t *testing.T, b []byte) { + r, err := NewReader(bytes.NewReader(b), int64(len(b))) + if err != nil { + return + } + + type file struct { + header *FileHeader + content []byte + } + files := []file{} + + for _, f := range r.File { + fr, err := f.Open() + if err != nil { + continue + } + content, err := io.ReadAll(fr) + if err != nil { + continue + } + files = append(files, file{header: &f.FileHeader, content: content}) + if _, err := r.Open(f.Name); err != nil { + continue + } + } + + // If we were unable to read anything out of the archive don't + // bother trying to roundtrip it. + if len(files) == 0 { + return + } + + w := NewWriter(io.Discard) + for _, f := range files { + ww, err := w.CreateHeader(f.header) + if err != nil { + t.Fatalf("unable to write previously parsed header: %s", err) + } + if _, err := ww.Write(f.content); err != nil { + t.Fatalf("unable to write previously parsed content: %s", err) + } + } + + if err := w.Close(); err != nil { + t.Fatalf("Unable to write archive: %s", err) + } + + // TODO: We may want to check if the archive roundtrips. + }) +} diff --git a/src/compress/gzip/fuzz_test.go b/src/compress/gzip/fuzz_test.go new file mode 100644 index 0000000000..80d803ce93 --- /dev/null +++ b/src/compress/gzip/fuzz_test.go @@ -0,0 +1,92 @@ +// 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 gzip + +import ( + "bytes" + "encoding/base64" + "io" + "os" + "path/filepath" + "strings" + "testing" +) + +func FuzzReader(f *testing.F) { + inp := []byte("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.") + for _, level := range []int{BestSpeed, BestCompression, DefaultCompression, HuffmanOnly} { + b := bytes.NewBuffer(nil) + w, err := NewWriterLevel(b, level) + if err != nil { + f.Fatalf("failed to construct writer: %s", err) + } + _, err = w.Write(inp) + if err != nil { + f.Fatalf("failed to write: %s", err) + } + f.Add(b.Bytes()) + } + + testdata, err := os.ReadDir("testdata") + if err != nil { + f.Fatalf("failed to read testdata directory: %s", err) + } + for _, de := range testdata { + if de.IsDir() { + continue + } + b, err := os.ReadFile(filepath.Join("testdata", de.Name())) + if err != nil { + f.Fatalf("failed to read testdata: %s", err) + } + + // decode any base64 encoded test files + if strings.HasPrefix(de.Name(), ".base64") { + b, err = base64.StdEncoding.DecodeString(string(b)) + if err != nil { + f.Fatalf("failed to decode base64 testdata: %s", err) + } + } + + f.Add(b) + } + + f.Fuzz(func(t *testing.T, b []byte) { + for _, multistream := range []bool{true, false} { + r, err := NewReader(bytes.NewBuffer(b)) + if err != nil { + continue + } + + r.Multistream(multistream) + + decompressed := bytes.NewBuffer(nil) + if _, err := io.Copy(decompressed, r); err != nil { + continue + } + + if err := r.Close(); err != nil { + continue + } + + for _, level := range []int{NoCompression, BestSpeed, BestCompression, DefaultCompression, HuffmanOnly} { + w, err := NewWriterLevel(io.Discard, level) + if err != nil { + t.Fatalf("failed to construct writer: %s", err) + } + _, err = w.Write(decompressed.Bytes()) + if err != nil { + t.Fatalf("failed to write: %s", err) + } + if err := w.Flush(); err != nil { + t.Fatalf("failed to flush: %s", err) + } + if err := w.Close(); err != nil { + t.Fatalf("failed to close: %s", err) + } + } + } + }) +} diff --git a/src/encoding/json/fuzz_test.go b/src/encoding/json/fuzz_test.go new file mode 100644 index 0000000000..778664c3e5 --- /dev/null +++ b/src/encoding/json/fuzz_test.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 json + +import ( + "bytes" + "io" + "testing" +) + +func FuzzUnmarshalJSON(f *testing.F) { + f.Add([]byte(`{ +"object": { + "slice": [ + 1, + 2.0, + "3", + [4], + {5: {}} + ] +}, +"slice": [[]], +"string": ":)", +"int": 1e5, +"float": 3e-9" +}`)) + + f.Fuzz(func(t *testing.T, b []byte) { + for _, typ := range []func() interface{}{ + func() interface{} { return new(interface{}) }, + func() interface{} { return new(map[string]interface{}) }, + func() interface{} { return new([]interface{}) }, + } { + i := typ() + if err := Unmarshal(b, i); err != nil { + return + } + + encoded, err := Marshal(i) + if err != nil { + t.Fatalf("failed to marshal: %s", err) + } + + if err := Unmarshal(encoded, i); err != nil { + t.Fatalf("failed to roundtrip: %s", err) + } + } + }) +} + +func FuzzDecoderToken(f *testing.F) { + f.Add([]byte(`{ +"object": { + "slice": [ + 1, + 2.0, + "3", + [4], + {5: {}} + ] +}, +"slice": [[]], +"string": ":)", +"int": 1e5, +"float": 3e-9" +}`)) + + f.Fuzz(func(t *testing.T, b []byte) { + r := bytes.NewReader(b) + d := NewDecoder(r) + for { + _, err := d.Token() + if err != nil { + if err == io.EOF { + break + } + return + } + } + }) +} diff --git a/src/image/gif/fuzz_test.go b/src/image/gif/fuzz_test.go new file mode 100644 index 0000000000..3ddf15d80f --- /dev/null +++ b/src/image/gif/fuzz_test.go @@ -0,0 +1,61 @@ +// 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 gif + +import ( + "bytes" + "image" + "os" + "path/filepath" + "strings" + "testing" +) + +func FuzzDecode(f *testing.F) { + testdata, err := os.ReadDir("../testdata") + if err != nil { + f.Fatalf("failed to read testdata directory: %s", err) + } + for _, de := range testdata { + if de.IsDir() || !strings.HasSuffix(de.Name(), ".gif") { + continue + } + b, err := os.ReadFile(filepath.Join("../testdata", de.Name())) + if err != nil { + f.Fatalf("failed to read testdata: %s", err) + } + f.Add(b) + } + + f.Fuzz(func(t *testing.T, b []byte) { + cfg, _, err := image.DecodeConfig(bytes.NewReader(b)) + if err != nil { + return + } + if cfg.Width*cfg.Height > 1e6 { + return + } + img, typ, err := image.Decode(bytes.NewReader(b)) + if err != nil || typ != "gif" { + return + } + for q := 1; q <= 256; q++ { + var w bytes.Buffer + err := Encode(&w, img, &Options{NumColors: q}) + if err != nil { + t.Fatalf("failed to encode valid image: %s", err) + } + img1, err := Decode(&w) + if err != nil { + t.Fatalf("failed to decode roundtripped image: %s", err) + } + got := img1.Bounds() + want := img.Bounds() + if !got.Eq(want) { + t.Fatalf("roundtripped image bounds have changed, got: %v, want: %v", got, want) + } + } + }) +} diff --git a/src/image/jpeg/fuzz_test.go b/src/image/jpeg/fuzz_test.go new file mode 100644 index 0000000000..716f06f43c --- /dev/null +++ b/src/image/jpeg/fuzz_test.go @@ -0,0 +1,61 @@ +// 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 jpeg + +import ( + "bytes" + "image" + "os" + "path/filepath" + "strings" + "testing" +) + +func FuzzDecode(f *testing.F) { + testdata, err := os.ReadDir("../testdata") + if err != nil { + f.Fatalf("failed to read testdata directory: %s", err) + } + for _, de := range testdata { + if de.IsDir() || !strings.HasSuffix(de.Name(), ".jpeg") { + continue + } + b, err := os.ReadFile(filepath.Join("../testdata", de.Name())) + if err != nil { + f.Fatalf("failed to read testdata: %s", err) + } + f.Add(b) + } + + f.Fuzz(func(t *testing.T, b []byte) { + cfg, _, err := image.DecodeConfig(bytes.NewReader(b)) + if err != nil { + return + } + if cfg.Width*cfg.Height > 1e6 { + return + } + img, typ, err := image.Decode(bytes.NewReader(b)) + if err != nil || typ != "jpeg" { + return + } + for q := 1; q <= 100; q++ { + var w bytes.Buffer + err := Encode(&w, img, &Options{Quality: q}) + if err != nil { + t.Fatalf("failed to encode valid image: %s", err) + } + img1, err := Decode(&w) + if err != nil { + t.Fatalf("failed to decode roundtripped image: %s", err) + } + got := img1.Bounds() + want := img.Bounds() + if !got.Eq(want) { + t.Fatalf("roundtripped image bounds have changed, got: %s, want: %s", got, want) + } + } + }) +} diff --git a/src/image/png/fuzz_test.go b/src/image/png/fuzz_test.go new file mode 100644 index 0000000000..22b3ef082a --- /dev/null +++ b/src/image/png/fuzz_test.go @@ -0,0 +1,68 @@ +// 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 png + +import ( + "bytes" + "image" + "os" + "path/filepath" + "strings" + "testing" +) + +func FuzzDecode(f *testing.F) { + testdata, err := os.ReadDir("../testdata") + if err != nil { + f.Fatalf("failed to read testdata directory: %s", err) + } + for _, de := range testdata { + if de.IsDir() || !strings.HasSuffix(de.Name(), ".png") { + continue + } + b, err := os.ReadFile(filepath.Join("../testdata", de.Name())) + if err != nil { + f.Fatalf("failed to read testdata: %s", err) + } + f.Add(b) + } + + f.Fuzz(func(t *testing.T, b []byte) { + cfg, _, err := image.DecodeConfig(bytes.NewReader(b)) + if err != nil { + return + } + if cfg.Width*cfg.Height > 1e6 { + return + } + img, typ, err := image.Decode(bytes.NewReader(b)) + if err != nil || typ != "png" { + return + } + levels := []CompressionLevel{ + DefaultCompression, + NoCompression, + BestSpeed, + BestCompression, + } + for _, l := range levels { + var w bytes.Buffer + e := &Encoder{CompressionLevel: l} + err = e.Encode(&w, img) + if err != nil { + t.Fatalf("failed to encode valid image: %s", err) + } + img1, err := Decode(&w) + if err != nil { + t.Fatalf("failed to decode roundtripped image: %s", err) + } + got := img1.Bounds() + want := img.Bounds() + if !got.Eq(want) { + t.Fatalf("roundtripped image bounds have changed, got: %s, want: %s", got, want) + } + } + }) +} From 3df44722013b54790e97a32aff945708bd1b62f7 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 7 Jan 2022 18:20:22 -0800 Subject: [PATCH 617/752] spec: adjust rules for specific types once more Introduce a (local) notion of a set of representative types, which serves as a representation/approximation of an interface's actual type set. If the set of representative types is is non-empty and finite, it corresponds to the set of specific types of the interface. In the implementation, the set of representative types serves as a finite representation of an interface's type set, together with the set of methods. Change-Id: Ib4c6cd5e17b81197672e4247be9737dd2cb6b56f Reviewed-on: https://go-review.googlesource.com/c/go/+/376834 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 28 +++++++++++++++++----------- 1 file changed, 17 insertions(+), 11 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index fa6630719b..7c20236016 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1,6 +1,6 @@ @@ -1980,30 +1980,34 @@ or in unions of such terms.

    -More precisely, for a given interface, the set 𝑆 of specific types is defined as follows: +More precisely, for a given interface, the set of specific types corresponds to +the set 𝑅 of representative types of the interface, if 𝑅 is non-empty and finite. +Otherwise, if 𝑅 is empty or infinite, the interface has no specific types. +

    + +

    +For a given interface, type element or type term, the set 𝑅 of representative types is defined as follows:

      -
    • For an interface with no type elements, 𝑆 is the empty set. +
    • For an interface with no type elements, 𝑅 is the (infinite) set of all types.
      • -
    • For an interface with type elements, 𝑆 is the intersection - of the specific types of its type elements with specific types - (type elements that have no specific types are ignored). +
    • For an interface with type elements, + 𝑅 is the intersection of the representative types of its type elements.
      • -
    • For a non-interface type term T - or ~T, 𝑆 is the set consisting of the type T. +
    • For a non-interface type term T or a term of the form ~T, + 𝑅 is the set consisting of the type T.
    • For a union of terms t1|t2|…|tn, - 𝑆 is the union of the specific types of the terms. + 𝑅 is the union of the representative types of the terms.

    -If 𝑆 is empty, the interface has no specific types. An interface may have specific types even if its type set is empty.

    @@ -2021,8 +2025,10 @@ interface{ int } // int interface{ ~string } // string interface{ int|~string } // int, string interface{ Celsius|Kelvin } // Celsius, Kelvin +interface{ float64|any } // no specific types (union is all types) interface{ int; m() } // int (but type set is empty because int has no method m) -interface{ int; any } // int (any has no specific types and is ignored) +interface{ ~int; m() } // int (but type set is infinite because many integer types have a method m) +interface{ int; any } // int interface{ int; string } // no specific types (intersection is empty) From 3d3f5d912b776424e50be276bc3a4ae02bf8d143 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 10 Jan 2022 17:29:21 -0800 Subject: [PATCH 618/752] go/types, types2: do not run CTI before FTI Until now, CTI (constraint type inference) was run before FTI (function type inference). This lead to situations where CTI infered a type that is missing necessary methods even though a function argument of correct type was given. This can happen when constraint type inference produces a inferred type that is the structural type of multiple types, which then is an underlying type, possibly without methods. This CL removes the initial CTI step; it is only applied after FTI with type arguments is run, and again after FTI with untyped arguments is run. Various comments are adjusted to reflect the new reality. Fixes #50426. Change-Id: I700ae6e762d7aa00d742943a2880f1a1db33c2b8 Reviewed-on: https://go-review.googlesource.com/c/go/+/377594 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/infer.go | 34 +++++--------- .../types2/testdata/fixedbugs/issue50426.go2 | 44 +++++++++++++++++++ src/go/types/infer.go | 34 +++++--------- .../types/testdata/fixedbugs/issue50426.go2 | 44 +++++++++++++++++++ 4 files changed, 112 insertions(+), 44 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50426.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50426.go2 diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go index b203985b8d..d4fb97453d 100644 --- a/src/cmd/compile/internal/types2/infer.go +++ b/src/cmd/compile/internal/types2/infer.go @@ -19,15 +19,17 @@ const useConstraintTypeInference = true // function arguments args, if any. There must be at least one type parameter, no more type arguments // than type parameters, and params and args must match in number (incl. zero). // If successful, infer returns the complete list of type arguments, one for each type parameter. -// Otherwise the result is nil and appropriate errors will be reported unless report is set to false. +// Otherwise the result is nil and appropriate errors will be reported. // -// Inference proceeds in 3 steps: +// Inference proceeds as follows: // -// 1) Start with given type arguments. -// 2) Infer type arguments from typed function arguments. -// 3) Infer type arguments from untyped function arguments. +// Starting with given type arguments +// 1) apply FTI (function type inference) with typed arguments, +// 2) apply CTI (constraint type inference), +// 3) apply FTI with untyped function arguments, +// 4) apply CTI. // -// Constraint type inference is used after each step to expand the set of type arguments. +// The process stops as soon as all type arguments are known or an error occurs. func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand) (result []Type) { if debug { defer func() { @@ -46,7 +48,6 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, // Function parameters and arguments must match in number. assert(params.Len() == len(args)) - // --- 0 --- // If we already have all type arguments, we're done. if len(targs) == n { return targs @@ -54,25 +55,13 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, // len(targs) < n // --- 1 --- - // Explicitly provided type arguments take precedence over any inferred types; - // and types inferred via constraint type inference take precedence over types - // inferred from function arguments. - // If we have type arguments, see how far we get with constraint type inference. - if len(targs) > 0 && useConstraintTypeInference { - var index int - targs, index = check.inferB(pos, tparams, targs) - if targs == nil || index < 0 { - return targs - } - } - - // Continue with the type arguments we have now. Avoid matching generic + // Continue with the type arguments we have. Avoid matching generic // parameters that already have type arguments against function arguments: // It may fail because matching uses type identity while parameter passing // uses assignment rules. Instantiate the parameter list with the type // arguments we have, and continue with that parameter list. - // First, make sure we have a "full" list of type arguments, so of which + // First, make sure we have a "full" list of type arguments, some of which // may be nil (unknown). if len(targs) < n { targs2 := make([]Type, n) @@ -90,7 +79,6 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, params = check.subst(nopos, params, smap, nil).(*Tuple) } - // --- 2 --- // Unify parameter and argument types for generic parameters with typed arguments // and collect the indices of generic parameters with untyped arguments. // Terminology: generic parameter = function parameter with a type-parameterized type @@ -167,6 +155,7 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, return targs } + // --- 2 --- // See how far we get with constraint type inference. // Note that even if we don't have any type arguments, constraint type inference // may produce results for constraints that explicitly specify a type. @@ -207,6 +196,7 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, return targs } + // --- 4 --- // Again, follow up with constraint type inference. if useConstraintTypeInference { targs, index = check.inferB(pos, tparams, targs) diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50426.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50426.go2 new file mode 100644 index 0000000000..17ec0ce529 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50426.go2 @@ -0,0 +1,44 @@ +// Copyright 2022 The Go 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 A1 [2]uint64 +type A2 [2]uint64 + +func (a A1) m() A1 { return a } +func (a A2) m() A2 { return a } + +func f[B any, T interface { + A1 | A2 + m() T +}](v T) { +} + +func _() { + var v A2 + // Use function type inference to infer type A2 for T. + // Don't use constraint type inference before function + // type inference for typed arguments, otherwise it would + // infer type [2]uint64 for T which doesn't have method m + // (was the bug). + f[int](v) +} + +// Keep using constraint type inference before function type +// inference for untyped arguments so we infer type float64 +// for E below, and not int (which would not work). +func g[S ~[]E, E any](S, E) {} + +func _() { + var s []float64 + g[[]float64](s, 0) +} + +// Keep using constraint type inference after function +// type inference for untyped arguments so we infer +// missing type arguments for which we only have the +// untyped arguments as starting point. +func h[E any, R []E](v E) R { return R{v} } +func _() []int { return h(0) } diff --git a/src/go/types/infer.go b/src/go/types/infer.go index a5088f2705..e139e45fff 100644 --- a/src/go/types/infer.go +++ b/src/go/types/infer.go @@ -18,15 +18,17 @@ import ( // function arguments args, if any. There must be at least one type parameter, no more type arguments // than type parameters, and params and args must match in number (incl. zero). // If successful, infer returns the complete list of type arguments, one for each type parameter. -// Otherwise the result is nil and appropriate errors will be reported unless report is set to false. +// Otherwise the result is nil and appropriate errors will be reported. // -// Inference proceeds in 3 steps: +// Inference proceeds as follows: // -// 1) Start with given type arguments. -// 2) Infer type arguments from typed function arguments. -// 3) Infer type arguments from untyped function arguments. +// Starting with given type arguments +// 1) apply FTI (function type inference) with typed arguments, +// 2) apply CTI (constraint type inference), +// 3) apply FTI with untyped function arguments, +// 4) apply CTI. // -// Constraint type inference is used after each step to expand the set of type arguments. +// The process stops as soon as all type arguments are known or an error occurs. func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand) (result []Type) { if debug { defer func() { @@ -45,7 +47,6 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, // Function parameters and arguments must match in number. assert(params.Len() == len(args)) - // --- 0 --- // If we already have all type arguments, we're done. if len(targs) == n { return targs @@ -53,25 +54,13 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, // len(targs) < n // --- 1 --- - // Explicitly provided type arguments take precedence over any inferred types; - // and types inferred via constraint type inference take precedence over types - // inferred from function arguments. - // If we have type arguments, see how far we get with constraint type inference. - if len(targs) > 0 { - var index int - targs, index = check.inferB(posn, tparams, targs) - if targs == nil || index < 0 { - return targs - } - } - - // Continue with the type arguments we have now. Avoid matching generic + // Continue with the type arguments we have. Avoid matching generic // parameters that already have type arguments against function arguments: // It may fail because matching uses type identity while parameter passing // uses assignment rules. Instantiate the parameter list with the type // arguments we have, and continue with that parameter list. - // First, make sure we have a "full" list of type arguments, so of which + // First, make sure we have a "full" list of type arguments, some of which // may be nil (unknown). if len(targs) < n { targs2 := make([]Type, n) @@ -89,7 +78,6 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, params = check.subst(token.NoPos, params, smap, nil).(*Tuple) } - // --- 2 --- // Unify parameter and argument types for generic parameters with typed arguments // and collect the indices of generic parameters with untyped arguments. // Terminology: generic parameter = function parameter with a type-parameterized type @@ -171,6 +159,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, return targs } + // --- 2 --- // See how far we get with constraint type inference. // Note that even if we don't have any type arguments, constraint type inference // may produce results for constraints that explicitly specify a type. @@ -209,6 +198,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, return targs } + // --- 4 --- // Again, follow up with constraint type inference. targs, index = check.inferB(posn, tparams, targs) if targs == nil || index < 0 { diff --git a/src/go/types/testdata/fixedbugs/issue50426.go2 b/src/go/types/testdata/fixedbugs/issue50426.go2 new file mode 100644 index 0000000000..17ec0ce529 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50426.go2 @@ -0,0 +1,44 @@ +// Copyright 2022 The Go 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 A1 [2]uint64 +type A2 [2]uint64 + +func (a A1) m() A1 { return a } +func (a A2) m() A2 { return a } + +func f[B any, T interface { + A1 | A2 + m() T +}](v T) { +} + +func _() { + var v A2 + // Use function type inference to infer type A2 for T. + // Don't use constraint type inference before function + // type inference for typed arguments, otherwise it would + // infer type [2]uint64 for T which doesn't have method m + // (was the bug). + f[int](v) +} + +// Keep using constraint type inference before function type +// inference for untyped arguments so we infer type float64 +// for E below, and not int (which would not work). +func g[S ~[]E, E any](S, E) {} + +func _() { + var s []float64 + g[[]float64](s, 0) +} + +// Keep using constraint type inference after function +// type inference for untyped arguments so we infer +// missing type arguments for which we only have the +// untyped arguments as starting point. +func h[E any, R []E](v E) R { return R{v} } +func _() []int { return h(0) } From 6e8b7e4f4213afb67a91050cb2d71347d73145aa Mon Sep 17 00:00:00 2001 From: Bryan Mills Date: Wed, 12 Jan 2022 02:22:10 +0000 Subject: [PATCH 619/752] Revert "all: add a handful of fuzz targets" This reverts CL 352109. Reason for revert: causing OOM failures on several builders, and may cause OOMs for end users with small machines as well. Change-Id: I58308d09919969d5a6512ee5cee6aa5c4af6769b Reviewed-on: https://go-review.googlesource.com/c/go/+/377934 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Katie Hockman Trust: Katie Hockman --- src/archive/tar/fuzz_test.go | 97 ---------------------------------- src/archive/zip/fuzz_test.go | 81 ---------------------------- src/compress/gzip/fuzz_test.go | 92 -------------------------------- src/encoding/json/fuzz_test.go | 83 ----------------------------- src/image/gif/fuzz_test.go | 61 --------------------- src/image/jpeg/fuzz_test.go | 61 --------------------- src/image/png/fuzz_test.go | 68 ------------------------ 7 files changed, 543 deletions(-) delete mode 100644 src/archive/tar/fuzz_test.go delete mode 100644 src/archive/zip/fuzz_test.go delete mode 100644 src/compress/gzip/fuzz_test.go delete mode 100644 src/encoding/json/fuzz_test.go delete mode 100644 src/image/gif/fuzz_test.go delete mode 100644 src/image/jpeg/fuzz_test.go delete mode 100644 src/image/png/fuzz_test.go diff --git a/src/archive/tar/fuzz_test.go b/src/archive/tar/fuzz_test.go deleted file mode 100644 index 069602aa21..0000000000 --- a/src/archive/tar/fuzz_test.go +++ /dev/null @@ -1,97 +0,0 @@ -// 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. - -//go:build !android -// +build !android - -package tar - -import ( - "bytes" - "internal/testenv" - "io" - "os" - "path/filepath" - "strings" - "testing" -) - -var constrainedBuilders = map[string]bool{ - "windows-386-2012": true, - "windows-386-2008": true, - "js-wasm": true, - "android-amd64-emu": true, -} - -func FuzzReader(f *testing.F) { - if constrainedBuilders[testenv.Builder()] { - f.Skip("builder is memory constrained") - } - testdata, err := os.ReadDir("testdata") - if err != nil { - f.Fatalf("failed to read testdata directory: %s", err) - } - for _, de := range testdata { - if de.IsDir() { - continue - } - if strings.Contains(de.Name(), "big") { - // skip large archives so we don't kill builders with restricted - // memory - continue - } - b, err := os.ReadFile(filepath.Join("testdata", de.Name())) - if err != nil { - f.Fatalf("failed to read testdata: %s", err) - } - f.Add(b) - } - - f.Fuzz(func(t *testing.T, b []byte) { - r := NewReader(bytes.NewReader(b)) - type file struct { - header *Header - content []byte - } - files := []file{} - for { - hdr, err := r.Next() - if err == io.EOF { - break - } - if err != nil { - return - } - buf := bytes.NewBuffer(nil) - if _, err := io.Copy(buf, r); err != nil { - continue - } - files = append(files, file{header: hdr, content: buf.Bytes()}) - } - - // If we were unable to read anything out of the archive don't - // bother trying to roundtrip it. - if len(files) == 0 { - return - } - - out := bytes.NewBuffer(nil) - w := NewWriter(out) - for _, f := range files { - if err := w.WriteHeader(f.header); err != nil { - t.Fatalf("unable to write previously parsed header: %s", err) - } - if _, err := w.Write(f.content); err != nil { - t.Fatalf("unable to write previously parsed content: %s", err) - } - } - if err := w.Close(); err != nil { - t.Fatalf("Unable to write archive: %s", err) - } - - // TODO: We may want to check if the archive roundtrips. This would require - // taking into account addition of the two zero trailer blocks that Writer.Close - // appends. - }) -} diff --git a/src/archive/zip/fuzz_test.go b/src/archive/zip/fuzz_test.go deleted file mode 100644 index 7dffde69bf..0000000000 --- a/src/archive/zip/fuzz_test.go +++ /dev/null @@ -1,81 +0,0 @@ -// 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 zip - -import ( - "bytes" - "io" - "os" - "path/filepath" - "testing" -) - -func FuzzReader(f *testing.F) { - testdata, err := os.ReadDir("testdata") - if err != nil { - f.Fatalf("failed to read testdata directory: %s", err) - } - for _, de := range testdata { - if de.IsDir() { - continue - } - b, err := os.ReadFile(filepath.Join("testdata", de.Name())) - if err != nil { - f.Fatalf("failed to read testdata: %s", err) - } - f.Add(b) - } - - f.Fuzz(func(t *testing.T, b []byte) { - r, err := NewReader(bytes.NewReader(b), int64(len(b))) - if err != nil { - return - } - - type file struct { - header *FileHeader - content []byte - } - files := []file{} - - for _, f := range r.File { - fr, err := f.Open() - if err != nil { - continue - } - content, err := io.ReadAll(fr) - if err != nil { - continue - } - files = append(files, file{header: &f.FileHeader, content: content}) - if _, err := r.Open(f.Name); err != nil { - continue - } - } - - // If we were unable to read anything out of the archive don't - // bother trying to roundtrip it. - if len(files) == 0 { - return - } - - w := NewWriter(io.Discard) - for _, f := range files { - ww, err := w.CreateHeader(f.header) - if err != nil { - t.Fatalf("unable to write previously parsed header: %s", err) - } - if _, err := ww.Write(f.content); err != nil { - t.Fatalf("unable to write previously parsed content: %s", err) - } - } - - if err := w.Close(); err != nil { - t.Fatalf("Unable to write archive: %s", err) - } - - // TODO: We may want to check if the archive roundtrips. - }) -} diff --git a/src/compress/gzip/fuzz_test.go b/src/compress/gzip/fuzz_test.go deleted file mode 100644 index 80d803ce93..0000000000 --- a/src/compress/gzip/fuzz_test.go +++ /dev/null @@ -1,92 +0,0 @@ -// 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 gzip - -import ( - "bytes" - "encoding/base64" - "io" - "os" - "path/filepath" - "strings" - "testing" -) - -func FuzzReader(f *testing.F) { - inp := []byte("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.") - for _, level := range []int{BestSpeed, BestCompression, DefaultCompression, HuffmanOnly} { - b := bytes.NewBuffer(nil) - w, err := NewWriterLevel(b, level) - if err != nil { - f.Fatalf("failed to construct writer: %s", err) - } - _, err = w.Write(inp) - if err != nil { - f.Fatalf("failed to write: %s", err) - } - f.Add(b.Bytes()) - } - - testdata, err := os.ReadDir("testdata") - if err != nil { - f.Fatalf("failed to read testdata directory: %s", err) - } - for _, de := range testdata { - if de.IsDir() { - continue - } - b, err := os.ReadFile(filepath.Join("testdata", de.Name())) - if err != nil { - f.Fatalf("failed to read testdata: %s", err) - } - - // decode any base64 encoded test files - if strings.HasPrefix(de.Name(), ".base64") { - b, err = base64.StdEncoding.DecodeString(string(b)) - if err != nil { - f.Fatalf("failed to decode base64 testdata: %s", err) - } - } - - f.Add(b) - } - - f.Fuzz(func(t *testing.T, b []byte) { - for _, multistream := range []bool{true, false} { - r, err := NewReader(bytes.NewBuffer(b)) - if err != nil { - continue - } - - r.Multistream(multistream) - - decompressed := bytes.NewBuffer(nil) - if _, err := io.Copy(decompressed, r); err != nil { - continue - } - - if err := r.Close(); err != nil { - continue - } - - for _, level := range []int{NoCompression, BestSpeed, BestCompression, DefaultCompression, HuffmanOnly} { - w, err := NewWriterLevel(io.Discard, level) - if err != nil { - t.Fatalf("failed to construct writer: %s", err) - } - _, err = w.Write(decompressed.Bytes()) - if err != nil { - t.Fatalf("failed to write: %s", err) - } - if err := w.Flush(); err != nil { - t.Fatalf("failed to flush: %s", err) - } - if err := w.Close(); err != nil { - t.Fatalf("failed to close: %s", err) - } - } - } - }) -} diff --git a/src/encoding/json/fuzz_test.go b/src/encoding/json/fuzz_test.go deleted file mode 100644 index 778664c3e5..0000000000 --- a/src/encoding/json/fuzz_test.go +++ /dev/null @@ -1,83 +0,0 @@ -// 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 json - -import ( - "bytes" - "io" - "testing" -) - -func FuzzUnmarshalJSON(f *testing.F) { - f.Add([]byte(`{ -"object": { - "slice": [ - 1, - 2.0, - "3", - [4], - {5: {}} - ] -}, -"slice": [[]], -"string": ":)", -"int": 1e5, -"float": 3e-9" -}`)) - - f.Fuzz(func(t *testing.T, b []byte) { - for _, typ := range []func() interface{}{ - func() interface{} { return new(interface{}) }, - func() interface{} { return new(map[string]interface{}) }, - func() interface{} { return new([]interface{}) }, - } { - i := typ() - if err := Unmarshal(b, i); err != nil { - return - } - - encoded, err := Marshal(i) - if err != nil { - t.Fatalf("failed to marshal: %s", err) - } - - if err := Unmarshal(encoded, i); err != nil { - t.Fatalf("failed to roundtrip: %s", err) - } - } - }) -} - -func FuzzDecoderToken(f *testing.F) { - f.Add([]byte(`{ -"object": { - "slice": [ - 1, - 2.0, - "3", - [4], - {5: {}} - ] -}, -"slice": [[]], -"string": ":)", -"int": 1e5, -"float": 3e-9" -}`)) - - f.Fuzz(func(t *testing.T, b []byte) { - r := bytes.NewReader(b) - d := NewDecoder(r) - for { - _, err := d.Token() - if err != nil { - if err == io.EOF { - break - } - return - } - } - }) -} diff --git a/src/image/gif/fuzz_test.go b/src/image/gif/fuzz_test.go deleted file mode 100644 index 3ddf15d80f..0000000000 --- a/src/image/gif/fuzz_test.go +++ /dev/null @@ -1,61 +0,0 @@ -// 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 gif - -import ( - "bytes" - "image" - "os" - "path/filepath" - "strings" - "testing" -) - -func FuzzDecode(f *testing.F) { - testdata, err := os.ReadDir("../testdata") - if err != nil { - f.Fatalf("failed to read testdata directory: %s", err) - } - for _, de := range testdata { - if de.IsDir() || !strings.HasSuffix(de.Name(), ".gif") { - continue - } - b, err := os.ReadFile(filepath.Join("../testdata", de.Name())) - if err != nil { - f.Fatalf("failed to read testdata: %s", err) - } - f.Add(b) - } - - f.Fuzz(func(t *testing.T, b []byte) { - cfg, _, err := image.DecodeConfig(bytes.NewReader(b)) - if err != nil { - return - } - if cfg.Width*cfg.Height > 1e6 { - return - } - img, typ, err := image.Decode(bytes.NewReader(b)) - if err != nil || typ != "gif" { - return - } - for q := 1; q <= 256; q++ { - var w bytes.Buffer - err := Encode(&w, img, &Options{NumColors: q}) - if err != nil { - t.Fatalf("failed to encode valid image: %s", err) - } - img1, err := Decode(&w) - if err != nil { - t.Fatalf("failed to decode roundtripped image: %s", err) - } - got := img1.Bounds() - want := img.Bounds() - if !got.Eq(want) { - t.Fatalf("roundtripped image bounds have changed, got: %v, want: %v", got, want) - } - } - }) -} diff --git a/src/image/jpeg/fuzz_test.go b/src/image/jpeg/fuzz_test.go deleted file mode 100644 index 716f06f43c..0000000000 --- a/src/image/jpeg/fuzz_test.go +++ /dev/null @@ -1,61 +0,0 @@ -// 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 jpeg - -import ( - "bytes" - "image" - "os" - "path/filepath" - "strings" - "testing" -) - -func FuzzDecode(f *testing.F) { - testdata, err := os.ReadDir("../testdata") - if err != nil { - f.Fatalf("failed to read testdata directory: %s", err) - } - for _, de := range testdata { - if de.IsDir() || !strings.HasSuffix(de.Name(), ".jpeg") { - continue - } - b, err := os.ReadFile(filepath.Join("../testdata", de.Name())) - if err != nil { - f.Fatalf("failed to read testdata: %s", err) - } - f.Add(b) - } - - f.Fuzz(func(t *testing.T, b []byte) { - cfg, _, err := image.DecodeConfig(bytes.NewReader(b)) - if err != nil { - return - } - if cfg.Width*cfg.Height > 1e6 { - return - } - img, typ, err := image.Decode(bytes.NewReader(b)) - if err != nil || typ != "jpeg" { - return - } - for q := 1; q <= 100; q++ { - var w bytes.Buffer - err := Encode(&w, img, &Options{Quality: q}) - if err != nil { - t.Fatalf("failed to encode valid image: %s", err) - } - img1, err := Decode(&w) - if err != nil { - t.Fatalf("failed to decode roundtripped image: %s", err) - } - got := img1.Bounds() - want := img.Bounds() - if !got.Eq(want) { - t.Fatalf("roundtripped image bounds have changed, got: %s, want: %s", got, want) - } - } - }) -} diff --git a/src/image/png/fuzz_test.go b/src/image/png/fuzz_test.go deleted file mode 100644 index 22b3ef082a..0000000000 --- a/src/image/png/fuzz_test.go +++ /dev/null @@ -1,68 +0,0 @@ -// 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 png - -import ( - "bytes" - "image" - "os" - "path/filepath" - "strings" - "testing" -) - -func FuzzDecode(f *testing.F) { - testdata, err := os.ReadDir("../testdata") - if err != nil { - f.Fatalf("failed to read testdata directory: %s", err) - } - for _, de := range testdata { - if de.IsDir() || !strings.HasSuffix(de.Name(), ".png") { - continue - } - b, err := os.ReadFile(filepath.Join("../testdata", de.Name())) - if err != nil { - f.Fatalf("failed to read testdata: %s", err) - } - f.Add(b) - } - - f.Fuzz(func(t *testing.T, b []byte) { - cfg, _, err := image.DecodeConfig(bytes.NewReader(b)) - if err != nil { - return - } - if cfg.Width*cfg.Height > 1e6 { - return - } - img, typ, err := image.Decode(bytes.NewReader(b)) - if err != nil || typ != "png" { - return - } - levels := []CompressionLevel{ - DefaultCompression, - NoCompression, - BestSpeed, - BestCompression, - } - for _, l := range levels { - var w bytes.Buffer - e := &Encoder{CompressionLevel: l} - err = e.Encode(&w, img) - if err != nil { - t.Fatalf("failed to encode valid image: %s", err) - } - img1, err := Decode(&w) - if err != nil { - t.Fatalf("failed to decode roundtripped image: %s", err) - } - got := img1.Bounds() - want := img.Bounds() - if !got.Eq(want) { - t.Fatalf("roundtripped image bounds have changed, got: %s, want: %s", got, want) - } - } - }) -} From 83bfdb6561c06bd890446af01b0f0c735360a8df Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Wed, 12 Jan 2022 09:54:19 -0500 Subject: [PATCH 620/752] go/ast: mention that FieldLists can now be enclosed by brackets Type parameter lists are stored using ast.FieldLists. Update the documentation to reflect that the enclosing delimiter may be a bracket. Change-Id: Id103e7b38975e94a1b521f75695edc10408ad3dd Reviewed-on: https://go-review.googlesource.com/c/go/+/378014 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/go/ast/ast.go | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/go/ast/ast.go b/src/go/ast/ast.go index bc140473d5..a74a827c8f 100644 --- a/src/go/ast/ast.go +++ b/src/go/ast/ast.go @@ -224,11 +224,12 @@ func (f *Field) End() token.Pos { return token.NoPos } -// A FieldList represents a list of Fields, enclosed by parentheses or braces. +// A FieldList represents a list of Fields, enclosed by parentheses, +// curly braces, or square brackets. type FieldList struct { - Opening token.Pos // position of opening parenthesis/brace, if any + Opening token.Pos // position of opening parenthesis/brace/bracket, if any List []*Field // field list; or nil - Closing token.Pos // position of closing parenthesis/brace, if any + Closing token.Pos // position of closing parenthesis/brace/bracket, if any } func (f *FieldList) Pos() token.Pos { From 68b3d36ff4e71d68f25d36caff8b4ba2b3b9c980 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 11 Jan 2022 15:36:38 -0800 Subject: [PATCH 621/752] go/types, types2: make function type inference argument-order independent If we have more than 2 arguments, we may have arguments with named and unnamed types. If that is the case, permutate params and args such that the arguments with named types are first in the list. This doesn't affect type inference if all types are taken as is. But when we have inexact unification enabled (as is the case for function type inference), when a named type is unified with an unnamed type, unification proceeds with the underlying type of the named type because otherwise unification would fail right away. This leads to an asymmetry in type inference: in cases where arguments of named and unnamed types are passed to parameters with identical type, different types (named vs underlying) may be inferred depending on the order of the arguments. By ensuring that named types are seen first, order dependence is avoided and unification succeeds where it can. This CL implements the respectice code but keeps it disabled for now, pending decision whether we want to address this issue in the first place. For #43056. Change-Id: Ibe3b08ec2afe90a24a8c30cd1875d504bcc2ef39 Reviewed-on: https://go-review.googlesource.com/c/go/+/377894 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/infer.go | 50 ++++++++++++++++++- .../types2/testdata/fixedbugs/issue43056.go2 | 31 ++++++++++++ src/go/types/infer.go | 50 ++++++++++++++++++- .../types/testdata/fixedbugs/issue43056.go2 | 31 ++++++++++++ 4 files changed, 160 insertions(+), 2 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue43056.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue43056.go2 diff --git a/src/cmd/compile/internal/types2/infer.go b/src/cmd/compile/internal/types2/infer.go index d4fb97453d..51d0d22144 100644 --- a/src/cmd/compile/internal/types2/infer.go +++ b/src/cmd/compile/internal/types2/infer.go @@ -54,6 +54,54 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, } // len(targs) < n + // If we have more than 2 arguments, we may have arguments with named and unnamed types. + // If that is the case, permutate params and args such that the arguments with named + // types are first in the list. This doesn't affect type inference if all types are taken + // as is. But when we have inexact unification enabled (as is the case for function type + // inference), when a named type is unified with an unnamed type, unification proceeds + // with the underlying type of the named type because otherwise unification would fail + // right away. This leads to an asymmetry in type inference: in cases where arguments of + // named and unnamed types are passed to parameters with identical type, different types + // (named vs underlying) may be inferred depending on the order of the arguments. + // By ensuring that named types are seen first, order dependence is avoided and unification + // succeeds where it can. + // + // This code is disabled for now pending decision whether we want to address cases like + // these and make the spec on type inference more complicated (see issue #43056). + const enableArgSorting = false + if m := len(args); m >= 2 && enableArgSorting { + // Determine indices of arguments with named and unnamed types. + var named, unnamed []int + for i, arg := range args { + if hasName(arg.typ) { + named = append(named, i) + } else { + unnamed = append(unnamed, i) + } + } + + // If we have named and unnamed types, move the arguments with + // named types first. Update the parameter list accordingly. + // Make copies so as not to clobber the incoming slices. + if len(named) != 0 && len(unnamed) != 0 { + params2 := make([]*Var, m) + args2 := make([]*operand, m) + i := 0 + for _, j := range named { + params2[i] = params.At(j) + args2[i] = args[j] + i++ + } + for _, j := range unnamed { + params2[i] = params.At(j) + args2[i] = args[j] + i++ + } + params = NewTuple(params2...) + args = args2 + } + } + // --- 1 --- // Continue with the type arguments we have. Avoid matching generic // parameters that already have type arguments against function arguments: @@ -62,7 +110,7 @@ func (check *Checker) infer(pos syntax.Pos, tparams []*TypeParam, targs []Type, // arguments we have, and continue with that parameter list. // First, make sure we have a "full" list of type arguments, some of which - // may be nil (unknown). + // may be nil (unknown). Make a copy so as to not clobber the incoming slice. if len(targs) < n { targs2 := make([]Type, n) copy(targs2, targs) diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43056.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43056.go2 new file mode 100644 index 0000000000..35c7ef592d --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue43056.go2 @@ -0,0 +1,31 @@ +// Copyright 2022 The Go 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 + +// simplified example +func f[T ~func(T)](a, b T) {} + +type F func(F) + +func _() { + var i F + var j func(F) + + f(i, j) + // f(j, i) // disabled for now +} + +// example from issue +func g[T interface{ Equal(T) bool }](a, b T) {} + +type I interface{ Equal(I) bool } + +func _() { + var i I + var j interface{ Equal(I) bool } + + g(i, j) + // g(j, i) // disabled for now +} diff --git a/src/go/types/infer.go b/src/go/types/infer.go index e139e45fff..2678da3bf5 100644 --- a/src/go/types/infer.go +++ b/src/go/types/infer.go @@ -53,6 +53,54 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, } // len(targs) < n + // If we have more than 2 arguments, we may have arguments with named and unnamed types. + // If that is the case, permutate params and args such that the arguments with named + // types are first in the list. This doesn't affect type inference if all types are taken + // as is. But when we have inexact unification enabled (as is the case for function type + // inference), when a named type is unified with an unnamed type, unification proceeds + // with the underlying type of the named type because otherwise unification would fail + // right away. This leads to an asymmetry in type inference: in cases where arguments of + // named and unnamed types are passed to parameters with identical type, different types + // (named vs underlying) may be inferred depending on the order of the arguments. + // By ensuring that named types are seen first, order dependence is avoided and unification + // succeeds where it can. + // + // This code is disabled for now pending decision whether we want to address cases like + // these and make the spec on type inference more complicated (see issue #43056). + const enableArgSorting = false + if m := len(args); m >= 2 && enableArgSorting { + // Determine indices of arguments with named and unnamed types. + var named, unnamed []int + for i, arg := range args { + if hasName(arg.typ) { + named = append(named, i) + } else { + unnamed = append(unnamed, i) + } + } + + // If we have named and unnamed types, move the arguments with + // named types first. Update the parameter list accordingly. + // Make copies so as not to clobber the incoming slices. + if len(named) != 0 && len(unnamed) != 0 { + params2 := make([]*Var, m) + args2 := make([]*operand, m) + i := 0 + for _, j := range named { + params2[i] = params.At(j) + args2[i] = args[j] + i++ + } + for _, j := range unnamed { + params2[i] = params.At(j) + args2[i] = args[j] + i++ + } + params = NewTuple(params2...) + args = args2 + } + } + // --- 1 --- // Continue with the type arguments we have. Avoid matching generic // parameters that already have type arguments against function arguments: @@ -61,7 +109,7 @@ func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, // arguments we have, and continue with that parameter list. // First, make sure we have a "full" list of type arguments, some of which - // may be nil (unknown). + // may be nil (unknown). Make a copy so as to not clobber the incoming slice. if len(targs) < n { targs2 := make([]Type, n) copy(targs2, targs) diff --git a/src/go/types/testdata/fixedbugs/issue43056.go2 b/src/go/types/testdata/fixedbugs/issue43056.go2 new file mode 100644 index 0000000000..35c7ef592d --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue43056.go2 @@ -0,0 +1,31 @@ +// Copyright 2022 The Go 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 + +// simplified example +func f[T ~func(T)](a, b T) {} + +type F func(F) + +func _() { + var i F + var j func(F) + + f(i, j) + // f(j, i) // disabled for now +} + +// example from issue +func g[T interface{ Equal(T) bool }](a, b T) {} + +type I interface{ Equal(I) bool } + +func _() { + var i I + var j interface{ Equal(I) bool } + + g(i, j) + // g(j, i) // disabled for now +} From deb45802a4384ea3c7c3434113fb64a57a494cb2 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 11 Jan 2022 20:55:56 -0800 Subject: [PATCH 622/752] go/types, types2: prevent unification from recursing endlessly This is a stop gap solution to avoid panics due to stack overflow during type unification. While this doesn't address the underlying issues (for which we are still investigating the correct approach), it prevents a panic during compilation and reports a (possibly not quite correct) error message. If the programs are correct in the first place, manually providing the desired type arguments is a viable work-around, resulting in code that will continue to work even when the issues here are fixed satisfactorily. For #48619. For #48656. Change-Id: I13bb14552b38b4170b5a1b820e3172d88ff656ec Reviewed-on: https://go-review.googlesource.com/c/go/+/377954 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley --- .../types2/testdata/fixedbugs/issue48619.go2 | 25 +++++++++++-------- .../types2/testdata/fixedbugs/issue48656.go2 | 11 +++++--- src/cmd/compile/internal/types2/unify.go | 17 +++++++++++++ .../types/testdata/fixedbugs/issue48619.go2 | 25 +++++++++++-------- .../types/testdata/fixedbugs/issue48656.go2 | 11 +++++--- src/go/types/unify.go | 17 +++++++++++++ 6 files changed, 76 insertions(+), 30 deletions(-) diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48619.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48619.go2 index 870bacd0bd..3d4f1b4707 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48619.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48619.go2 @@ -2,23 +2,26 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// This issue has been re-opened. +// This issue is still open: +// - the error messages could be better or are incorrect +// - unification fails due to stack overflow that is caught package p func f[P any](a, _ P) { - // var x int - // f(a, x /* ERROR type int of x does not match P */) - // f(x, a /* ERROR type P of a does not match inferred type int for P */) + var x int + // TODO(gri) these error messages, while correct, could be better + f(a, x /* ERROR type int of x does not match P */) + f(x, a /* ERROR type P of a does not match inferred type int for P */) } func g[P any](a, b P) { - // g(a, b) - // g(&a, &b) - // g([]P{}, []P{}) -} + g(a, b) + // TODO(gri) these error messages are incorrect because the code is valid + g(&a, & /* ERROR type \*P of &b does not match inferred type \*P for P */ b) + g([]P{}, [ /* ERROR type \[\]P of \[\]P{} does not match inferred type \[\]P for P */ ]P{}) -func h[P any](a, b P) { - // h(&a, &b) - // h([]P{a}, []P{b}) + // work-around: provide type argument explicitly + g[*P](&a, &b) + g[[]P]([]P{}, []P{}) } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48656.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48656.go2 index 652f8ce37a..bea3dc14a0 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48656.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48656.go2 @@ -2,11 +2,14 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// This issue is still open. +// This issue is still open: +// - the error messages are unclear +// - unification fails due to stack overflow that is caught package p -func f[P *Q, Q any](p P, q Q) { - // _ = f[P] - // _ = f[/* ERROR cannot infer P */ *P] +func f[P *Q, Q any](P, Q) { + // TODO(gri) these error messages are unclear + _ = f[ /* ERROR P does not match \*Q */ P] + _ = f[ /* ERROR cannot infer P */ *P] } diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go index f663beec38..8762bae559 100644 --- a/src/cmd/compile/internal/types2/unify.go +++ b/src/cmd/compile/internal/types2/unify.go @@ -33,6 +33,10 @@ import ( // by setting up one of them (using init) and then assigning its value // to the other. +// Upper limit for recursion depth. Used to catch infinite recursions +// due to implementation issues (e.g., see issues #48619, #48656). +const unificationDepthLimit = 50 + // A unifier maintains the current type parameters for x and y // and the respective types inferred for each type parameter. // A unifier is created by calling newUnifier. @@ -40,6 +44,7 @@ type unifier struct { exact bool x, y tparamsList // x and y must initialized via tparamsList.init types []Type // inferred types, shared by x and y + depth int // recursion depth during unification } // newUnifier returns a new unifier. @@ -237,6 +242,18 @@ func (u *unifier) nifyEq(x, y Type, p *ifacePair) bool { // code the corresponding changes should be made here. // Must not be called directly from outside the unifier. func (u *unifier) nify(x, y Type, p *ifacePair) bool { + // Stop gap for cases where unification fails. + if u.depth >= unificationDepthLimit { + if debug { + panic("unification reached recursion depth limit") + } + return false + } + u.depth++ + defer func() { + u.depth-- + }() + if !u.exact { // If exact unification is known to fail because we attempt to // match a type name against an unnamed type literal, consider diff --git a/src/go/types/testdata/fixedbugs/issue48619.go2 b/src/go/types/testdata/fixedbugs/issue48619.go2 index 870bacd0bd..d33040d78f 100644 --- a/src/go/types/testdata/fixedbugs/issue48619.go2 +++ b/src/go/types/testdata/fixedbugs/issue48619.go2 @@ -2,23 +2,26 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// This issue has been re-opened. +// This issue is still open: +// - the error messages could be better or are incorrect +// - unification fails due to stack overflow that is caught package p func f[P any](a, _ P) { - // var x int - // f(a, x /* ERROR type int of x does not match P */) - // f(x, a /* ERROR type P of a does not match inferred type int for P */) + var x int + // TODO(gri) these error messages, while correct, could be better + f(a, x /* ERROR type int of x does not match P */) + f(x, a /* ERROR type P of a does not match inferred type int for P */) } func g[P any](a, b P) { - // g(a, b) - // g(&a, &b) - // g([]P{}, []P{}) -} + g(a, b) + // TODO(gri) these error messages are incorrect because the code is valid + g(&a, & /* ERROR type \*P of &b does not match inferred type \*P for P */ b) + g([]P{}, [ /* ERROR type \[\]P of \(\[\]P literal\) does not match inferred type \[\]P for P */ ]P{}) -func h[P any](a, b P) { - // h(&a, &b) - // h([]P{a}, []P{b}) + // work-around: provide type argument explicitly + g[*P](&a, &b) + g[[]P]([]P{}, []P{}) } diff --git a/src/go/types/testdata/fixedbugs/issue48656.go2 b/src/go/types/testdata/fixedbugs/issue48656.go2 index 52863d446b..493f220e98 100644 --- a/src/go/types/testdata/fixedbugs/issue48656.go2 +++ b/src/go/types/testdata/fixedbugs/issue48656.go2 @@ -2,11 +2,14 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// This issue is still open. +// This issue is still open: +// - the error messages are unclear +// - unification fails due to stack overflow that is caught package p -func f[P interface{*Q}, Q any](p P, q Q) { - // _ = f[P] - // _ = f[/* ERROR cannot infer P */ *P] +func f[P *Q, Q any](P, Q) { + // TODO(gri) these error messages are unclear + _ = f /* ERROR P does not match \*Q */ [P] + _ = f /* ERROR cannot infer P */ [*P] } diff --git a/src/go/types/unify.go b/src/go/types/unify.go index 5dcb35f6ec..ad6d316227 100644 --- a/src/go/types/unify.go +++ b/src/go/types/unify.go @@ -33,6 +33,10 @@ import ( // by setting up one of them (using init) and then assigning its value // to the other. +// Upper limit for recursion depth. Used to catch infinite recursions +// due to implementation issues (e.g., see issues #48619, #48656). +const unificationDepthLimit = 50 + // A unifier maintains the current type parameters for x and y // and the respective types inferred for each type parameter. // A unifier is created by calling newUnifier. @@ -40,6 +44,7 @@ type unifier struct { exact bool x, y tparamsList // x and y must initialized via tparamsList.init types []Type // inferred types, shared by x and y + depth int // recursion depth during unification } // newUnifier returns a new unifier. @@ -237,6 +242,18 @@ func (u *unifier) nifyEq(x, y Type, p *ifacePair) bool { // code the corresponding changes should be made here. // Must not be called directly from outside the unifier. func (u *unifier) nify(x, y Type, p *ifacePair) bool { + // Stop gap for cases where unification fails. + if u.depth >= unificationDepthLimit { + if debug { + panic("unification reached recursion depth limit") + } + return false + } + u.depth++ + defer func() { + u.depth-- + }() + if !u.exact { // If exact unification is known to fail because we attempt to // match a type name against an unnamed type literal, consider From a4b6fc7b1ddcec937b605b76068f8e800c1487e2 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 11 Jan 2022 22:19:56 -0800 Subject: [PATCH 623/752] go/types, types2: fix tracing output for type and expr lists - support printing of expression and type lists in sprintf - simplified some code in go/types/exprstring.go - fixed a typo in syntax package Change-Id: Ic4bc154200aad95958d5bc2904a9ea17cf518388 Reviewed-on: https://go-review.googlesource.com/c/go/+/377974 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/syntax/printer.go | 2 +- src/cmd/compile/internal/types2/errors.go | 22 ++++++++++++++++++++++ src/go/types/errors.go | 18 ++++++++++++++++++ src/go/types/exprstring.go | 7 +------ 4 files changed, 42 insertions(+), 7 deletions(-) diff --git a/src/cmd/compile/internal/syntax/printer.go b/src/cmd/compile/internal/syntax/printer.go index 11190ab287..0385227c7c 100644 --- a/src/cmd/compile/internal/syntax/printer.go +++ b/src/cmd/compile/internal/syntax/printer.go @@ -44,7 +44,7 @@ func Fprint(w io.Writer, x Node, form Form) (n int, err error) { return } -// String is a convenience functions that prints n in ShortForm +// String is a convenience function that prints n in ShortForm // and returns the printed string. func String(n Node) string { var buf bytes.Buffer diff --git a/src/cmd/compile/internal/types2/errors.go b/src/cmd/compile/internal/types2/errors.go index c39652fe5e..2318b95f3d 100644 --- a/src/cmd/compile/internal/types2/errors.go +++ b/src/cmd/compile/internal/types2/errors.go @@ -98,10 +98,32 @@ func sprintf(qf Qualifier, debug bool, format string, args ...interface{}) strin arg = a.String() case syntax.Expr: arg = syntax.String(a) + case []syntax.Expr: + var buf bytes.Buffer + buf.WriteByte('[') + for i, x := range a { + if i > 0 { + buf.WriteString(", ") + } + buf.WriteString(syntax.String(x)) + } + buf.WriteByte(']') + arg = buf.String() case Object: arg = ObjectString(a, qf) case Type: arg = typeString(a, qf, debug) + case []Type: + var buf bytes.Buffer + buf.WriteByte('[') + for i, x := range a { + if i > 0 { + buf.WriteString(", ") + } + buf.WriteString(typeString(x, qf, debug)) + } + buf.WriteByte(']') + arg = buf.String() } args[i] = arg } diff --git a/src/go/types/errors.go b/src/go/types/errors.go index 81c62a82f0..ce62a8cbdd 100644 --- a/src/go/types/errors.go +++ b/src/go/types/errors.go @@ -7,6 +7,7 @@ package types import ( + "bytes" "errors" "fmt" "go/ast" @@ -81,10 +82,27 @@ func sprintf(fset *token.FileSet, qf Qualifier, debug bool, format string, args } case ast.Expr: arg = ExprString(a) + case []ast.Expr: + var buf bytes.Buffer + buf.WriteByte('[') + writeExprList(&buf, a) + buf.WriteByte(']') + arg = buf.String() case Object: arg = ObjectString(a, qf) case Type: arg = typeString(a, qf, debug) + case []Type: + var buf bytes.Buffer + buf.WriteByte('[') + for i, x := range a { + if i > 0 { + buf.WriteString(", ") + } + buf.WriteString(typeString(x, qf, debug)) + } + buf.WriteByte(']') + arg = buf.String() } args[i] = arg } diff --git a/src/go/types/exprstring.go b/src/go/types/exprstring.go index aa4f403c1f..544cd84d61 100644 --- a/src/go/types/exprstring.go +++ b/src/go/types/exprstring.go @@ -71,12 +71,7 @@ func WriteExpr(buf *bytes.Buffer, x ast.Expr) { ix := typeparams.UnpackIndexExpr(x) WriteExpr(buf, ix.X) buf.WriteByte('[') - for i, e := range ix.Indices { - if i > 0 { - buf.WriteString(", ") - } - WriteExpr(buf, e) - } + writeExprList(buf, ix.Indices) buf.WriteByte(']') case *ast.SliceExpr: From f005df8b582658d54e63d59953201299d6fee880 Mon Sep 17 00:00:00 2001 From: Ayan George Date: Tue, 11 Jan 2022 16:37:46 -0500 Subject: [PATCH 624/752] cmd/go: enable fuzz testing for FreeBSD Add "freebsd" to GOOS for which sys.FuzzSupported() returns true and add freebsd to the build tags to fuzz test source. Fixes #46554 Change-Id: I5f695ecc8f09c0ab4279ced23b4715b788fcade0 Reviewed-on: https://go-review.googlesource.com/c/go/+/377855 Trust: Bryan Mills Trust: Katie Hockman Run-TryBot: Katie Hockman TryBot-Result: Gopher Robot Reviewed-by: Katie Hockman --- src/cmd/internal/sys/supported.go | 2 +- src/internal/fuzz/minimize_test.go | 2 +- src/internal/fuzz/sys_posix.go | 2 +- src/internal/fuzz/sys_unimplemented.go | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/cmd/internal/sys/supported.go b/src/cmd/internal/sys/supported.go index f25aaabddd..82b65511de 100644 --- a/src/cmd/internal/sys/supported.go +++ b/src/cmd/internal/sys/supported.go @@ -50,7 +50,7 @@ func ASanSupported(goos, goarch string) bool { // ('go test -fuzz=.'). func FuzzSupported(goos, goarch string) bool { switch goos { - case "darwin", "linux", "windows": + case "darwin", "freebsd", "linux", "windows": return true default: return false diff --git a/src/internal/fuzz/minimize_test.go b/src/internal/fuzz/minimize_test.go index 6e5f3184b4..2db2633896 100644 --- a/src/internal/fuzz/minimize_test.go +++ b/src/internal/fuzz/minimize_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. -//go:build darwin || linux || windows +//go:build darwin || freebsd || linux || windows package fuzz diff --git a/src/internal/fuzz/sys_posix.go b/src/internal/fuzz/sys_posix.go index 89c86c1ebb..fec6054f67 100644 --- a/src/internal/fuzz/sys_posix.go +++ b/src/internal/fuzz/sys_posix.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. -//go:build darwin || linux +//go:build darwin || freebsd || linux package fuzz diff --git a/src/internal/fuzz/sys_unimplemented.go b/src/internal/fuzz/sys_unimplemented.go index 123a32583c..f84dae6a61 100644 --- a/src/internal/fuzz/sys_unimplemented.go +++ b/src/internal/fuzz/sys_unimplemented.go @@ -4,7 +4,7 @@ // If you update this constraint, also update cmd/internal/sys.FuzzSupported. // -//go:build !darwin && !linux && !windows +//go:build !darwin && !freebsd && !linux && !windows package fuzz From 24239120bfbff9ebee8e8c344d9d3a8ce460b686 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 12 Jan 2022 16:27:14 -0800 Subject: [PATCH 625/752] doc: mention that GOAMD64 is a compile-time setting Fixes #50589 Change-Id: Ic260a6edd9af5c9c6dd8b40f0830f88644c907f1 Reviewed-on: https://go-review.googlesource.com/c/go/+/378179 Trust: Keith Randall Run-TryBot: Keith Randall Reviewed-by: Ian Lance Taylor TryBot-Result: Gopher Robot --- doc/go1.18.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 03d2b4e346..f23f2b8562 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -149,7 +149,7 @@ Do not send CLs removing the interior tags from such phrases.

    AMD64

    - Go 1.18 introduces the new GOAMD64 environment variable, which selects + Go 1.18 introduces the new GOAMD64 environment variable, which selects at compile time a mininum target version of the AMD64 architecture. Allowed values are v1, v2, v3, or v4. Each higher level requires, and takes advantage of, additional processor features. A detailed From 4fa6e33f30365a8bca374ab8bd47acd82b9faa96 Mon Sep 17 00:00:00 2001 From: Roland Shoemaker Date: Wed, 25 Aug 2021 13:50:24 -0700 Subject: [PATCH 626/752] all: add a handful of fuzz targets Adds simple fuzz targets to archive/tar, archive/zip, compress/gzip, encoding/json, image/jpeg, image/gif, and image/png. Second attempt, this time we don't use the archives in testdata when fuzzing archive/tar, since those are rather memory intensive, and were crashing a number of builders. Change-Id: I4828d64fa4763c0d8c980392a6578e4dfd956e13 Reviewed-on: https://go-review.googlesource.com/c/go/+/378174 Trust: Roland Shoemaker Run-TryBot: Roland Shoemaker Reviewed-by: Bryan Mills TryBot-Result: Gopher Robot --- src/archive/tar/fuzz_test.go | 80 +++++++++++++++++++++++++++++ src/archive/zip/fuzz_test.go | 81 ++++++++++++++++++++++++++++++ src/compress/gzip/fuzz_test.go | 92 ++++++++++++++++++++++++++++++++++ src/encoding/json/fuzz_test.go | 83 ++++++++++++++++++++++++++++++ src/image/gif/fuzz_test.go | 61 ++++++++++++++++++++++ src/image/jpeg/fuzz_test.go | 61 ++++++++++++++++++++++ src/image/png/fuzz_test.go | 68 +++++++++++++++++++++++++ 7 files changed, 526 insertions(+) create mode 100644 src/archive/tar/fuzz_test.go create mode 100644 src/archive/zip/fuzz_test.go create mode 100644 src/compress/gzip/fuzz_test.go create mode 100644 src/encoding/json/fuzz_test.go create mode 100644 src/image/gif/fuzz_test.go create mode 100644 src/image/jpeg/fuzz_test.go create mode 100644 src/image/png/fuzz_test.go diff --git a/src/archive/tar/fuzz_test.go b/src/archive/tar/fuzz_test.go new file mode 100644 index 0000000000..e73e0d2609 --- /dev/null +++ b/src/archive/tar/fuzz_test.go @@ -0,0 +1,80 @@ +// 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 tar + +import ( + "bytes" + "io" + "testing" +) + +func FuzzReader(f *testing.F) { + b := bytes.NewBuffer(nil) + w := NewWriter(b) + inp := []byte("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.") + err := w.WriteHeader(&Header{ + Name: "lorem.txt", + Mode: 0600, + Size: int64(len(inp)), + }) + if err != nil { + f.Fatalf("failed to create writer: %s", err) + } + _, err = w.Write(inp) + if err != nil { + f.Fatalf("failed to write file to archive: %s", err) + } + if err := w.Close(); err != nil { + f.Fatalf("failed to write archive: %s", err) + } + f.Add(b.Bytes()) + + f.Fuzz(func(t *testing.T, b []byte) { + r := NewReader(bytes.NewReader(b)) + type file struct { + header *Header + content []byte + } + files := []file{} + for { + hdr, err := r.Next() + if err == io.EOF { + break + } + if err != nil { + return + } + buf := bytes.NewBuffer(nil) + if _, err := io.Copy(buf, r); err != nil { + continue + } + files = append(files, file{header: hdr, content: buf.Bytes()}) + } + + // If we were unable to read anything out of the archive don't + // bother trying to roundtrip it. + if len(files) == 0 { + return + } + + out := bytes.NewBuffer(nil) + w := NewWriter(out) + for _, f := range files { + if err := w.WriteHeader(f.header); err != nil { + t.Fatalf("unable to write previously parsed header: %s", err) + } + if _, err := w.Write(f.content); err != nil { + t.Fatalf("unable to write previously parsed content: %s", err) + } + } + if err := w.Close(); err != nil { + t.Fatalf("Unable to write archive: %s", err) + } + + // TODO: We may want to check if the archive roundtrips. This would require + // taking into account addition of the two zero trailer blocks that Writer.Close + // appends. + }) +} diff --git a/src/archive/zip/fuzz_test.go b/src/archive/zip/fuzz_test.go new file mode 100644 index 0000000000..7dffde69bf --- /dev/null +++ b/src/archive/zip/fuzz_test.go @@ -0,0 +1,81 @@ +// 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 zip + +import ( + "bytes" + "io" + "os" + "path/filepath" + "testing" +) + +func FuzzReader(f *testing.F) { + testdata, err := os.ReadDir("testdata") + if err != nil { + f.Fatalf("failed to read testdata directory: %s", err) + } + for _, de := range testdata { + if de.IsDir() { + continue + } + b, err := os.ReadFile(filepath.Join("testdata", de.Name())) + if err != nil { + f.Fatalf("failed to read testdata: %s", err) + } + f.Add(b) + } + + f.Fuzz(func(t *testing.T, b []byte) { + r, err := NewReader(bytes.NewReader(b), int64(len(b))) + if err != nil { + return + } + + type file struct { + header *FileHeader + content []byte + } + files := []file{} + + for _, f := range r.File { + fr, err := f.Open() + if err != nil { + continue + } + content, err := io.ReadAll(fr) + if err != nil { + continue + } + files = append(files, file{header: &f.FileHeader, content: content}) + if _, err := r.Open(f.Name); err != nil { + continue + } + } + + // If we were unable to read anything out of the archive don't + // bother trying to roundtrip it. + if len(files) == 0 { + return + } + + w := NewWriter(io.Discard) + for _, f := range files { + ww, err := w.CreateHeader(f.header) + if err != nil { + t.Fatalf("unable to write previously parsed header: %s", err) + } + if _, err := ww.Write(f.content); err != nil { + t.Fatalf("unable to write previously parsed content: %s", err) + } + } + + if err := w.Close(); err != nil { + t.Fatalf("Unable to write archive: %s", err) + } + + // TODO: We may want to check if the archive roundtrips. + }) +} diff --git a/src/compress/gzip/fuzz_test.go b/src/compress/gzip/fuzz_test.go new file mode 100644 index 0000000000..80d803ce93 --- /dev/null +++ b/src/compress/gzip/fuzz_test.go @@ -0,0 +1,92 @@ +// 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 gzip + +import ( + "bytes" + "encoding/base64" + "io" + "os" + "path/filepath" + "strings" + "testing" +) + +func FuzzReader(f *testing.F) { + inp := []byte("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.") + for _, level := range []int{BestSpeed, BestCompression, DefaultCompression, HuffmanOnly} { + b := bytes.NewBuffer(nil) + w, err := NewWriterLevel(b, level) + if err != nil { + f.Fatalf("failed to construct writer: %s", err) + } + _, err = w.Write(inp) + if err != nil { + f.Fatalf("failed to write: %s", err) + } + f.Add(b.Bytes()) + } + + testdata, err := os.ReadDir("testdata") + if err != nil { + f.Fatalf("failed to read testdata directory: %s", err) + } + for _, de := range testdata { + if de.IsDir() { + continue + } + b, err := os.ReadFile(filepath.Join("testdata", de.Name())) + if err != nil { + f.Fatalf("failed to read testdata: %s", err) + } + + // decode any base64 encoded test files + if strings.HasPrefix(de.Name(), ".base64") { + b, err = base64.StdEncoding.DecodeString(string(b)) + if err != nil { + f.Fatalf("failed to decode base64 testdata: %s", err) + } + } + + f.Add(b) + } + + f.Fuzz(func(t *testing.T, b []byte) { + for _, multistream := range []bool{true, false} { + r, err := NewReader(bytes.NewBuffer(b)) + if err != nil { + continue + } + + r.Multistream(multistream) + + decompressed := bytes.NewBuffer(nil) + if _, err := io.Copy(decompressed, r); err != nil { + continue + } + + if err := r.Close(); err != nil { + continue + } + + for _, level := range []int{NoCompression, BestSpeed, BestCompression, DefaultCompression, HuffmanOnly} { + w, err := NewWriterLevel(io.Discard, level) + if err != nil { + t.Fatalf("failed to construct writer: %s", err) + } + _, err = w.Write(decompressed.Bytes()) + if err != nil { + t.Fatalf("failed to write: %s", err) + } + if err := w.Flush(); err != nil { + t.Fatalf("failed to flush: %s", err) + } + if err := w.Close(); err != nil { + t.Fatalf("failed to close: %s", err) + } + } + } + }) +} diff --git a/src/encoding/json/fuzz_test.go b/src/encoding/json/fuzz_test.go new file mode 100644 index 0000000000..778664c3e5 --- /dev/null +++ b/src/encoding/json/fuzz_test.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 json + +import ( + "bytes" + "io" + "testing" +) + +func FuzzUnmarshalJSON(f *testing.F) { + f.Add([]byte(`{ +"object": { + "slice": [ + 1, + 2.0, + "3", + [4], + {5: {}} + ] +}, +"slice": [[]], +"string": ":)", +"int": 1e5, +"float": 3e-9" +}`)) + + f.Fuzz(func(t *testing.T, b []byte) { + for _, typ := range []func() interface{}{ + func() interface{} { return new(interface{}) }, + func() interface{} { return new(map[string]interface{}) }, + func() interface{} { return new([]interface{}) }, + } { + i := typ() + if err := Unmarshal(b, i); err != nil { + return + } + + encoded, err := Marshal(i) + if err != nil { + t.Fatalf("failed to marshal: %s", err) + } + + if err := Unmarshal(encoded, i); err != nil { + t.Fatalf("failed to roundtrip: %s", err) + } + } + }) +} + +func FuzzDecoderToken(f *testing.F) { + f.Add([]byte(`{ +"object": { + "slice": [ + 1, + 2.0, + "3", + [4], + {5: {}} + ] +}, +"slice": [[]], +"string": ":)", +"int": 1e5, +"float": 3e-9" +}`)) + + f.Fuzz(func(t *testing.T, b []byte) { + r := bytes.NewReader(b) + d := NewDecoder(r) + for { + _, err := d.Token() + if err != nil { + if err == io.EOF { + break + } + return + } + } + }) +} diff --git a/src/image/gif/fuzz_test.go b/src/image/gif/fuzz_test.go new file mode 100644 index 0000000000..3ddf15d80f --- /dev/null +++ b/src/image/gif/fuzz_test.go @@ -0,0 +1,61 @@ +// 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 gif + +import ( + "bytes" + "image" + "os" + "path/filepath" + "strings" + "testing" +) + +func FuzzDecode(f *testing.F) { + testdata, err := os.ReadDir("../testdata") + if err != nil { + f.Fatalf("failed to read testdata directory: %s", err) + } + for _, de := range testdata { + if de.IsDir() || !strings.HasSuffix(de.Name(), ".gif") { + continue + } + b, err := os.ReadFile(filepath.Join("../testdata", de.Name())) + if err != nil { + f.Fatalf("failed to read testdata: %s", err) + } + f.Add(b) + } + + f.Fuzz(func(t *testing.T, b []byte) { + cfg, _, err := image.DecodeConfig(bytes.NewReader(b)) + if err != nil { + return + } + if cfg.Width*cfg.Height > 1e6 { + return + } + img, typ, err := image.Decode(bytes.NewReader(b)) + if err != nil || typ != "gif" { + return + } + for q := 1; q <= 256; q++ { + var w bytes.Buffer + err := Encode(&w, img, &Options{NumColors: q}) + if err != nil { + t.Fatalf("failed to encode valid image: %s", err) + } + img1, err := Decode(&w) + if err != nil { + t.Fatalf("failed to decode roundtripped image: %s", err) + } + got := img1.Bounds() + want := img.Bounds() + if !got.Eq(want) { + t.Fatalf("roundtripped image bounds have changed, got: %v, want: %v", got, want) + } + } + }) +} diff --git a/src/image/jpeg/fuzz_test.go b/src/image/jpeg/fuzz_test.go new file mode 100644 index 0000000000..716f06f43c --- /dev/null +++ b/src/image/jpeg/fuzz_test.go @@ -0,0 +1,61 @@ +// 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 jpeg + +import ( + "bytes" + "image" + "os" + "path/filepath" + "strings" + "testing" +) + +func FuzzDecode(f *testing.F) { + testdata, err := os.ReadDir("../testdata") + if err != nil { + f.Fatalf("failed to read testdata directory: %s", err) + } + for _, de := range testdata { + if de.IsDir() || !strings.HasSuffix(de.Name(), ".jpeg") { + continue + } + b, err := os.ReadFile(filepath.Join("../testdata", de.Name())) + if err != nil { + f.Fatalf("failed to read testdata: %s", err) + } + f.Add(b) + } + + f.Fuzz(func(t *testing.T, b []byte) { + cfg, _, err := image.DecodeConfig(bytes.NewReader(b)) + if err != nil { + return + } + if cfg.Width*cfg.Height > 1e6 { + return + } + img, typ, err := image.Decode(bytes.NewReader(b)) + if err != nil || typ != "jpeg" { + return + } + for q := 1; q <= 100; q++ { + var w bytes.Buffer + err := Encode(&w, img, &Options{Quality: q}) + if err != nil { + t.Fatalf("failed to encode valid image: %s", err) + } + img1, err := Decode(&w) + if err != nil { + t.Fatalf("failed to decode roundtripped image: %s", err) + } + got := img1.Bounds() + want := img.Bounds() + if !got.Eq(want) { + t.Fatalf("roundtripped image bounds have changed, got: %s, want: %s", got, want) + } + } + }) +} diff --git a/src/image/png/fuzz_test.go b/src/image/png/fuzz_test.go new file mode 100644 index 0000000000..22b3ef082a --- /dev/null +++ b/src/image/png/fuzz_test.go @@ -0,0 +1,68 @@ +// 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 png + +import ( + "bytes" + "image" + "os" + "path/filepath" + "strings" + "testing" +) + +func FuzzDecode(f *testing.F) { + testdata, err := os.ReadDir("../testdata") + if err != nil { + f.Fatalf("failed to read testdata directory: %s", err) + } + for _, de := range testdata { + if de.IsDir() || !strings.HasSuffix(de.Name(), ".png") { + continue + } + b, err := os.ReadFile(filepath.Join("../testdata", de.Name())) + if err != nil { + f.Fatalf("failed to read testdata: %s", err) + } + f.Add(b) + } + + f.Fuzz(func(t *testing.T, b []byte) { + cfg, _, err := image.DecodeConfig(bytes.NewReader(b)) + if err != nil { + return + } + if cfg.Width*cfg.Height > 1e6 { + return + } + img, typ, err := image.Decode(bytes.NewReader(b)) + if err != nil || typ != "png" { + return + } + levels := []CompressionLevel{ + DefaultCompression, + NoCompression, + BestSpeed, + BestCompression, + } + for _, l := range levels { + var w bytes.Buffer + e := &Encoder{CompressionLevel: l} + err = e.Encode(&w, img) + if err != nil { + t.Fatalf("failed to encode valid image: %s", err) + } + img1, err := Decode(&w) + if err != nil { + t.Fatalf("failed to decode roundtripped image: %s", err) + } + got := img1.Bounds() + want := img.Bounds() + if !got.Eq(want) { + t.Fatalf("roundtripped image bounds have changed, got: %s, want: %s", got, want) + } + } + }) +} From ce01afe907f7f37b465bda529a339a7a8b98c59e Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Fri, 7 Jan 2022 16:52:53 -0500 Subject: [PATCH 627/752] cmd/go: reset modfetch state between modules in go work sync go work sync resets the state in the modload package before each iteration where it updates the workspace modules' go.mod files. But before this change it wasn't resetting the global state in the modfetch package. This is necessary because the modfetch package keeps track of the sums that will be written to go.sum. Further, the fetch caches will update information about which modules are used when fetching packages, and so those caches need to be cleared between each workspace module. Thanks bcmills for helping me debug! Fixes #50038 Change-Id: I5679c18a80feb7c5194c4a5f7e7129c7d198ef7b Reviewed-on: https://go-review.googlesource.com/c/go/+/376655 Trust: Michael Matloob Run-TryBot: Michael Matloob Reviewed-by: Bryan Mills TryBot-Result: Gopher Robot --- src/cmd/go/internal/modfetch/fetch.go | 22 +++++++++++ src/cmd/go/internal/modload/init.go | 1 + src/cmd/go/internal/workcmd/sync.go | 4 +- src/cmd/go/testdata/script/work_sync_sum.txt | 40 ++++++++++++++++++++ 4 files changed, 65 insertions(+), 2 deletions(-) create mode 100644 src/cmd/go/testdata/script/work_sync_sum.txt diff --git a/src/cmd/go/internal/modfetch/fetch.go b/src/cmd/go/internal/modfetch/fetch.go index 12b7431570..f5423b48ad 100644 --- a/src/cmd/go/internal/modfetch/fetch.go +++ b/src/cmd/go/internal/modfetch/fetch.go @@ -405,6 +405,28 @@ type modSumStatus struct { used, dirty bool } +// Reset resets globals in the modfetch package, so previous loads don't affect +// contents of go.sum files +func Reset() { + GoSumFile = "" + WorkspaceGoSumFiles = nil + + // Uses of lookupCache and downloadCache both can call checkModSum, + // which in turn sets the used bit on goSum.status for modules. + // Reset them so used can be computed properly. + lookupCache = par.Cache{} + downloadCache = par.Cache{} + + // Clear all fields on goSum. It will be initialized later + goSum.mu.Lock() + goSum.m = nil + goSum.w = nil + goSum.status = nil + goSum.overwrite = false + goSum.enabled = false + goSum.mu.Unlock() +} + // initGoSum initializes the go.sum data. // The boolean it returns reports whether the // use of go.sum is now enabled. diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go index df083e7fcc..fe7d0ef3e6 100644 --- a/src/cmd/go/internal/modload/init.go +++ b/src/cmd/go/internal/modload/init.go @@ -75,6 +75,7 @@ func EnterModule(ctx context.Context, enterModroot string) { MainModules = nil // reset MainModules requirements = nil workFilePath = "" // Force module mode + modfetch.Reset() modRoots = []string{enterModroot} LoadModFile(ctx) diff --git a/src/cmd/go/internal/workcmd/sync.go b/src/cmd/go/internal/workcmd/sync.go index a10d15a3b7..1cca817517 100644 --- a/src/cmd/go/internal/workcmd/sync.go +++ b/src/cmd/go/internal/workcmd/sync.go @@ -108,13 +108,13 @@ func runSync(ctx context.Context, cmd *base.Command, args []string) { modload.LoadPackages(ctx, modload.PackageOpts{ Tags: imports.AnyTags(), + Tidy: true, VendorModulesInGOROOTSrc: true, ResolveMissingImports: false, LoadTests: true, AllowErrors: true, + SilenceMissingStdImports: true, SilencePackageErrors: true, - Tidy: true, - SilenceUnmatchedWarnings: true, }, "all") modload.WriteGoMod(ctx) } diff --git a/src/cmd/go/testdata/script/work_sync_sum.txt b/src/cmd/go/testdata/script/work_sync_sum.txt new file mode 100644 index 0000000000..656fd31379 --- /dev/null +++ b/src/cmd/go/testdata/script/work_sync_sum.txt @@ -0,0 +1,40 @@ +# Test that the sum file data state is properly reset between modules in +# go work sync so that the sum file that's written is correct. +# Exercises the fix to #50038. + +cp b/go.sum b/go.sum.want + +# As a sanity check, verify b/go.sum is tidy. +cd b +go mod tidy +cd .. +cmp b/go.sum b/go.sum.want + +# Run go work sync and verify it doesn't change b/go.sum. +go work sync +cmp b/go.sum b/go.sum.want + +-- b/go.sum -- +rsc.io/quote v1.0.0 h1:kQ3IZQzPTiDJxSZI98YaWgxFEhlNdYASHvh+MplbViw= +rsc.io/quote v1.0.0/go.mod h1:v83Ri/njykPcgJltBc/gEkJTmjTsNgtO1Y7vyIK1CQA= +-- go.work -- +go 1.18 +use ( + ./a + ./b +) +replace example.com/c => ./c +-- a/go.mod -- +module example.com/a +go 1.18 +require rsc.io/fortune v1.0.0 +-- a/a.go -- +package a +import "rsc.io/fortune" +-- b/go.mod -- +module example.com/b +go 1.18 +require rsc.io/quote v1.0.0 +-- b/b.go -- +package b +import _ "rsc.io/quote" From 3ff12a019f00bc81996c453e5cb4729a9278f65a Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Mon, 10 Jan 2022 12:58:20 -0500 Subject: [PATCH 628/752] cmd/go: run go install in workspace mode It's too confusing to users to run go install in module mode, so run it in workspace mode instead. Fixes #50036 Change-Id: Ia99927bd98f54be4c42224a247543892045e3464 Reviewed-on: https://go-review.googlesource.com/c/go/+/377334 Reviewed-by: Bryan Mills Trust: Michael Matloob Run-TryBot: Michael Matloob TryBot-Result: Gopher Robot --- src/cmd/go/internal/work/build.go | 1 + .../script/work_install_submodule.txt | 36 +++++++++++++++++++ 2 files changed, 37 insertions(+) create mode 100644 src/cmd/go/testdata/script/work_install_submodule.txt diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go index 9d0ad27f0d..9b1acf987d 100644 --- a/src/cmd/go/internal/work/build.go +++ b/src/cmd/go/internal/work/build.go @@ -617,6 +617,7 @@ func runInstall(ctx context.Context, cmd *base.Command, args []string) { } } + modload.InitWorkfile() BuildInit() pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{}, args) if cfg.ModulesEnabled && !modload.HasModRoot() { diff --git a/src/cmd/go/testdata/script/work_install_submodule.txt b/src/cmd/go/testdata/script/work_install_submodule.txt new file mode 100644 index 0000000000..3d1171736d --- /dev/null +++ b/src/cmd/go/testdata/script/work_install_submodule.txt @@ -0,0 +1,36 @@ +# This is a regression test for golang.org/issue/50036 +# Don't check sums for other modules in the workspace. + +cd m/sub +go install -n + +-- go.work -- +go 1.18 + +use ( + ./m + ./m/sub +) +-- m/go.mod -- +module example.com/m + +go 1.18 + +-- m/m.go -- +package m + +func M() {} +-- m/sub/go.mod -- +module example.com/m/sub + +go 1.18 + +require example.com/m v1.0.0 +-- m/sub/main.go -- +package main + +import "example.com/m" + +func main() { + m.M() +} From 6891d07ee6a34f1c8d0326f3f7dd941bddf524f1 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Thu, 13 Jan 2022 13:57:47 -0500 Subject: [PATCH 629/752] database/sql: consolidate test polling loops Also eliminate some arbitrary deadlines and sleeps. Fixes #49958 Change-Id: I999b39a896e430e3bb93aa8b8c9444f28bbaa9d0 Reviewed-on: https://go-review.googlesource.com/c/go/+/378395 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Daniel Theophanes --- src/database/sql/sql_test.go | 111 +++++++++++++++++++---------------- 1 file changed, 61 insertions(+), 50 deletions(-) diff --git a/src/database/sql/sql_test.go b/src/database/sql/sql_test.go index 1bb9afc407..08ca1f5b9a 100644 --- a/src/database/sql/sql_test.go +++ b/src/database/sql/sql_test.go @@ -55,6 +55,10 @@ func init() { } } +// pollDuration is an arbitrary interval to wait between checks when polling for +// a condition to occur. +const pollDuration = 5 * time.Millisecond + const fakeDBName = "foo" var chrisBirthday = time.Unix(123456789, 0) @@ -173,7 +177,7 @@ func closeDB(t testing.TB, db *DB) { } var numOpen int - if !waitCondition(5*time.Second, 5*time.Millisecond, func() bool { + if !waitCondition(t, func() bool { numOpen = db.numOpenConns() return numOpen == 0 }) { @@ -197,16 +201,14 @@ func (db *DB) numDeps() int { } // Dependencies are closed via a goroutine, so this polls waiting for -// numDeps to fall to want, waiting up to d. -func (db *DB) numDepsPollUntil(want int, d time.Duration) int { - deadline := time.Now().Add(d) - for { - n := db.numDeps() - if n <= want || time.Now().After(deadline) { - return n - } - time.Sleep(50 * time.Millisecond) - } +// numDeps to fall to want, waiting up to nearly the test's deadline. +func (db *DB) numDepsPoll(t *testing.T, want int) int { + var n int + waitCondition(t, func() bool { + n = db.numDeps() + return n <= want + }) + return n } func (db *DB) numFreeConns() int { @@ -229,7 +231,7 @@ func (db *DB) clearAllConns(t *testing.T) { t.Errorf("free conns = %d; want %d", g, w) } - if n := db.numDepsPollUntil(0, time.Second); n > 0 { + if n := db.numDepsPoll(t, 0); n > 0 { t.Errorf("number of dependencies = %d; expected 0", n) db.dumpDeps(t) } @@ -321,7 +323,7 @@ func TestQueryContext(t *testing.T) { for rows.Next() { if index == 2 { cancel() - waitForRowsClose(t, rows, 5*time.Second) + waitForRowsClose(t, rows) } var r row err = rows.Scan(&r.age, &r.name) @@ -355,29 +357,43 @@ func TestQueryContext(t *testing.T) { // And verify that the final rows.Next() call, which hit EOF, // also closed the rows connection. - waitForRowsClose(t, rows, 5*time.Second) - waitForFree(t, db, 5*time.Second, 1) + waitForRowsClose(t, rows) + waitForFree(t, db, 1) if prepares := numPrepares(t, db) - prepares0; prepares != 1 { t.Errorf("executed %d Prepare statements; want 1", prepares) } } -func waitCondition(waitFor, checkEvery time.Duration, fn func() bool) bool { - deadline := time.Now().Add(waitFor) - for time.Now().Before(deadline) { +func waitCondition(t testing.TB, fn func() bool) bool { + timeout := 5 * time.Second + + type deadliner interface { + Deadline() (time.Time, bool) + } + if td, ok := t.(deadliner); ok { + if deadline, ok := td.Deadline(); ok { + timeout = time.Until(deadline) + timeout = timeout * 19 / 20 // Give 5% headroom for cleanup and error-reporting. + } + } + + deadline := time.Now().Add(timeout) + for { if fn() { return true } - time.Sleep(checkEvery) + if time.Until(deadline) < pollDuration { + return false + } + time.Sleep(pollDuration) } - return false } // waitForFree checks db.numFreeConns until either it equals want or // the maxWait time elapses. -func waitForFree(t *testing.T, db *DB, maxWait time.Duration, want int) { +func waitForFree(t *testing.T, db *DB, want int) { var numFree int - if !waitCondition(maxWait, 5*time.Millisecond, func() bool { + if !waitCondition(t, func() bool { numFree = db.numFreeConns() return numFree == want }) { @@ -385,8 +401,8 @@ func waitForFree(t *testing.T, db *DB, maxWait time.Duration, want int) { } } -func waitForRowsClose(t *testing.T, rows *Rows, maxWait time.Duration) { - if !waitCondition(maxWait, 5*time.Millisecond, func() bool { +func waitForRowsClose(t *testing.T, rows *Rows) { + if !waitCondition(t, func() bool { rows.closemu.RLock() defer rows.closemu.RUnlock() return rows.closed @@ -416,7 +432,7 @@ func TestQueryContextWait(t *testing.T) { } // Verify closed rows connection after error condition. - waitForFree(t, db, 5*time.Second, 1) + waitForFree(t, db, 1) if prepares := numPrepares(t, db) - prepares0; prepares != 1 { // TODO(kardianos): if the context timeouts before the db.QueryContext // executes this check may fail. After adjusting how the context @@ -451,7 +467,7 @@ func TestTxContextWait(t *testing.T) { t.Fatalf("expected QueryContext to error with context canceled but returned %v", err) } - waitForFree(t, db, 5*time.Second, 0) + waitForFree(t, db, 0) } // TestTxContextWaitNoDiscard is the same as TestTxContextWait, but should not discard @@ -480,7 +496,7 @@ func TestTxContextWaitNoDiscard(t *testing.T) { t.Fatalf("expected QueryContext to error with context deadline exceeded but returned %v", err) } - waitForFree(t, db, 5*time.Second, 1) + waitForFree(t, db, 1) } // TestUnsupportedOptions checks that the database fails when a driver that @@ -565,7 +581,7 @@ func TestMultiResultSetQuery(t *testing.T) { // And verify that the final rows.Next() call, which hit EOF, // also closed the rows connection. - waitForFree(t, db, 5*time.Second, 1) + waitForFree(t, db, 1) if prepares := numPrepares(t, db) - prepares0; prepares != 1 { t.Errorf("executed %d Prepare statements; want 1", prepares) } @@ -2083,18 +2099,15 @@ func TestMaxOpenConns(t *testing.T) { } }() } - // Sleep for twice the expected length of time for the - // batch of 50 queries above to finish before starting - // the next round. - time.Sleep(2 * sleepMillis * time.Millisecond) + // Wait for the batch of queries above to finish before starting the next round. + wg.Wait() } - wg.Wait() if g, w := db.numFreeConns(), 10; g != w { t.Errorf("free conns = %d; want %d", g, w) } - if n := db.numDepsPollUntil(20, time.Second); n > 20 { + if n := db.numDepsPoll(t, 20); n > 20 { t.Errorf("number of dependencies = %d; expected <= 20", n) db.dumpDeps(t) } @@ -2119,7 +2132,7 @@ func TestMaxOpenConns(t *testing.T) { t.Errorf("free conns = %d; want %d", g, w) } - if n := db.numDepsPollUntil(10, time.Second); n > 10 { + if n := db.numDepsPoll(t, 10); n > 10 { t.Errorf("number of dependencies = %d; expected <= 10", n) db.dumpDeps(t) } @@ -2130,7 +2143,7 @@ func TestMaxOpenConns(t *testing.T) { t.Errorf("free conns = %d; want %d", g, w) } - if n := db.numDepsPollUntil(5, time.Second); n > 5 { + if n := db.numDepsPoll(t, 5); n > 5 { t.Errorf("number of dependencies = %d; expected 0", n) db.dumpDeps(t) } @@ -2141,7 +2154,7 @@ func TestMaxOpenConns(t *testing.T) { t.Errorf("free conns = %d; want %d", g, w) } - if n := db.numDepsPollUntil(5, time.Second); n > 5 { + if n := db.numDepsPoll(t, 5); n > 5 { t.Errorf("number of dependencies = %d; expected 0", n) db.dumpDeps(t) } @@ -2400,13 +2413,14 @@ func TestConnMaxLifetime(t *testing.T) { tx2.Commit() // Give connectionCleaner chance to run. - for i := 0; i < 100 && closes != 1; i++ { - time.Sleep(time.Millisecond) + waitCondition(t, func() bool { driver.mu.Lock() opens = driver.openCount - opens0 closes = driver.closeCount - closes0 driver.mu.Unlock() - } + + return closes == 1 + }) if opens != 3 { t.Errorf("opens = %d; want 3", opens) @@ -2466,18 +2480,15 @@ func TestStmtCloseDeps(t *testing.T) { } }() } - // Sleep for twice the expected length of time for the - // batch of 50 queries above to finish before starting - // the next round. - time.Sleep(2 * sleepMillis * time.Millisecond) + // Wait for the batch of queries above to finish before starting the next round. + wg.Wait() } - wg.Wait() if g, w := db.numFreeConns(), 2; g != w { t.Errorf("free conns = %d; want %d", g, w) } - if n := db.numDepsPollUntil(4, time.Second); n > 4 { + if n := db.numDepsPoll(t, 4); n > 4 { t.Errorf("number of dependencies = %d; expected <= 4", n) db.dumpDeps(t) } @@ -2496,7 +2507,7 @@ func TestStmtCloseDeps(t *testing.T) { db.dumpDeps(t) } - if !waitCondition(5*time.Second, 5*time.Millisecond, func() bool { + if !waitCondition(t, func() bool { return len(stmt.css) <= nquery }) { t.Errorf("len(stmt.css) = %d; want <= %d", len(stmt.css), nquery) @@ -2510,7 +2521,7 @@ func TestStmtCloseDeps(t *testing.T) { t.Errorf("free conns = %d; want %d", g, w) } - if n := db.numDepsPollUntil(2, time.Second); n > 2 { + if n := db.numDepsPoll(t, 2); n > 2 { t.Errorf("number of dependencies = %d; expected <= 2", n) db.dumpDeps(t) } @@ -2942,7 +2953,7 @@ func TestConnExpiresFreshOutOfPool(t *testing.T) { if ct > 0 { return } - time.Sleep(10 * time.Millisecond) + time.Sleep(pollDuration) } }() @@ -3721,7 +3732,7 @@ func TestIssue18719(t *testing.T) { // Wait for the context to cancel and tx to rollback. for tx.isDone() == false { - time.Sleep(3 * time.Millisecond) + time.Sleep(pollDuration) } } defer func() { hookTxGrabConn = nil }() From 1a8b4e05b1ff7a52c6d40fad73bcad612168d094 Mon Sep 17 00:00:00 2001 From: Matthew Dempsky Date: Thu, 16 Dec 2021 12:55:15 -0800 Subject: [PATCH 630/752] cmd/compile: unique LinkString for renamed, embedded fields Using type aliases, it's possible to create structs with embedded fields that have no corresponding type literal notation. However, we still need to generate a unique name for these types to use for linker symbols. This CL introduces a new "struct{ Name = Type }" syntax for use in LinkString formatting to represent these types. Reattempt at CL 372914, which was rolled back due to race-y LocalPkg.Lookup call that isn't safe for concurrency. Fixes #50190. Change-Id: I0b7fd81e1b0b3199a6afcffde96ade42495ad8d1 Reviewed-on: https://go-review.googlesource.com/c/go/+/378434 Trust: Matthew Dempsky Run-TryBot: Matthew Dempsky TryBot-Result: Gopher Robot Reviewed-by: Robert Griesemer --- src/cmd/compile/internal/types/fmt.go | 45 +++++++++++++++++++++++++-- test/fixedbugs/issue50190.go | 31 ++++++++++++++++++ 2 files changed, 74 insertions(+), 2 deletions(-) create mode 100644 test/fixedbugs/issue50190.go diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go index 3198a1f53c..e1b395559a 100644 --- a/src/cmd/compile/internal/types/fmt.go +++ b/src/cmd/compile/internal/types/fmt.go @@ -631,6 +631,7 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty } var name string + nameSep := " " if verb != 'S' { s := f.Sym @@ -639,7 +640,47 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty s = OrigSym(s) } - if s != nil && f.Embedded == 0 { + // Using type aliases and embedded fields, it's possible to + // construct types that can't be directly represented as a + // type literal. For example, given "type Int = int" (#50190), + // it would be incorrect to format "struct{ Int }" as either + // "struct{ int }" or "struct{ Int int }", because those each + // represent other, distinct types. + // + // So for the purpose of LinkString (i.e., fmtTypeID), we use + // the non-standard syntax "struct{ Int = int }" to represent + // embedded fields that have been renamed through the use of + // type aliases. + if f.Embedded != 0 { + if mode == fmtTypeID { + nameSep = " = " + + // Compute tsym, the symbol that would normally be used as + // the field name when embedding f.Type. + // TODO(mdempsky): Check for other occurences of this logic + // and deduplicate. + typ := f.Type + if typ.IsPtr() { + base.Assertf(typ.Sym() == nil, "embedded pointer type has name: %L", typ) + typ = typ.Elem() + } + tsym := typ.Sym() + + // If the field name matches the embedded type's name, then + // suppress printing of the field name. For example, format + // "struct{ T }" as simply that instead of "struct{ T = T }". + if tsym != nil && (s == tsym || IsExported(tsym.Name) && s.Name == tsym.Name) { + s = nil + } + } else { + // Suppress the field name for embedded fields for + // non-LinkString formats, to match historical behavior. + // TODO(mdempsky): Re-evaluate this. + s = nil + } + } + + if s != nil { if funarg != FunargNone { name = fmt.Sprint(f.Nname) } else if verb == 'L' { @@ -658,7 +699,7 @@ func fldconv(b *bytes.Buffer, f *Field, verb rune, mode fmtMode, visited map[*Ty if name != "" { b.WriteString(name) - b.WriteString(" ") + b.WriteString(nameSep) } if f.IsDDD() { diff --git a/test/fixedbugs/issue50190.go b/test/fixedbugs/issue50190.go new file mode 100644 index 0000000000..a5ee646a1a --- /dev/null +++ b/test/fixedbugs/issue50190.go @@ -0,0 +1,31 @@ +// 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 + +type Int = int + +type A = struct{ int } +type B = struct{ Int } + +func main() { + var x, y interface{} = A{}, B{} + if x == y { + panic("FAIL") + } + + { + type C = int32 + x = struct{ C }{} + } + { + type C = uint32 + y = struct{ C }{} + } + if x == y { + panic("FAIL") + } +} From 899d19ac8330648b4ced7a7787db41c04f07f79f Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Wed, 12 Jan 2022 11:30:57 -0800 Subject: [PATCH 631/752] cmd/compile: descend through types to find fully-instantiated types In order to make sure we export the dictionaries/shape methods for all fully-instantiated types in inlineable functions, we need to descend fully into types. For example, we may have a map type (e.g. map[transactionID]Promise[*ByteBuffer]), where the key or value is a new fully-instantiated type. So, I add a new checkFullyInst() traversal function, which traverses all encountered types, but maintains a map, so it only traverse it type once. We need to descend fully into interfaces, structs, and methods, since a fully-instantiated type make occur in any fields or arguments/results of methods, etc. Fixes #50561 Change-Id: I88681a30384168539ed7229eed709f4e73ff0666 Reviewed-on: https://go-review.googlesource.com/c/go/+/378154 Reviewed-by: Keith Randall Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/typecheck/crawler.go | 143 ++++++++++++------ test/typeparam/issue50561.dir/diameter.go | 86 +++++++++++ test/typeparam/issue50561.dir/main.go | 13 ++ test/typeparam/issue50561.go | 7 + 4 files changed, 203 insertions(+), 46 deletions(-) create mode 100644 test/typeparam/issue50561.dir/diameter.go create mode 100644 test/typeparam/issue50561.dir/main.go create mode 100644 test/typeparam/issue50561.go diff --git a/src/cmd/compile/internal/typecheck/crawler.go b/src/cmd/compile/internal/typecheck/crawler.go index 87dc5165fd..11c8056df5 100644 --- a/src/cmd/compile/internal/typecheck/crawler.go +++ b/src/cmd/compile/internal/typecheck/crawler.go @@ -30,9 +30,10 @@ import ( // type. func crawlExports(exports []*ir.Name) { p := crawler{ - marked: make(map[*types.Type]bool), - embedded: make(map[*types.Type]bool), - generic: make(map[*types.Type]bool), + marked: make(map[*types.Type]bool), + embedded: make(map[*types.Type]bool), + generic: make(map[*types.Type]bool), + checkFullyInst: make(map[*types.Type]bool), } for _, n := range exports { p.markObject(n) @@ -40,9 +41,10 @@ func crawlExports(exports []*ir.Name) { } type crawler struct { - marked map[*types.Type]bool // types already seen by markType - embedded map[*types.Type]bool // types already seen by markEmbed - generic map[*types.Type]bool // types already seen by markGeneric + marked map[*types.Type]bool // types already seen by markType + embedded map[*types.Type]bool // types already seen by markEmbed + generic map[*types.Type]bool // types already seen by markGeneric + checkFullyInst map[*types.Type]bool // types already seen by checkForFullyInst } // markObject visits a reachable object (function, method, global type, or global variable) @@ -208,6 +210,93 @@ func (p *crawler) markGeneric(t *types.Type) { } } +// checkForFullyInst looks for fully-instantiated types in a type (at any nesting +// level). If it finds a fully-instantiated type, it ensures that the necessary +// dictionary and shape methods are exported. It updates p.checkFullyInst, so it +// traverses each particular type only once. +func (p *crawler) checkForFullyInst(t *types.Type) { + if p.checkFullyInst[t] { + return + } + p.checkFullyInst[t] = true + + if t.IsFullyInstantiated() && !t.HasShape() && !t.IsInterface() && t.Methods().Len() > 0 { + // For any fully-instantiated type, the relevant + // dictionaries and shape instantiations will have + // already been created or are in the import data. + // Make sure that they are exported, so that any + // other package that inlines this function will have + // them available for import, and so will not need + // another round of method and dictionary + // instantiation after inlining. + baseType := t.OrigSym().Def.(*ir.Name).Type() + shapes := make([]*types.Type, len(t.RParams())) + for i, t1 := range t.RParams() { + shapes[i] = Shapify(t1, i) + } + for j := range t.Methods().Slice() { + baseNname := baseType.Methods().Slice()[j].Nname.(*ir.Name) + dictsym := MakeDictSym(baseNname.Sym(), t.RParams(), true) + if dictsym.Def == nil { + in := Resolve(ir.NewIdent(src.NoXPos, dictsym)) + dictsym = in.Sym() + } + Export(dictsym.Def.(*ir.Name)) + methsym := MakeFuncInstSym(baseNname.Sym(), shapes, false, true) + if methsym.Def == nil { + in := Resolve(ir.NewIdent(src.NoXPos, methsym)) + methsym = in.Sym() + } + methNode := methsym.Def.(*ir.Name) + Export(methNode) + if HaveInlineBody(methNode.Func) { + // Export the body as well if + // instantiation is inlineable. + methNode.Func.SetExportInline(true) + } + } + } + + // Descend into the type. We descend even if it is a fully-instantiated type, + // since the instantiated type may have other instantiated types inside of + // it (in fields, methods, etc.). + switch t.Kind() { + case types.TPTR, types.TARRAY, types.TSLICE: + p.checkForFullyInst(t.Elem()) + + case types.TCHAN: + p.checkForFullyInst(t.Elem()) + + case types.TMAP: + p.checkForFullyInst(t.Key()) + p.checkForFullyInst(t.Elem()) + + case types.TSTRUCT: + if t.IsFuncArgStruct() { + break + } + for _, f := range t.FieldSlice() { + p.checkForFullyInst(f.Type) + } + + case types.TFUNC: + if recv := t.Recv(); recv != nil { + p.checkForFullyInst(t.Recv().Type) + } + for _, f := range t.Params().FieldSlice() { + p.checkForFullyInst(f.Type) + } + for _, f := range t.Results().FieldSlice() { + p.checkForFullyInst(f.Type) + } + + case types.TINTER: + for _, f := range t.AllMethods().Slice() { + p.checkForFullyInst(f.Type) + } + } +} + // markInlBody marks n's inline body for export and recursively // ensures all called functions are marked too. func (p *crawler) markInlBody(n *ir.Name) { @@ -236,51 +325,13 @@ func (p *crawler) markInlBody(n *ir.Name) { doFlood = func(n ir.Node) { t := n.Type() if t != nil { - if t.IsPtr() { - t = t.Elem() - } - if t.IsFullyInstantiated() && !t.HasShape() && !t.IsInterface() && t.Methods().Len() > 0 { - // For any fully-instantiated type, the relevant - // dictionaries and shape instantiations will have - // already been created or are in the import data. - // Make sure that they are exported, so that any - // other package that inlines this function will have - // them available for import, and so will not need - // another round of method and dictionary - // instantiation after inlining. - baseType := t.OrigSym().Def.(*ir.Name).Type() - shapes := make([]*types.Type, len(t.RParams())) - for i, t1 := range t.RParams() { - shapes[i] = Shapify(t1, i) - } - for j := range t.Methods().Slice() { - baseNname := baseType.Methods().Slice()[j].Nname.(*ir.Name) - dictsym := MakeDictSym(baseNname.Sym(), t.RParams(), true) - if dictsym.Def == nil { - in := Resolve(ir.NewIdent(src.NoXPos, dictsym)) - dictsym = in.Sym() - } - Export(dictsym.Def.(*ir.Name)) - methsym := MakeFuncInstSym(baseNname.Sym(), shapes, false, true) - if methsym.Def == nil { - in := Resolve(ir.NewIdent(src.NoXPos, methsym)) - methsym = in.Sym() - } - methNode := methsym.Def.(*ir.Name) - Export(methNode) - if HaveInlineBody(methNode.Func) { - // Export the body as well if - // instantiation is inlineable. - methNode.Func.SetExportInline(true) - } - } - } - if t.HasTParam() { // If any generic types are used, then make sure that // the methods of the generic type are exported and // scanned for other possible exports. p.markGeneric(t) + } else { + p.checkForFullyInst(t) } if base.Debug.Unified == 0 { // If a method of un-exported type is promoted and accessible by diff --git a/test/typeparam/issue50561.dir/diameter.go b/test/typeparam/issue50561.dir/diameter.go new file mode 100644 index 0000000000..2bfe92405d --- /dev/null +++ b/test/typeparam/issue50561.dir/diameter.go @@ -0,0 +1,86 @@ +// Copyright 2022 The Go 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 diameter + +type Runnable interface { + Run() +} + +// RunnableFunc is converter which converts function to Runnable interface +type RunnableFunc func() + +// Run is Runnable.Run +func (r RunnableFunc) Run() { + r() +} + +type Executor interface { + ExecuteUnsafe(runnable Runnable) +} + +type Promise[T any] interface { + Future() Future[T] + Success(value T) bool + Failure(err error) bool + IsCompleted() bool + Complete(result Try[T]) bool +} + +type Future[T any] interface { + OnFailure(cb func(err error), ctx ...Executor) + OnSuccess(cb func(success T), ctx ...Executor) + Foreach(f func(v T), ctx ...Executor) + OnComplete(cb func(try Try[T]), ctx ...Executor) + IsCompleted() bool + // Value() Option[Try[T]] + Failed() Future[error] + Recover(f func(err error) T, ctx ...Executor) Future[T] + RecoverWith(f func(err error) Future[T], ctx ...Executor) Future[T] +} + +type Try[T any] struct { + v *T + err error +} + +func (r Try[T]) IsSuccess() bool { + return r.v != nil +} + +type ByteBuffer struct { + pos int + buf []byte + underflow error +} + +// InboundHandler is extends of uclient.NetInboundHandler +type InboundHandler interface { + OriginHost() string + OriginRealm() string +} + +type transactionID struct { + hopID uint32 + endID uint32 +} + +type roundTripper struct { + promise map[transactionID]Promise[*ByteBuffer] + host string + realm string +} + +func (r *roundTripper) OriginHost() string { + return r.host +} +func (r *roundTripper) OriginRealm() string { + return r.realm +} + +func NewInboundHandler(host string, realm string, productName string) InboundHandler { + ret := &roundTripper{promise: make(map[transactionID]Promise[*ByteBuffer]), host: host, realm: realm} + + return ret +} diff --git a/test/typeparam/issue50561.dir/main.go b/test/typeparam/issue50561.dir/main.go new file mode 100644 index 0000000000..bad7b6a34b --- /dev/null +++ b/test/typeparam/issue50561.dir/main.go @@ -0,0 +1,13 @@ +// Copyright 2022 The Go 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 ( + "diameter" +) + +func main() { + diameter.NewInboundHandler("hello", "world", "hi") +} diff --git a/test/typeparam/issue50561.go b/test/typeparam/issue50561.go new file mode 100644 index 0000000000..060a1214cc --- /dev/null +++ b/test/typeparam/issue50561.go @@ -0,0 +1,7 @@ +// compiledir -G=3 + +// Copyright 2022 The Go 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 From 4f6f68ee4b50162d3bd01efb9b8a5f6a10dc54af Mon Sep 17 00:00:00 2001 From: Patrik Nyblom Date: Wed, 12 Jan 2022 17:50:55 -0800 Subject: [PATCH 632/752] testing: skip flaky TestRaiseException on windows-amd64-2012 This is in relation to #49681 Change-Id: I32ad8b506cf8fb0a94b15c3cc8b1eaf5af728c59 Reviewed-on: https://go-review.googlesource.com/c/go/+/378254 Run-TryBot: Patrik Nyblom TryBot-Result: Gopher Robot Reviewed-by: Bryan Mills Trust: Patrik Nyblom --- src/runtime/syscall_windows_test.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/runtime/syscall_windows_test.go b/src/runtime/syscall_windows_test.go index dcd390ff9d..034a1d84db 100644 --- a/src/runtime/syscall_windows_test.go +++ b/src/runtime/syscall_windows_test.go @@ -628,6 +628,9 @@ func TestOutputDebugString(t *testing.T) { } func TestRaiseException(t *testing.T) { + if testenv.Builder() == "windows-amd64-2012" { + testenv.SkipFlaky(t, 49681) + } o := runTestProg(t, "testprog", "RaiseException") if strings.Contains(o, "RaiseException should not return") { t.Fatalf("RaiseException did not crash program: %v", o) From e550c3054586a224d949cc8fa030bac0887bee51 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Wed, 12 Jan 2022 16:11:35 -0800 Subject: [PATCH 633/752] cmd/compile: stop interface conversions for generic method calls from allocating Let T be a type parameter, and say we instantiate it with S, a type that isn't pointer-like (e.g. a pair of ints, or as in 50182, a slice). Then to call a method m on a variable of type T, the compiler does essentially: var v T = ... i := (interface{m()})(v) i.m() The conversion at that second line allocates, as we need to make the data word for an interface. And in the general case, that interface may live an arbitrarily long time. But in this case, we know it doesn't. The data word of i has type *S. When we call i.m, we can't call S.m directly. It is expecting an S, not a *S. We call through a wrapper defined on *S, which looks like: func (p *S) m() { var s S = *p s.m() } The value passed in for p is exactly the data word mentioned above. It never escapes anywhere - the wrapper copies a type S variable out of *p and p is dead after that. That means that in the situation where we build an interface for the explicit purpose of calling a method on it, and use that built interface nowhere else, the allocation of the data word for that interface is known to die before the call returns and thus can be stack allocated. One tricky case is that although the allocation of the backing store of the interface conversion doesn't escape, pointers we store *inside* that allocation might escape (in fact they definitely will, unless we can devirtualize the receiver). Fixes #50182 Change-Id: I40e893955c2e6871c54ccecf1b9f0cae17871b0d Reviewed-on: https://go-review.googlesource.com/c/go/+/378178 Trust: Keith Randall Run-TryBot: Keith Randall Trust: Dan Scales Reviewed-by: Matthew Dempsky Reviewed-by: David Chase Reviewed-by: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/escape/escape.go | 8 +++ src/cmd/compile/internal/ir/expr.go | 3 +- src/cmd/compile/internal/noder/stencil.go | 15 +++-- .../compile/internal/test/issue50182_test.go | 62 +++++++++++++++++++ 4 files changed, 83 insertions(+), 5 deletions(-) create mode 100644 src/cmd/compile/internal/test/issue50182_test.go diff --git a/src/cmd/compile/internal/escape/escape.go b/src/cmd/compile/internal/escape/escape.go index 61e0121a40..c2145bdf91 100644 --- a/src/cmd/compile/internal/escape/escape.go +++ b/src/cmd/compile/internal/escape/escape.go @@ -293,6 +293,14 @@ func (b *batch) finish(fns []*ir.Func) { // TODO(mdempsky): Update tests to expect this. goDeferWrapper := n.Op() == ir.OCLOSURE && n.(*ir.ClosureExpr).Func.Wrapper() + if n.Op() == ir.OCONVIDATA && n.(*ir.ConvExpr).NonEscaping { + // The allocation for the data word of an interface is known to not escape. + // See issue 50182. + // (But we do still need to process that allocation, as pointers inside + // the data word may escape.) + loc.escapes = false + } + if loc.escapes { if n.Op() == ir.ONAME { if base.Flag.CompilingRuntime { diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go index f526d987a7..68303c0581 100644 --- a/src/cmd/compile/internal/ir/expr.go +++ b/src/cmd/compile/internal/ir/expr.go @@ -250,7 +250,8 @@ func (n *ConstExpr) Val() constant.Value { return n.val } // It may end up being a value or a type. type ConvExpr struct { miniExpr - X Node + X Node + NonEscaping bool // The allocation needed for the conversion to interface is known not to escape } func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr { diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go index 4c6eaf3fb0..e5f59d0286 100644 --- a/src/cmd/compile/internal/noder/stencil.go +++ b/src/cmd/compile/internal/noder/stencil.go @@ -1228,7 +1228,11 @@ func (g *genInst) dictPass(info *instInfo) { // we do a type assert to the type bound. mse.X = assertToBound(info, info.dictParam, m.Pos(), mse.X, dst) } else { - mse.X = convertUsingDictionary(info, info.dictParam, m.Pos(), mse.X, m, dst) + mse.X = convertUsingDictionary(info, info.dictParam, m.Pos(), mse.X, m, dst, true) + // Note: we set nonEscaping==true, because we can assume the backing store for the + // interface conversion doesn't escape. The method call will immediately go to + // a wrapper function which copies all the data out of the interface value. + // (It only matters for non-pointer-shaped interface conversions. See issue 50182.) } transformDot(mse, false) } @@ -1254,7 +1258,7 @@ func (g *genInst) dictPass(info *instInfo) { // Note: x's argument is still typed as a type parameter. // m's argument now has an instantiated type. if mce.X.Type().HasShape() || (mce.X.Type().IsInterface() && m.Type().HasShape()) { - m = convertUsingDictionary(info, info.dictParam, m.Pos(), m.(*ir.ConvExpr).X, m, m.Type()) + m = convertUsingDictionary(info, info.dictParam, m.Pos(), m.(*ir.ConvExpr).X, m, m.Type(), false) } case ir.ODOTTYPE, ir.ODOTTYPE2: if !m.Type().HasShape() { @@ -1347,7 +1351,9 @@ func findDictType(info *instInfo, t *types.Type) int { // type dst, by returning a new set of nodes that make use of a dictionary entry. in is the // instantiated node of the CONVIFACE node or XDOT node (for a bound method call) that is causing the // conversion. -func convertUsingDictionary(info *instInfo, dictParam *ir.Name, pos src.XPos, v ir.Node, in ir.Node, dst *types.Type) ir.Node { +// If nonEscaping is true, the caller guarantees that the backing store needed for the interface data +// word will not escape. +func convertUsingDictionary(info *instInfo, dictParam *ir.Name, pos src.XPos, v ir.Node, in ir.Node, dst *types.Type, nonEscaping bool) ir.Node { assert(v.Type().HasShape() || v.Type().IsInterface() && in.Type().HasShape()) assert(dst.IsInterface()) @@ -1417,6 +1423,7 @@ func convertUsingDictionary(info *instInfo, dictParam *ir.Name, pos src.XPos, v // Figure out what the data field of the interface will be. data := ir.NewConvExpr(pos, ir.OCONVIDATA, nil, v) typed(types.Types[types.TUNSAFEPTR], data) + data.NonEscaping = nonEscaping // Build an interface from the type and data parts. var i ir.Node = ir.NewBinaryExpr(pos, ir.OEFACE, rt, data) @@ -2147,7 +2154,7 @@ func (g *genInst) buildClosure2(info *instInfo, m ir.Node) ir.Node { // the type bound. rcvr = assertToBound(info, dictVar, pos, rcvr, dst) } else { - rcvr = convertUsingDictionary(info, dictVar, pos, rcvr, m, dst) + rcvr = convertUsingDictionary(info, dictVar, pos, rcvr, m, dst, false) } dot := ir.NewSelectorExpr(pos, ir.ODOTINTER, rcvr, m.(*ir.SelectorExpr).Sel) dot.Selection = typecheck.Lookdot1(dot, dot.Sel, dot.X.Type(), dot.X.Type().AllMethods(), 1) diff --git a/src/cmd/compile/internal/test/issue50182_test.go b/src/cmd/compile/internal/test/issue50182_test.go new file mode 100644 index 0000000000..cd277fa285 --- /dev/null +++ b/src/cmd/compile/internal/test/issue50182_test.go @@ -0,0 +1,62 @@ +// 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 test + +import ( + "fmt" + "sort" + "testing" +) + +// Test that calling methods on generic types doesn't cause allocations. +func genericSorted[T sort.Interface](data T) bool { + n := data.Len() + for i := n - 1; i > 0; i-- { + if data.Less(i, i-1) { + return false + } + } + return true +} +func TestGenericSorted(t *testing.T) { + var data = sort.IntSlice{-10, -5, 0, 1, 2, 3, 5, 7, 11, 100, 100, 100, 1000, 10000} + f := func() { + genericSorted(data) + } + if n := testing.AllocsPerRun(10, f); n > 0 { + t.Errorf("got %f allocs, want 0", n) + } +} + +// Test that escape analysis correctly tracks escaping inside of methods +// called on generic types. +type fooer interface { + foo() +} +type P struct { + p *int + q int +} + +var esc []*int + +func (p P) foo() { + esc = append(esc, p.p) // foo escapes the pointer from inside of p +} +func f[T fooer](t T) { + t.foo() +} +func TestGenericEscape(t *testing.T) { + for i := 0; i < 4; i++ { + var x int = 77 + i + var p P = P{p: &x} + f(p) + } + for i, p := range esc { + if got, want := *p, 77+i; got != want { + panic(fmt.Sprintf("entry %d: got %d, want %d", i, got, want)) + } + } +} From b41185c5c3da2d5f52b3b5aa7eb034addd458938 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Thu, 13 Jan 2022 13:20:19 -0800 Subject: [PATCH 634/752] cmd/compile: add call to ImportedBody() when exporting shape inst body When we export a shape instantiation, because a particular fully-instantiated type is needed by an inlineable function, we possibly export the body of the instantiation, if it is inlineable. In this case, we should have been calling ImportedBody() to make sure that the function body had already been read in (if it is actually imported from another package). Fixes #50598 Change-Id: I512d2bcc745faa6ff3a97e25bc8f46e2c2643d23 Reviewed-on: https://go-review.googlesource.com/c/go/+/378494 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: Cuong Manh Le Reviewed-by: Keith Randall --- src/cmd/compile/internal/typecheck/crawler.go | 1 + test/typeparam/issue50598.dir/a0.go | 23 +++++++++++++++++++ test/typeparam/issue50598.dir/a1.go | 11 +++++++++ test/typeparam/issue50598.dir/a2.go | 11 +++++++++ test/typeparam/issue50598.dir/main.go | 22 ++++++++++++++++++ test/typeparam/issue50598.go | 7 ++++++ 6 files changed, 75 insertions(+) create mode 100644 test/typeparam/issue50598.dir/a0.go create mode 100644 test/typeparam/issue50598.dir/a1.go create mode 100644 test/typeparam/issue50598.dir/a2.go create mode 100644 test/typeparam/issue50598.dir/main.go create mode 100644 test/typeparam/issue50598.go diff --git a/src/cmd/compile/internal/typecheck/crawler.go b/src/cmd/compile/internal/typecheck/crawler.go index 11c8056df5..a25c741488 100644 --- a/src/cmd/compile/internal/typecheck/crawler.go +++ b/src/cmd/compile/internal/typecheck/crawler.go @@ -252,6 +252,7 @@ func (p *crawler) checkForFullyInst(t *types.Type) { if HaveInlineBody(methNode.Func) { // Export the body as well if // instantiation is inlineable. + ImportedBody(methNode.Func) methNode.Func.SetExportInline(true) } } diff --git a/test/typeparam/issue50598.dir/a0.go b/test/typeparam/issue50598.dir/a0.go new file mode 100644 index 0000000000..61d353e462 --- /dev/null +++ b/test/typeparam/issue50598.dir/a0.go @@ -0,0 +1,23 @@ +// Copyright 2022 The Go 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 a0 + +type Builder[T any] struct{} + +func (r Builder[T]) New1() T { + var v T + return v +} + +func (r Builder[T]) New2() T { + var v T + return v +} + +type IntBuilder struct{} + +func (b IntBuilder) New() int { + return Builder[int]{}.New2() +} diff --git a/test/typeparam/issue50598.dir/a1.go b/test/typeparam/issue50598.dir/a1.go new file mode 100644 index 0000000000..0e63fac016 --- /dev/null +++ b/test/typeparam/issue50598.dir/a1.go @@ -0,0 +1,11 @@ +// Copyright 2022 The Go 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 a1 + +import "a0" + +func New() int { + return a0.IntBuilder{}.New() +} diff --git a/test/typeparam/issue50598.dir/a2.go b/test/typeparam/issue50598.dir/a2.go new file mode 100644 index 0000000000..3eb5200253 --- /dev/null +++ b/test/typeparam/issue50598.dir/a2.go @@ -0,0 +1,11 @@ +// Copyright 2022 The Go 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 a2 + +import "a0" + +func New() int { + return a0.Builder[int]{}.New1() +} diff --git a/test/typeparam/issue50598.dir/main.go b/test/typeparam/issue50598.dir/main.go new file mode 100644 index 0000000000..0fab8b665c --- /dev/null +++ b/test/typeparam/issue50598.dir/main.go @@ -0,0 +1,22 @@ +// Copyright 2022 The Go 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" + + "a1" + "a2" +) + +func New() int { + return a1.New() + a2.New() +} + +func main() { + if got, want := New(), 0; got != want { + panic(fmt.Sprintf("got %d, want %d", got, want)) + } +} diff --git a/test/typeparam/issue50598.go b/test/typeparam/issue50598.go new file mode 100644 index 0000000000..642f4bf49f --- /dev/null +++ b/test/typeparam/issue50598.go @@ -0,0 +1,7 @@ +// rundir -G=3 + +// Copyright 2022 The Go 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 From 17b2fb1b656a275906b5071c562439d50a27f167 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Wed, 12 Jan 2022 17:22:09 -0500 Subject: [PATCH 635/752] runtime: fix net poll races The netpoll code was written long ago, when the only multiprocessors that Go ran on were x86. It assumed that an atomic store would trigger a full memory barrier and then used that barrier to order otherwise racy access to a handful of fields, including pollDesc.closing. On ARM64, this code has finally failed, because the atomic store is on a value completely unrelated to any of the racily-accessed fields, and the ARMv8 hardware, unlike x86, is clever enough not to do a full memory barrier for a simple atomic store. We are seeing a constant background rate of trybot failures where the net/http tests deadlock - a netpollblock has clearly happened after the pollDesc has begun to close. The code that does the racy reads is netpollcheckerr, which needs to be able to run without acquiring a lock. This CL fixes the race, without introducing unnecessary inefficiency or deadlock, by arranging for every updater of the relevant fields to publish a summary as a single atomic uint32, and then having netpollcheckerr use a single atomic load to fetch the relevant bits and then proceed as before. Fixes #45211 (until proven otherwise!). Change-Id: Ib6788c8da4d00b7bda84d55ca3fdffb5a64c1a0a Reviewed-on: https://go-review.googlesource.com/c/go/+/378234 Trust: Russ Cox Run-TryBot: Russ Cox Trust: Bryan Mills Reviewed-by: Ian Lance Taylor --- src/runtime/netpoll.go | 157 ++++++++++++++++++++++++--------- src/runtime/netpoll_aix.go | 5 +- src/runtime/netpoll_epoll.go | 5 +- src/runtime/netpoll_kqueue.go | 5 +- src/runtime/netpoll_solaris.go | 2 +- src/runtime/runtime2.go | 2 + 6 files changed, 119 insertions(+), 57 deletions(-) diff --git a/src/runtime/netpoll.go b/src/runtime/netpoll.go index 322a6f3637..bb3dd35317 100644 --- a/src/runtime/netpoll.go +++ b/src/runtime/netpoll.go @@ -71,31 +71,99 @@ const pollBlockSize = 4 * 1024 //go:notinheap type pollDesc struct { link *pollDesc // in pollcache, protected by pollcache.lock + fd uintptr // constant for pollDesc usage lifetime + + // atomicInfo holds bits from closing, rd, and wd, + // which are only ever written while holding the lock, + // summarized for use by netpollcheckerr, + // which cannot acquire the lock. + // After writing these fields under lock in a way that + // might change the summary, code must call publishInfo + // before releasing the lock. + // Code that changes fields and then calls netpollunblock + // (while still holding the lock) must call publishInfo + // before calling netpollunblock, because publishInfo is what + // stops netpollblock from blocking anew + // (by changing the result of netpollcheckerr). + // atomicInfo also holds the eventErr bit, + // recording whether a poll event on the fd got an error; + // atomicInfo is the only source of truth for that bit. + atomicInfo atomic.Uint32 // atomic pollInfo + + // rg, wg are accessed atomically and hold g pointers. + // (Using atomic.Uintptr here is similar to using guintptr elsewhere.) + rg atomic.Uintptr // pdReady, pdWait, G waiting for read or nil + wg atomic.Uintptr // pdReady, pdWait, G waiting for write or nil - // The lock protects pollOpen, pollSetDeadline, pollUnblock and deadlineimpl operations. - // This fully covers seq, rt and wt variables. fd is constant throughout the PollDesc lifetime. - // pollReset, pollWait, pollWaitCanceled and runtime·netpollready (IO readiness notification) - // proceed w/o taking the lock. So closing, everr, rg, rd, wg and wd are manipulated - // in a lock-free way by all operations. - // TODO(golang.org/issue/49008): audit these lock-free fields for continued correctness. - // NOTE(dvyukov): the following code uses uintptr to store *g (rg/wg), - // that will blow up when GC starts moving objects. lock mutex // protects the following fields - fd uintptr closing bool - everr bool // marks event scanning error happened user uint32 // user settable cookie rseq uintptr // protects from stale read timers - rg uintptr // pdReady, pdWait, G waiting for read or nil. Accessed atomically. rt timer // read deadline timer (set if rt.f != nil) - rd int64 // read deadline + rd int64 // read deadline (a nanotime in the future, -1 when expired) wseq uintptr // protects from stale write timers - wg uintptr // pdReady, pdWait, G waiting for write or nil. Accessed atomically. wt timer // write deadline timer - wd int64 // write deadline + wd int64 // write deadline (a nanotime in the future, -1 when expired) self *pollDesc // storage for indirect interface. See (*pollDesc).makeArg. } +// pollInfo is the bits needed by netpollcheckerr, stored atomically, +// mostly duplicating state that is manipulated under lock in pollDesc. +// The one exception is the pollEventErr bit, which is maintained only +// in the pollInfo. +type pollInfo uint32 + +const ( + pollClosing = 1 << iota + pollEventErr + pollExpiredReadDeadline + pollExpiredWriteDeadline +) + +func (i pollInfo) closing() bool { return i&pollClosing != 0 } +func (i pollInfo) eventErr() bool { return i&pollEventErr != 0 } +func (i pollInfo) expiredReadDeadline() bool { return i&pollExpiredReadDeadline != 0 } +func (i pollInfo) expiredWriteDeadline() bool { return i&pollExpiredWriteDeadline != 0 } + +// info returns the pollInfo corresponding to pd. +func (pd *pollDesc) info() pollInfo { + return pollInfo(pd.atomicInfo.Load()) +} + +// publishInfo updates pd.atomicInfo (returned by pd.info) +// using the other values in pd. +// It must be called while holding pd.lock, +// and it must be called after changing anything +// that might affect the info bits. +// In practice this means after changing closing +// or changing rd or wd from < 0 to >= 0. +func (pd *pollDesc) publishInfo() { + var info uint32 + if pd.closing { + info |= pollClosing + } + if pd.rd < 0 { + info |= pollExpiredReadDeadline + } + if pd.wd < 0 { + info |= pollExpiredWriteDeadline + } + + // Set all of x except the pollEventErr bit. + x := pd.atomicInfo.Load() + for !pd.atomicInfo.CompareAndSwap(x, (x&pollEventErr)|info) { + x = pd.atomicInfo.Load() + } +} + +// setEventErr sets the result of pd.info().eventErr() to b. +func (pd *pollDesc) setEventErr(b bool) { + x := pd.atomicInfo.Load() + for (x&pollEventErr != 0) != b && !pd.atomicInfo.CompareAndSwap(x, x^pollEventErr) { + x = pd.atomicInfo.Load() + } +} + type pollCache struct { lock mutex first *pollDesc @@ -147,24 +215,25 @@ func poll_runtime_isPollServerDescriptor(fd uintptr) bool { func poll_runtime_pollOpen(fd uintptr) (*pollDesc, int) { pd := pollcache.alloc() lock(&pd.lock) - wg := atomic.Loaduintptr(&pd.wg) + wg := pd.wg.Load() if wg != 0 && wg != pdReady { throw("runtime: blocked write on free polldesc") } - rg := atomic.Loaduintptr(&pd.rg) + rg := pd.rg.Load() if rg != 0 && rg != pdReady { throw("runtime: blocked read on free polldesc") } pd.fd = fd pd.closing = false - pd.everr = false + pd.setEventErr(false) pd.rseq++ - atomic.Storeuintptr(&pd.rg, 0) + pd.rg.Store(0) pd.rd = 0 pd.wseq++ - atomic.Storeuintptr(&pd.wg, 0) + pd.wg.Store(0) pd.wd = 0 pd.self = pd + pd.publishInfo() unlock(&pd.lock) errno := netpollopen(fd, pd) @@ -180,11 +249,11 @@ func poll_runtime_pollClose(pd *pollDesc) { if !pd.closing { throw("runtime: close polldesc w/o unblock") } - wg := atomic.Loaduintptr(&pd.wg) + wg := pd.wg.Load() if wg != 0 && wg != pdReady { throw("runtime: blocked write on closing polldesc") } - rg := atomic.Loaduintptr(&pd.rg) + rg := pd.rg.Load() if rg != 0 && rg != pdReady { throw("runtime: blocked read on closing polldesc") } @@ -209,9 +278,9 @@ func poll_runtime_pollReset(pd *pollDesc, mode int) int { return errcode } if mode == 'r' { - atomic.Storeuintptr(&pd.rg, 0) + pd.rg.Store(0) } else if mode == 'w' { - atomic.Storeuintptr(&pd.wg, 0) + pd.wg.Store(0) } return pollNoError } @@ -273,6 +342,7 @@ func poll_runtime_pollSetDeadline(pd *pollDesc, d int64, mode int) { if mode == 'w' || mode == 'r'+'w' { pd.wd = d } + pd.publishInfo() combo := pd.rd > 0 && pd.rd == pd.wd rtf := netpollReadDeadline if combo { @@ -314,15 +384,13 @@ func poll_runtime_pollSetDeadline(pd *pollDesc, d int64, mode int) { } } // If we set the new deadline in the past, unblock currently pending IO if any. + // Note that pd.publishInfo has already been called, above, immediately after modifying rd and wd. var rg, wg *g - if pd.rd < 0 || pd.wd < 0 { - atomic.StorepNoWB(noescape(unsafe.Pointer(&wg)), nil) // full memory barrier between stores to rd/wd and load of rg/wg in netpollunblock - if pd.rd < 0 { - rg = netpollunblock(pd, 'r', false) - } - if pd.wd < 0 { - wg = netpollunblock(pd, 'w', false) - } + if pd.rd < 0 { + rg = netpollunblock(pd, 'r', false) + } + if pd.wd < 0 { + wg = netpollunblock(pd, 'w', false) } unlock(&pd.lock) if rg != nil { @@ -343,7 +411,7 @@ func poll_runtime_pollUnblock(pd *pollDesc) { pd.rseq++ pd.wseq++ var rg, wg *g - atomic.StorepNoWB(noescape(unsafe.Pointer(&rg)), nil) // full memory barrier between store to closing and read of rg/wg in netpollunblock + pd.publishInfo() rg = netpollunblock(pd, 'r', false) wg = netpollunblock(pd, 'w', false) if pd.rt.f != nil { @@ -388,16 +456,17 @@ func netpollready(toRun *gList, pd *pollDesc, mode int32) { } func netpollcheckerr(pd *pollDesc, mode int32) int { - if pd.closing { + info := pd.info() + if info.closing() { return pollErrClosing } - if (mode == 'r' && pd.rd < 0) || (mode == 'w' && pd.wd < 0) { + if (mode == 'r' && info.expiredReadDeadline()) || (mode == 'w' && info.expiredWriteDeadline()) { return pollErrTimeout } // Report an event scanning error only on a read event. // An error on a write event will be captured in a subsequent // write call that is able to report a more specific error. - if mode == 'r' && pd.everr { + if mode == 'r' && info.eventErr() { return pollErrNotPollable } return pollNoError @@ -432,28 +501,28 @@ func netpollblock(pd *pollDesc, mode int32, waitio bool) bool { // set the gpp semaphore to pdWait for { // Consume notification if already ready. - if atomic.Casuintptr(gpp, pdReady, 0) { + if gpp.CompareAndSwap(pdReady, 0) { return true } - if atomic.Casuintptr(gpp, 0, pdWait) { + if gpp.CompareAndSwap(0, pdWait) { break } // Double check that this isn't corrupt; otherwise we'd loop // forever. - if v := atomic.Loaduintptr(gpp); v != pdReady && v != 0 { + if v := gpp.Load(); v != pdReady && v != 0 { throw("runtime: double wait") } } // need to recheck error states after setting gpp to pdWait // this is necessary because runtime_pollUnblock/runtime_pollSetDeadline/deadlineimpl - // do the opposite: store to closing/rd/wd, membarrier, load of rg/wg + // do the opposite: store to closing/rd/wd, publishInfo, load of rg/wg if waitio || netpollcheckerr(pd, mode) == pollNoError { gopark(netpollblockcommit, unsafe.Pointer(gpp), waitReasonIOWait, traceEvGoBlockNet, 5) } // be careful to not lose concurrent pdReady notification - old := atomic.Xchguintptr(gpp, 0) + old := gpp.Swap(0) if old > pdWait { throw("runtime: corrupted polldesc") } @@ -467,7 +536,7 @@ func netpollunblock(pd *pollDesc, mode int32, ioready bool) *g { } for { - old := atomic.Loaduintptr(gpp) + old := gpp.Load() if old == pdReady { return nil } @@ -480,7 +549,7 @@ func netpollunblock(pd *pollDesc, mode int32, ioready bool) *g { if ioready { new = pdReady } - if atomic.Casuintptr(gpp, old, new) { + if gpp.CompareAndSwap(old, new) { if old == pdWait { old = 0 } @@ -508,7 +577,7 @@ func netpolldeadlineimpl(pd *pollDesc, seq uintptr, read, write bool) { throw("runtime: inconsistent read deadline") } pd.rd = -1 - atomic.StorepNoWB(unsafe.Pointer(&pd.rt.f), nil) // full memory barrier between store to rd and load of rg in netpollunblock + pd.publishInfo() rg = netpollunblock(pd, 'r', false) } var wg *g @@ -517,7 +586,7 @@ func netpolldeadlineimpl(pd *pollDesc, seq uintptr, read, write bool) { throw("runtime: inconsistent write deadline") } pd.wd = -1 - atomic.StorepNoWB(unsafe.Pointer(&pd.wt.f), nil) // full memory barrier between store to wd and load of wg in netpollunblock + pd.publishInfo() wg = netpollunblock(pd, 'w', false) } unlock(&pd.lock) diff --git a/src/runtime/netpoll_aix.go b/src/runtime/netpoll_aix.go index 4590ed81a6..90950af444 100644 --- a/src/runtime/netpoll_aix.go +++ b/src/runtime/netpoll_aix.go @@ -212,10 +212,7 @@ retry: pfd.events &= ^_POLLOUT } if mode != 0 { - pds[i].everr = false - if pfd.revents == _POLLERR { - pds[i].everr = true - } + pds[i].setEventErr(pfd.revents == _POLLERR) netpollready(&toRun, pds[i], mode) n-- } diff --git a/src/runtime/netpoll_epoll.go b/src/runtime/netpoll_epoll.go index e0fb877d50..b7d6199965 100644 --- a/src/runtime/netpoll_epoll.go +++ b/src/runtime/netpoll_epoll.go @@ -168,10 +168,7 @@ retry: } if mode != 0 { pd := *(**pollDesc)(unsafe.Pointer(&ev.data)) - pd.everr = false - if ev.events == _EPOLLERR { - pd.everr = true - } + pd.setEventErr(ev.events == _EPOLLERR) netpollready(&toRun, pd, mode) } } diff --git a/src/runtime/netpoll_kqueue.go b/src/runtime/netpoll_kqueue.go index 2f7f2848d2..1694753b6f 100644 --- a/src/runtime/netpoll_kqueue.go +++ b/src/runtime/netpoll_kqueue.go @@ -179,10 +179,7 @@ retry: } if mode != 0 { pd := (*pollDesc)(unsafe.Pointer(ev.udata)) - pd.everr = false - if ev.flags == _EV_ERROR { - pd.everr = true - } + pd.setEventErr(ev.flags == _EV_ERROR) netpollready(&toRun, pd, mode) } } diff --git a/src/runtime/netpoll_solaris.go b/src/runtime/netpoll_solaris.go index d217d5b160..6e545b3d31 100644 --- a/src/runtime/netpoll_solaris.go +++ b/src/runtime/netpoll_solaris.go @@ -158,7 +158,7 @@ func netpollclose(fd uintptr) int32 { // this call, port_getn will return one and only one event for that // particular descriptor, so this function needs to be called again. func netpollupdate(pd *pollDesc, set, clear uint32) { - if pd.closing { + if pd.info().closing() { return } diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go index ec34e7ac1a..d0b7a162d5 100644 --- a/src/runtime/runtime2.go +++ b/src/runtime/runtime2.go @@ -255,6 +255,8 @@ func efaceOf(ep *any) *eface { // so I can't see them ever moving. If we did want to start moving data // in the GC, we'd need to allocate the goroutine structs from an // alternate arena. Using guintptr doesn't make that problem any worse. +// Note that pollDesc.rg, pollDesc.wg also store g in uintptr form, +// so they would need to be updated too if g's start moving. type guintptr uintptr //go:nosplit From 9c6ecc49ca02c83f3081c30171ab40dd62557342 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 14 Jan 2022 09:23:25 -0500 Subject: [PATCH 636/752] runtime: skip known TestSegv failure mode on linux-mips64le-mengzhuo Also adjust other skips to actually call t.Skip, so that the test correctly shows as skipped instead of passing. For #50605 Change-Id: Ied482f231a879224c5a92e2c47a6b21c1593a7da Reviewed-on: https://go-review.googlesource.com/c/go/+/378554 Trust: Bryan Mills Reviewed-by: Michael Pratt Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot --- src/runtime/crash_cgo_test.go | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/src/runtime/crash_cgo_test.go b/src/runtime/crash_cgo_test.go index abaed40977..6f1265c014 100644 --- a/src/runtime/crash_cgo_test.go +++ b/src/runtime/crash_cgo_test.go @@ -622,17 +622,19 @@ func TestSegv(t *testing.T) { // No runtime errors like "runtime: unknown pc". switch runtime.GOOS { case "darwin", "illumos", "solaris": - // TODO(golang.org/issue/49182): Skip, runtime - // throws while attempting to generate - // traceback. - return + // Runtime sometimes throws when generating the traceback. + testenv.SkipFlaky(t, 49182) case "linux": if runtime.GOARCH == "386" { - // TODO(golang.org/issue/50504): Skip, - // runtime throws while attempting to - // generate traceback from VDSO call - // via asmcgocall. - return + // Runtime throws when generating a traceback from + // a VDSO call via asmcgocall. + testenv.SkipFlaky(t, 50504) + } + if testenv.Builder() == "linux-mips64le-mengzhuo" && strings.Contains(got, "runtime: unknown pc") { + // Runtime sometimes throw "unknown pc" when generating the traceback. + // Curiously, that doesn't seem to happen on the linux-mips64le-rtrk + // builder. + testenv.SkipFlaky(t, 50605) } } nowant := "runtime: " From e4a6b84962cc2fb4f4b8bb532a84bab5bfd68d99 Mon Sep 17 00:00:00 2001 From: Alessandro Arzilli Date: Tue, 4 Jan 2022 15:47:02 +0100 Subject: [PATCH 637/752] debug/elf: do not read unrelated bytes for SHT_NOBITS sections SHT_NOBITS sections do not occupy space in the file and their offset is "conceptual", reading their data should return all zeroes instead of reading bytes from the section that follows them. Change-Id: Iaa9634792c1909c3e87dab841dd646cd6dcf9027 Reviewed-on: https://go-review.googlesource.com/c/go/+/375216 Reviewed-by: Emmanuel Odeke Run-TryBot: Emmanuel Odeke TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/debug/elf/elf_test.go | 22 ++++++++++++++++++++++ src/debug/elf/file.go | 12 ++++++++++++ 2 files changed, 34 insertions(+) diff --git a/src/debug/elf/elf_test.go b/src/debug/elf/elf_test.go index a61b491090..b8c310dba5 100644 --- a/src/debug/elf/elf_test.go +++ b/src/debug/elf/elf_test.go @@ -47,3 +47,25 @@ func TestNames(t *testing.T) { } } } + +func TestNobitsSection(t *testing.T) { + const testdata = "testdata/gcc-amd64-linux-exec" + f, err := Open(testdata) + if err != nil { + t.Fatalf("could not read %s: %v", testdata, err) + } + defer f.Close() + bss := f.Section(".bss") + bssData, err := bss.Data() + if err != nil { + t.Fatalf("error reading .bss section: %v", err) + } + if g, w := uint64(len(bssData)), bss.Size; g != w { + t.Errorf(".bss section length mismatch: got %d, want %d", g, w) + } + for i := range bssData { + if bssData[i] != 0 { + t.Fatalf("unexpected non-zero byte at offset %d: %#x", i, bssData[i]) + } + } +} diff --git a/src/debug/elf/file.go b/src/debug/elf/file.go index eefcaab8d6..8c84661c5f 100644 --- a/src/debug/elf/file.go +++ b/src/debug/elf/file.go @@ -120,6 +120,9 @@ func (f *File) stringTable(link uint32) ([]byte, error) { // Even if the section is stored compressed in the ELF file, // the ReadSeeker reads uncompressed data. func (s *Section) Open() io.ReadSeeker { + if s.Type == SHT_NOBITS { + return io.NewSectionReader(&zeroReader{}, 0, int64(s.Size)) + } if s.Flags&SHF_COMPRESSED == 0 { return io.NewSectionReader(s.sr, 0, 1<<63-1) } @@ -1453,3 +1456,12 @@ func (f *File) DynString(tag DynTag) ([]string, error) { } return all, nil } + +type zeroReader struct{} + +func (*zeroReader) ReadAt(p []byte, off int64) (n int, err error) { + for i := range p { + p[i] = 0 + } + return len(p), nil +} From 1302f93c4e1eae0e625b372f9bb6bb48780af30f Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Mon, 13 Dec 2021 17:32:07 -0500 Subject: [PATCH 638/752] cmd/dist: log CPU model when testing Knowing whether test failures are correlated with specific CPU models on has proven useful on several issues. Log it for prior to testing so it is always available. internal/sysinfo provides the CPU model, but it is not available in the bootstrap toolchain, so we can't access this unconditionally in cmd/dist. Instead use a build-tagged file, as the final version of cmd/dist will use the final toolchain. The addition of new data to the beginning of cmd/dist output will break x/build/cmd/coordinator's banner parsing, leaving extra lines in the log output, though information will not be lost. https://golang.org/cl/372538 fixes up the coordinator and should be submitted and deployed before this CL is submitted. For #46272. For #49209. For #50146. Change-Id: I515d2ec58e4c0034b76bf624ecaab38f16146074 Reviewed-on: https://go-review.googlesource.com/c/go/+/371474 Trust: Benny Siegert Reviewed-by: Benny Siegert Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot Reviewed-by: Austin Clements --- src/cmd/dist/metadata.go | 24 ++++++++++++++++++++++++ src/cmd/dist/metadata_bootstrap.go | 21 +++++++++++++++++++++ src/cmd/dist/sys_windows.go | 6 +++--- src/cmd/dist/test.go | 19 +++++++++++++++++++ 4 files changed, 67 insertions(+), 3 deletions(-) create mode 100644 src/cmd/dist/metadata.go create mode 100644 src/cmd/dist/metadata_bootstrap.go diff --git a/src/cmd/dist/metadata.go b/src/cmd/dist/metadata.go new file mode 100644 index 0000000000..f0a125fb8a --- /dev/null +++ b/src/cmd/dist/metadata.go @@ -0,0 +1,24 @@ +// 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. + +// Helper to print system metadata (CPU model, etc). This uses packages that +// may not be available in the bootstrap toolchain. It only needs to be built +// on the dist build using the final toolchain. + +//go:build go1.18 +// +build go1.18 + +package main + +import ( + "fmt" + "internal/sysinfo" + "runtime" +) + +func logMetadata() error { + fmt.Printf("# GOARCH: %s\n", runtime.GOARCH) + fmt.Printf("# CPU: %s\n", sysinfo.CPU.Name()) + return nil +} diff --git a/src/cmd/dist/metadata_bootstrap.go b/src/cmd/dist/metadata_bootstrap.go new file mode 100644 index 0000000000..fe5f422b0b --- /dev/null +++ b/src/cmd/dist/metadata_bootstrap.go @@ -0,0 +1,21 @@ +// 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. + +// No-op metadata implementation when building with an old bootstrap toolchain. + +//go:build !go1.18 +// +build !go1.18 + +package main + +import ( + "fmt" +) + +func logMetadata() error { + // We don't return an error so we don't completely preclude running + // tests with a bootstrap dist. + fmt.Printf("# Metadata unavailable: bootstrap build\n") + return nil +} diff --git a/src/cmd/dist/sys_windows.go b/src/cmd/dist/sys_windows.go index 265f729d0f..0fb66ad27d 100644 --- a/src/cmd/dist/sys_windows.go +++ b/src/cmd/dist/sys_windows.go @@ -38,11 +38,11 @@ const ( PROCESSOR_ARCHITECTURE_IA64 = 6 ) -var sysinfo systeminfo +var winsysinfo systeminfo func sysinit() { - syscall.Syscall(procGetSystemInfo.Addr(), 1, uintptr(unsafe.Pointer(&sysinfo)), 0, 0) - switch sysinfo.wProcessorArchitecture { + syscall.Syscall(procGetSystemInfo.Addr(), 1, uintptr(unsafe.Pointer(&winsysinfo)), 0, 0) + switch winsysinfo.wProcessorArchitecture { case PROCESSOR_ARCHITECTURE_AMD64: gohostarch = "amd64" case PROCESSOR_ARCHITECTURE_INTEL: diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go index 50a2e5936c..fed83120ed 100644 --- a/src/cmd/dist/test.go +++ b/src/cmd/dist/test.go @@ -218,6 +218,15 @@ func (t *tester) run() { } } + if err := t.maybeLogMetadata(); err != nil { + t.failed = true + if t.keepGoing { + log.Printf("Failed logging metadata: %v", err) + } else { + fatalf("Failed logging metadata: %v", err) + } + } + for _, dt := range t.tests { if !t.shouldRunTest(dt.name) { t.partial = true @@ -268,6 +277,16 @@ func (t *tester) shouldRunTest(name string) bool { return false } +func (t *tester) maybeLogMetadata() error { + if t.compileOnly { + // We need to run a subprocess to log metadata. Don't do that + // on compile-only runs. + return nil + } + t.out("Test execution environment.") + return logMetadata() +} + // short returns a -short flag value to use with 'go test' // or a test binary for tests intended to run in short mode. // It returns "true", unless the environment variable From 4f0c32de078b57958fa9c37c05bae4ee1f8193e5 Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Mon, 13 Dec 2021 17:34:16 -0500 Subject: [PATCH 639/752] cmd/dist: log OS version when testing As a follow-up to https://golang.org/cl/371474, add the OS version to the metadata printed for each test. Fixes #50146. Change-Id: I3b7e47983d0e85feebce8e424881b931882d53bf Reviewed-on: https://go-review.googlesource.com/c/go/+/371475 Reviewed-by: Bryan Mills Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot Reviewed-by: Austin Clements --- src/cmd/dist/metadata.go | 9 +++++++ src/cmd/internal/osinfo/doc.go | 6 +++++ src/cmd/internal/osinfo/os_js.go | 18 ++++++++++++++ src/cmd/internal/osinfo/os_plan9.go | 21 ++++++++++++++++ src/cmd/internal/osinfo/os_unix.go | 36 +++++++++++++++++++++++++++ src/cmd/internal/osinfo/os_windows.go | 19 ++++++++++++++ 6 files changed, 109 insertions(+) create mode 100644 src/cmd/internal/osinfo/doc.go create mode 100644 src/cmd/internal/osinfo/os_js.go create mode 100644 src/cmd/internal/osinfo/os_plan9.go create mode 100644 src/cmd/internal/osinfo/os_unix.go create mode 100644 src/cmd/internal/osinfo/os_windows.go diff --git a/src/cmd/dist/metadata.go b/src/cmd/dist/metadata.go index f0a125fb8a..76f108ea06 100644 --- a/src/cmd/dist/metadata.go +++ b/src/cmd/dist/metadata.go @@ -12,6 +12,7 @@ package main import ( + "cmd/internal/osinfo" "fmt" "internal/sysinfo" "runtime" @@ -20,5 +21,13 @@ import ( func logMetadata() error { fmt.Printf("# GOARCH: %s\n", runtime.GOARCH) fmt.Printf("# CPU: %s\n", sysinfo.CPU.Name()) + + fmt.Printf("# GOOS: %s\n", runtime.GOOS) + ver, err := osinfo.Version() + if err != nil { + return fmt.Errorf("error determining OS version: %v", err) + } + fmt.Printf("# OS Version: %s\n", ver) + return nil } diff --git a/src/cmd/internal/osinfo/doc.go b/src/cmd/internal/osinfo/doc.go new file mode 100644 index 0000000000..c2f74bea27 --- /dev/null +++ b/src/cmd/internal/osinfo/doc.go @@ -0,0 +1,6 @@ +// 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 osinfo provides OS metadata information. +package osinfo diff --git a/src/cmd/internal/osinfo/os_js.go b/src/cmd/internal/osinfo/os_js.go new file mode 100644 index 0000000000..8e86464cd8 --- /dev/null +++ b/src/cmd/internal/osinfo/os_js.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. + +//go:build js + +package osinfo + +import ( + "fmt" +) + +// Version returns the OS version name/number. +func Version() (string, error) { + // TODO(prattmic): Does wasm have any version/runtime detection + // functionality? + return "", fmt.Errorf("unimplemented") +} diff --git a/src/cmd/internal/osinfo/os_plan9.go b/src/cmd/internal/osinfo/os_plan9.go new file mode 100644 index 0000000000..ad1d324e5e --- /dev/null +++ b/src/cmd/internal/osinfo/os_plan9.go @@ -0,0 +1,21 @@ +// 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. + +//go:build plan9 + +package osinfo + +import ( + "os" +) + +// Version returns the OS version name/number. +func Version() (string, error) { + b, err := os.ReadFile("/dev/osversion") + if err != nil { + return "", err + } + + return string(b), nil +} diff --git a/src/cmd/internal/osinfo/os_unix.go b/src/cmd/internal/osinfo/os_unix.go new file mode 100644 index 0000000000..4587cb2501 --- /dev/null +++ b/src/cmd/internal/osinfo/os_unix.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. + +//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris + +package osinfo + +import ( + "bytes" + + "golang.org/x/sys/unix" +) + +func utsString(b []byte) string { + i := bytes.IndexByte(b, 0) + if i == -1 { + return string(b) + } + return string(b[:i]) +} + +// Version returns the OS version name/number. +func Version() (string, error) { + var uts unix.Utsname + if err := unix.Uname(&uts); err != nil { + return "", err + } + + sysname := utsString(uts.Sysname[:]) + release := utsString(uts.Release[:]) + version := utsString(uts.Version[:]) + machine := utsString(uts.Machine[:]) + + return sysname + " " + release + " " + version + " " + machine, nil +} diff --git a/src/cmd/internal/osinfo/os_windows.go b/src/cmd/internal/osinfo/os_windows.go new file mode 100644 index 0000000000..05fab9bb1e --- /dev/null +++ b/src/cmd/internal/osinfo/os_windows.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. + +//go:build windows + +package osinfo + +import ( + "fmt" + + "golang.org/x/sys/windows" +) + +// Version returns the OS version name/number. +func Version() (string, error) { + major, minor, patch := windows.RtlGetNtVersionNumbers() + return fmt.Sprintf("%d.%d.%d", major, minor, patch), nil +} From 07b995e5bba0c3fe04d6ba399c16abec485bcdaa Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Fri, 14 Jan 2022 15:22:10 -0500 Subject: [PATCH 640/752] Revert "cmd/dist: log OS version when testing" Fails TestAllDependencies. This reverts CL 371475. For #50146. Change-Id: I1feccd772d92d80e57c6327a4ac7b8af753a8c05 Reviewed-on: https://go-review.googlesource.com/c/go/+/378586 Reviewed-by: Bryan Mills Reviewed-by: Ian Lance Taylor Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot --- src/cmd/dist/metadata.go | 9 ------- src/cmd/internal/osinfo/doc.go | 6 ----- src/cmd/internal/osinfo/os_js.go | 18 -------------- src/cmd/internal/osinfo/os_plan9.go | 21 ---------------- src/cmd/internal/osinfo/os_unix.go | 36 --------------------------- src/cmd/internal/osinfo/os_windows.go | 19 -------------- 6 files changed, 109 deletions(-) delete mode 100644 src/cmd/internal/osinfo/doc.go delete mode 100644 src/cmd/internal/osinfo/os_js.go delete mode 100644 src/cmd/internal/osinfo/os_plan9.go delete mode 100644 src/cmd/internal/osinfo/os_unix.go delete mode 100644 src/cmd/internal/osinfo/os_windows.go diff --git a/src/cmd/dist/metadata.go b/src/cmd/dist/metadata.go index 76f108ea06..f0a125fb8a 100644 --- a/src/cmd/dist/metadata.go +++ b/src/cmd/dist/metadata.go @@ -12,7 +12,6 @@ package main import ( - "cmd/internal/osinfo" "fmt" "internal/sysinfo" "runtime" @@ -21,13 +20,5 @@ import ( func logMetadata() error { fmt.Printf("# GOARCH: %s\n", runtime.GOARCH) fmt.Printf("# CPU: %s\n", sysinfo.CPU.Name()) - - fmt.Printf("# GOOS: %s\n", runtime.GOOS) - ver, err := osinfo.Version() - if err != nil { - return fmt.Errorf("error determining OS version: %v", err) - } - fmt.Printf("# OS Version: %s\n", ver) - return nil } diff --git a/src/cmd/internal/osinfo/doc.go b/src/cmd/internal/osinfo/doc.go deleted file mode 100644 index c2f74bea27..0000000000 --- a/src/cmd/internal/osinfo/doc.go +++ /dev/null @@ -1,6 +0,0 @@ -// 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 osinfo provides OS metadata information. -package osinfo diff --git a/src/cmd/internal/osinfo/os_js.go b/src/cmd/internal/osinfo/os_js.go deleted file mode 100644 index 8e86464cd8..0000000000 --- a/src/cmd/internal/osinfo/os_js.go +++ /dev/null @@ -1,18 +0,0 @@ -// 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. - -//go:build js - -package osinfo - -import ( - "fmt" -) - -// Version returns the OS version name/number. -func Version() (string, error) { - // TODO(prattmic): Does wasm have any version/runtime detection - // functionality? - return "", fmt.Errorf("unimplemented") -} diff --git a/src/cmd/internal/osinfo/os_plan9.go b/src/cmd/internal/osinfo/os_plan9.go deleted file mode 100644 index ad1d324e5e..0000000000 --- a/src/cmd/internal/osinfo/os_plan9.go +++ /dev/null @@ -1,21 +0,0 @@ -// 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. - -//go:build plan9 - -package osinfo - -import ( - "os" -) - -// Version returns the OS version name/number. -func Version() (string, error) { - b, err := os.ReadFile("/dev/osversion") - if err != nil { - return "", err - } - - return string(b), nil -} diff --git a/src/cmd/internal/osinfo/os_unix.go b/src/cmd/internal/osinfo/os_unix.go deleted file mode 100644 index 4587cb2501..0000000000 --- a/src/cmd/internal/osinfo/os_unix.go +++ /dev/null @@ -1,36 +0,0 @@ -// 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. - -//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris - -package osinfo - -import ( - "bytes" - - "golang.org/x/sys/unix" -) - -func utsString(b []byte) string { - i := bytes.IndexByte(b, 0) - if i == -1 { - return string(b) - } - return string(b[:i]) -} - -// Version returns the OS version name/number. -func Version() (string, error) { - var uts unix.Utsname - if err := unix.Uname(&uts); err != nil { - return "", err - } - - sysname := utsString(uts.Sysname[:]) - release := utsString(uts.Release[:]) - version := utsString(uts.Version[:]) - machine := utsString(uts.Machine[:]) - - return sysname + " " + release + " " + version + " " + machine, nil -} diff --git a/src/cmd/internal/osinfo/os_windows.go b/src/cmd/internal/osinfo/os_windows.go deleted file mode 100644 index 05fab9bb1e..0000000000 --- a/src/cmd/internal/osinfo/os_windows.go +++ /dev/null @@ -1,19 +0,0 @@ -// 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. - -//go:build windows - -package osinfo - -import ( - "fmt" - - "golang.org/x/sys/windows" -) - -// Version returns the OS version name/number. -func Version() (string, error) { - major, minor, patch := windows.RtlGetNtVersionNumbers() - return fmt.Sprintf("%d.%d.%d", major, minor, patch), nil -} From a99c38d66381b2a6abbc0d9c88feb3f6291cb245 Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Fri, 14 Jan 2022 15:22:51 -0500 Subject: [PATCH 641/752] Revert "cmd/dist: log CPU model when testing" Fails TestRepeatBootstrap. This reverts CL 371474. For #50146. Change-Id: Ie4adda4e0229e153471301ca00fe2c1c694b4b2d Reviewed-on: https://go-review.googlesource.com/c/go/+/378587 Reviewed-by: Bryan Mills Reviewed-by: Ian Lance Taylor Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot --- src/cmd/dist/metadata.go | 24 ------------------------ src/cmd/dist/metadata_bootstrap.go | 21 --------------------- src/cmd/dist/sys_windows.go | 6 +++--- src/cmd/dist/test.go | 19 ------------------- 4 files changed, 3 insertions(+), 67 deletions(-) delete mode 100644 src/cmd/dist/metadata.go delete mode 100644 src/cmd/dist/metadata_bootstrap.go diff --git a/src/cmd/dist/metadata.go b/src/cmd/dist/metadata.go deleted file mode 100644 index f0a125fb8a..0000000000 --- a/src/cmd/dist/metadata.go +++ /dev/null @@ -1,24 +0,0 @@ -// 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. - -// Helper to print system metadata (CPU model, etc). This uses packages that -// may not be available in the bootstrap toolchain. It only needs to be built -// on the dist build using the final toolchain. - -//go:build go1.18 -// +build go1.18 - -package main - -import ( - "fmt" - "internal/sysinfo" - "runtime" -) - -func logMetadata() error { - fmt.Printf("# GOARCH: %s\n", runtime.GOARCH) - fmt.Printf("# CPU: %s\n", sysinfo.CPU.Name()) - return nil -} diff --git a/src/cmd/dist/metadata_bootstrap.go b/src/cmd/dist/metadata_bootstrap.go deleted file mode 100644 index fe5f422b0b..0000000000 --- a/src/cmd/dist/metadata_bootstrap.go +++ /dev/null @@ -1,21 +0,0 @@ -// 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. - -// No-op metadata implementation when building with an old bootstrap toolchain. - -//go:build !go1.18 -// +build !go1.18 - -package main - -import ( - "fmt" -) - -func logMetadata() error { - // We don't return an error so we don't completely preclude running - // tests with a bootstrap dist. - fmt.Printf("# Metadata unavailable: bootstrap build\n") - return nil -} diff --git a/src/cmd/dist/sys_windows.go b/src/cmd/dist/sys_windows.go index 0fb66ad27d..265f729d0f 100644 --- a/src/cmd/dist/sys_windows.go +++ b/src/cmd/dist/sys_windows.go @@ -38,11 +38,11 @@ const ( PROCESSOR_ARCHITECTURE_IA64 = 6 ) -var winsysinfo systeminfo +var sysinfo systeminfo func sysinit() { - syscall.Syscall(procGetSystemInfo.Addr(), 1, uintptr(unsafe.Pointer(&winsysinfo)), 0, 0) - switch winsysinfo.wProcessorArchitecture { + syscall.Syscall(procGetSystemInfo.Addr(), 1, uintptr(unsafe.Pointer(&sysinfo)), 0, 0) + switch sysinfo.wProcessorArchitecture { case PROCESSOR_ARCHITECTURE_AMD64: gohostarch = "amd64" case PROCESSOR_ARCHITECTURE_INTEL: diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go index fed83120ed..50a2e5936c 100644 --- a/src/cmd/dist/test.go +++ b/src/cmd/dist/test.go @@ -218,15 +218,6 @@ func (t *tester) run() { } } - if err := t.maybeLogMetadata(); err != nil { - t.failed = true - if t.keepGoing { - log.Printf("Failed logging metadata: %v", err) - } else { - fatalf("Failed logging metadata: %v", err) - } - } - for _, dt := range t.tests { if !t.shouldRunTest(dt.name) { t.partial = true @@ -277,16 +268,6 @@ func (t *tester) shouldRunTest(name string) bool { return false } -func (t *tester) maybeLogMetadata() error { - if t.compileOnly { - // We need to run a subprocess to log metadata. Don't do that - // on compile-only runs. - return nil - } - t.out("Test execution environment.") - return logMetadata() -} - // short returns a -short flag value to use with 'go test' // or a test binary for tests intended to run in short mode. // It returns "true", unless the environment variable From 3b5eec937018be98549dea7067964018f0e5824c Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Fri, 14 Jan 2022 13:11:36 -0500 Subject: [PATCH 642/752] runtime/race: be less picky about test run time Currently, there are two regexps in the race detector output tests that assume subtests will complete in < 1 second. This isn't necessary and very occasionally fails (on builders that are probably very loaded). Make these tests less picky about timing. Fixes #50612. Change-Id: Ib3f94d6c5dc37541dbeb06de71cf462a74af844b Reviewed-on: https://go-review.googlesource.com/c/go/+/378581 Trust: Austin Clements Run-TryBot: Austin Clements Reviewed-by: Ian Lance Taylor TryBot-Result: Gopher Robot --- src/runtime/race/output_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/runtime/race/output_test.go b/src/runtime/race/output_test.go index 46cdfcd0e9..0dcdabe641 100644 --- a/src/runtime/race/output_test.go +++ b/src/runtime/race/output_test.go @@ -207,7 +207,7 @@ func TestFail(t *testing.T) { } `, []string{` ================== ---- FAIL: TestFail \(0...s\) +--- FAIL: TestFail \([0-9.]+s\) .*main_test.go:14: true .*testing.go:.*: race detected during execution of test FAIL`}}, @@ -363,7 +363,7 @@ func TestPass(t *testing.T) { } `, []string{` ================== ---- FAIL: TestFail \(0...s\) +--- FAIL: TestFail \([0-9.]+s\) .*testing.go:.*: race detected during execution of test FAIL`}}, {"mutex", "run", "", "atexit_sleep_ms=0", ` From 897b3da2e079b9b940b309747305a5379fffa6ec Mon Sep 17 00:00:00 2001 From: eric fang Date: Wed, 5 Jan 2022 09:20:06 +0000 Subject: [PATCH 643/752] cmd/internal/obj/arm64: adjust rule for VMOVQ instruction The VMOVQ instruction stores a 128-bit number into a V register, for example: VMOVQ $0x1122334455667788, $0x99aabbccddeeff00, V2 From a documentation (https://pkg.go.dev/cmd/internal/obj/arm64) point of view, the value in V2 should be 0x112233445566778899aabbccddeeff00, however the value is actually 0x99aabbccddeeff001122334455667788. The reason is that we misplaced the high 64-bit and the low 64-bit in the literal pool. To maintain backward compatibility, this CL adjusts the rule of VMOVQ instruction to make the documentation consistent with the code. Fixes #50528 Change-Id: Ib51f59e97c55252ab2a50bbc6ba4d430732a7a04 Reviewed-on: https://go-review.googlesource.com/c/go/+/377055 Reviewed-by: Cherry Mui Reviewed-by: Eric Fang Run-TryBot: Eric Fang Trust: Eric Fang TryBot-Result: Gopher Robot --- src/cmd/internal/obj/arm64/asm7.go | 2 +- src/cmd/internal/obj/arm64/doc.go | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go index 68f0921d4d..f4111f4f5c 100644 --- a/src/cmd/internal/obj/arm64/asm7.go +++ b/src/cmd/internal/obj/arm64/asm7.go @@ -1184,7 +1184,7 @@ func (c *ctxt7) addpool128(p *obj.Prog, al, ah *obj.Addr) { q := c.newprog() q.As = ADWORD q.To.Type = obj.TYPE_CONST - q.To.Offset = al.Offset + q.To.Offset = al.Offset // q.Pc is lower than t.Pc, so al.Offset is stored in q. t := c.newprog() t.As = ADWORD diff --git a/src/cmd/internal/obj/arm64/doc.go b/src/cmd/internal/obj/arm64/doc.go index 14f0f4c616..1234a3e818 100644 --- a/src/cmd/internal/obj/arm64/doc.go +++ b/src/cmd/internal/obj/arm64/doc.go @@ -89,12 +89,12 @@ In the following example, PCALIGN at the entry of the function Add will align it 7. Move large constants to vector registers. Go asm uses VMOVQ/VMOVD/VMOVS to move 128-bit, 64-bit and 32-bit constants into vector registers, respectively. -And for a 128-bit interger, it take two 64-bit operands, for the high and low parts separately. +And for a 128-bit interger, it take two 64-bit operands, for the low and high parts separately. Examples: VMOVS $0x11223344, V0 VMOVD $0x1122334455667788, V1 - VMOVQ $0x1122334455667788, $8877665544332211, V2 // V2=0x11223344556677888877665544332211 + VMOVQ $0x1122334455667788, $0x99aabbccddeeff00, V2 // V2=0x99aabbccddeeff001122334455667788 8. Move an optionally-shifted 16-bit immediate value to a register. From 5b3ebc8b72f496a5c6892d76fdeee3d9029b55cc Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Sun, 16 Jan 2022 12:58:45 -0500 Subject: [PATCH 644/752] cmd/dist: avoid lapsing into x86 builds on ARM64 Macs We use uname -m to decide the GOHOSTARCH default, and on my ARM64 Mac laptop, uname -m prints x86_64. uname -a prints: Darwin p1.local 21.1.0 Darwin Kernel Version 21.1.0: Wed Oct 13 17:33:01 PDT 2021; root:xnu-8019.41.5~1/RELEASE_ARM64_T6000 x86_64 (Note the x86_64 at the end, consistent with uname -m.) The effect of this is that make.bash builds an x86 toolchain even when I start with an ARM64 bootstrap toolchain! Avoid being tricked by looking for RELEASE_ARM64 instead. Fixes #50643. Change-Id: I76eded84bde8009d29419d5982bf964a0bf1c8fd Reviewed-on: https://go-review.googlesource.com/c/go/+/378894 Trust: Russ Cox Reviewed-by: Ian Lance Taylor --- src/cmd/dist/main.go | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/cmd/dist/main.go b/src/cmd/dist/main.go index 37de1acc31..212d5cbe45 100644 --- a/src/cmd/dist/main.go +++ b/src/cmd/dist/main.go @@ -94,7 +94,15 @@ func main() { if gohostarch == "" { // Default Unix system. out := run("", CheckExit, "uname", "-m") + outAll := run("", CheckExit, "uname", "-a") switch { + case strings.Contains(outAll, "RELEASE_ARM64"): + // MacOS prints + // Darwin p1.local 21.1.0 Darwin Kernel Version 21.1.0: Wed Oct 13 17:33:01 PDT 2021; root:xnu-8019.41.5~1/RELEASE_ARM64_T6000 x86_64 + // on ARM64 laptops when there is an x86 parent in the + // process tree. Look for the RELEASE_ARM64 to avoid being + // confused into building an x86 toolchain. + gohostarch = "arm64" case strings.Contains(out, "x86_64"), strings.Contains(out, "amd64"): gohostarch = "amd64" case strings.Contains(out, "86"): From d54f6630703900948d9757487a1bffd87b7d36e2 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 14 Jan 2022 11:23:59 -0500 Subject: [PATCH 645/752] cmd/go: remove the -buildinfo flag Fixes #50501 (in a sense, by removing a flag that looks like it should do something it does not) Change-Id: I69ae4862706a6283cda4016fd43b361bb21557f9 Reviewed-on: https://go-review.googlesource.com/c/go/+/378576 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Russ Cox --- src/cmd/go/alldocs.go | 7 +------ src/cmd/go/go_test.go | 2 +- src/cmd/go/internal/cfg/cfg.go | 1 - src/cmd/go/internal/load/pkg.go | 2 +- src/cmd/go/internal/work/build.go | 8 +------- 5 files changed, 4 insertions(+), 16 deletions(-) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index 3bb9d146b2..1d3098a76e 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -135,11 +135,6 @@ // // -asmflags '[pattern=]arg list' // arguments to pass on each go tool asm invocation. -// -buildinfo -// Whether to stamp binaries with build flags. By default, the compiler name -// (gc or gccgo), toolchain flags (like -gcflags), and environment variables -// containing flags (like CGO_CFLAGS) are stamped into binaries. Use -// -buildinfo=false to omit build information. See also -buildvcs. // -buildmode mode // build mode to use. See 'go help buildmode' for more. // -buildvcs @@ -147,7 +142,7 @@ // version control information is stamped into a binary if the main package // and the main module containing it are in the repository containing the // current directory (if there is a repository). Use -buildvcs=false to -// omit version control information. See also -buildinfo. +// omit version control information. // -compiler name // name of compiler to use, as in runtime.Compiler (gccgo or gc). // -gccgoflags '[pattern=]arg list' diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go index 170c882df9..7aaec4eb98 100644 --- a/src/cmd/go/go_test.go +++ b/src/cmd/go/go_test.go @@ -1387,7 +1387,7 @@ func TestLdFlagsLongArgumentsIssue42295(t *testing.T) { for buf.Len() < sys.ExecArgLengthLimit+1 { buf.WriteString(testStr) } - tg.run("run", "-buildinfo=false", "-ldflags", fmt.Sprintf(`-X "main.extern=%s"`, buf.String()), tg.path("main.go")) + tg.run("run", "-ldflags", fmt.Sprintf(`-X "main.extern=%s"`, buf.String()), tg.path("main.go")) if tg.stderr.String() != buf.String() { t.Errorf("strings differ") } diff --git a/src/cmd/go/internal/cfg/cfg.go b/src/cmd/go/internal/cfg/cfg.go index 5b84d8be92..7f68d7bb62 100644 --- a/src/cmd/go/internal/cfg/cfg.go +++ b/src/cmd/go/internal/cfg/cfg.go @@ -25,7 +25,6 @@ import ( // These are general "build flags" used by build and other commands. var ( BuildA bool // -a flag - BuildBuildinfo bool // -buildinfo flag BuildBuildmode string // -buildmode flag BuildBuildvcs bool // -buildvcs flag BuildContext = defaultContext() diff --git a/src/cmd/go/internal/load/pkg.go b/src/cmd/go/internal/load/pkg.go index a891d601b1..fca9d5a0a2 100644 --- a/src/cmd/go/internal/load/pkg.go +++ b/src/cmd/go/internal/load/pkg.go @@ -2292,7 +2292,7 @@ func (p *Package) setBuildInfo() { // Add command-line flags relevant to the build. // This is informational, not an exhaustive list. // Please keep the list sorted. - if cfg.BuildBuildinfo && !p.Standard { + if !p.Standard { if cfg.BuildASan { appendSetting("-asan", "true") } diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go index 9b1acf987d..56648338c5 100644 --- a/src/cmd/go/internal/work/build.go +++ b/src/cmd/go/internal/work/build.go @@ -88,11 +88,6 @@ and test commands: -asmflags '[pattern=]arg list' arguments to pass on each go tool asm invocation. - -buildinfo - Whether to stamp binaries with build flags. By default, the compiler name - (gc or gccgo), toolchain flags (like -gcflags), and environment variables - containing flags (like CGO_CFLAGS) are stamped into binaries. Use - -buildinfo=false to omit build information. See also -buildvcs. -buildmode mode build mode to use. See 'go help buildmode' for more. -buildvcs @@ -100,7 +95,7 @@ and test commands: version control information is stamped into a binary if the main package and the main module containing it are in the repository containing the current directory (if there is a repository). Use -buildvcs=false to - omit version control information. See also -buildinfo. + omit version control information. -compiler name name of compiler to use, as in runtime.Compiler (gccgo or gc). -gccgoflags '[pattern=]arg list' @@ -317,7 +312,6 @@ func AddBuildFlags(cmd *base.Command, mask BuildFlagMask) { cmd.Flag.Var((*base.StringsFlag)(&cfg.BuildToolexec), "toolexec", "") cmd.Flag.BoolVar(&cfg.BuildTrimpath, "trimpath", false, "") cmd.Flag.BoolVar(&cfg.BuildWork, "work", false, "") - cmd.Flag.BoolVar(&cfg.BuildBuildinfo, "buildinfo", true, "") cmd.Flag.BoolVar(&cfg.BuildBuildvcs, "buildvcs", true, "") // Undocumented, unstable debugging flags. From ef4be98abd699c6f059dcac6dc6dfe5774cbf257 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Thu, 6 Jan 2022 16:51:10 -0800 Subject: [PATCH 646/752] cmd/compile: support field access for typeparam with structural constraint In the compiler, we need to distinguish field and method access on a type param. For field access, we avoid the dictionary access (to create an interface bound) and just do the normal transformDot() (which will create the field access on the shape type). This field access works fine for non-pointer types, since the shape type preserves the underlying type of all types in the shape. But we generally merge all pointer types into a single shape, which means the field will not be accessible via the shape type. So, we need to change Shapify() so that a type which is a pointer type is mapped to its underlying type, rather than being merged with other pointers. Because we don't want to change the export format at this point in the release, we need to compute StructuralType() directly in types1, rather than relying on types2. That implementation is in types/type.go, along with the helper specificTypes(). I enabled the compiler-related tests in issue50417.go, added an extra test for unnamed pointer types, and added a bunch more tests for interesting cases involving StructuralType(). I added a test issue50417b.go similar to the original example, but also tests access to an embedded field. I also added a unit test in cmd/compile/internal/types/structuraltype_test.go that tests a bunch of unusual cases directly (some of which have no structural type). Updates #50417 Change-Id: I77c55cbad98a2b95efbd4a02a026c07dfbb46caa Reviewed-on: https://go-review.googlesource.com/c/go/+/376194 Reviewed-by: Keith Randall Reviewed-by: Robert Griesemer Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/noder/stencil.go | 80 +++++--- .../compile/internal/reflectdata/reflect.go | 3 +- src/cmd/compile/internal/typecheck/crawler.go | 2 +- src/cmd/compile/internal/typecheck/subr.go | 9 +- .../compile/internal/types/structuraltype.go | 187 ++++++++++++++++++ .../internal/types/structuraltype_test.go | 135 +++++++++++++ src/go/internal/gcimporter/gcimporter_test.go | 5 +- test/run.go | 1 + test/typeparam/issue50417.go | 86 +++++++- test/typeparam/issue50417b.go | 50 +++++ 10 files changed, 512 insertions(+), 46 deletions(-) create mode 100644 src/cmd/compile/internal/types/structuraltype.go create mode 100644 src/cmd/compile/internal/types/structuraltype_test.go create mode 100644 test/typeparam/issue50417b.go diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go index e5f59d0286..66c73a9427 100644 --- a/src/cmd/compile/internal/noder/stencil.go +++ b/src/cmd/compile/internal/noder/stencil.go @@ -634,17 +634,38 @@ func (g *genInst) getInstantiation(nameNode *ir.Name, shapes []*types.Type, isMe checkFetchBody(nameNode) } + var tparams []*types.Type + if isMeth { + // Get the type params from the method receiver (after skipping + // over any pointer) + recvType := nameNode.Type().Recv().Type + recvType = deref(recvType) + tparams = recvType.RParams() + } else { + fields := nameNode.Type().TParams().Fields().Slice() + tparams = make([]*types.Type, len(fields)) + for i, f := range fields { + tparams[i] = f.Type + } + } + // Convert any non-shape type arguments to their shape, so we can reduce the // number of instantiations we have to generate. You can actually have a mix // of shape and non-shape arguments, because of inferred or explicitly // specified concrete type args. s1 := make([]*types.Type, len(shapes)) for i, t := range shapes { + var tparam *types.Type + if tparams[i].Kind() == types.TTYPEPARAM { + // Shapes are grouped differently for structural types, so we + // pass the type param to Shapify(), so we can distinguish. + tparam = tparams[i] + } if !t.IsShape() { - s1[i] = typecheck.Shapify(t, i) + s1[i] = typecheck.Shapify(t, i, tparam) } else { // Already a shape, but make sure it has the correct index. - s1[i] = typecheck.Shapify(shapes[i].Underlying(), i) + s1[i] = typecheck.Shapify(shapes[i].Underlying(), i, tparam) } } shapes = s1 @@ -675,7 +696,7 @@ func (g *genInst) getInstantiation(nameNode *ir.Name, shapes []*types.Type, isMe } // genericSubst fills in info.dictParam and info.shapeToBound. - st := g.genericSubst(sym, nameNode, shapes, isMeth, info) + st := g.genericSubst(sym, nameNode, tparams, shapes, isMeth, info) info.fun = st g.instInfoMap[sym] = info @@ -713,21 +734,7 @@ type subster struct { // function type where the receiver becomes the first parameter. For either a generic // method or function, a dictionary parameter is the added as the very first // parameter. genericSubst fills in info.dictParam and info.shapeToBound. -func (g *genInst) genericSubst(newsym *types.Sym, nameNode *ir.Name, shapes []*types.Type, isMethod bool, info *instInfo) *ir.Func { - var tparams []*types.Type - if isMethod { - // Get the type params from the method receiver (after skipping - // over any pointer) - recvType := nameNode.Type().Recv().Type - recvType = deref(recvType) - tparams = recvType.RParams() - } else { - fields := nameNode.Type().TParams().Fields().Slice() - tparams = make([]*types.Type, len(fields)) - for i, f := range fields { - tparams[i] = f.Type - } - } +func (g *genInst) genericSubst(newsym *types.Sym, nameNode *ir.Name, tparams []*types.Type, shapes []*types.Type, isMethod bool, info *instInfo) *ir.Func { gf := nameNode.Func // Pos of the instantiated function is same as the generic function newf := ir.NewFunc(gf.Pos()) @@ -1208,31 +1215,40 @@ func (g *genInst) dictPass(info *instInfo) { ir.CurFunc = info.fun case ir.OXDOT: + // This is the case of a dot access on a type param. This is + // typically a bound call on the type param, but could be a + // field access, if the constraint has a single structural type. mse := m.(*ir.SelectorExpr) src := mse.X.Type() assert(src.IsShape()) - // The only dot on a shape type value are methods. if mse.X.Op() == ir.OTYPE { // Method expression T.M m = g.buildClosure2(info, m) // No need for transformDot - buildClosure2 has already // transformed to OCALLINTER/ODOTINTER. } else { - // Implement x.M as a conversion-to-bound-interface - // 1) convert x to the bound interface - // 2) call M on that interface dst := info.dictInfo.shapeToBound[m.(*ir.SelectorExpr).X.Type()] - if src.IsInterface() { - // If type arg is an interface (unusual case), - // we do a type assert to the type bound. - mse.X = assertToBound(info, info.dictParam, m.Pos(), mse.X, dst) - } else { - mse.X = convertUsingDictionary(info, info.dictParam, m.Pos(), mse.X, m, dst, true) - // Note: we set nonEscaping==true, because we can assume the backing store for the - // interface conversion doesn't escape. The method call will immediately go to - // a wrapper function which copies all the data out of the interface value. - // (It only matters for non-pointer-shaped interface conversions. See issue 50182.) + // If we can't find the selected method in the + // AllMethods of the bound, then this must be an access + // to a field of a structural type. If so, we skip the + // dictionary lookups - transformDot() will convert to + // the desired direct field access. + if typecheck.Lookdot1(mse, mse.Sel, dst, dst.AllMethods(), 1) != nil { + // Implement x.M as a conversion-to-bound-interface + // 1) convert x to the bound interface + // 2) call M on that interface + if src.IsInterface() { + // If type arg is an interface (unusual case), + // we do a type assert to the type bound. + mse.X = assertToBound(info, info.dictParam, m.Pos(), mse.X, dst) + } else { + mse.X = convertUsingDictionary(info, info.dictParam, m.Pos(), mse.X, m, dst, true) + // Note: we set nonEscaping==true, because we can assume the backing store for the + // interface conversion doesn't escape. The method call will immediately go to + // a wrapper function which copies all the data out of the interface value. + // (It only matters for non-pointer-shaped interface conversions. See issue 50182.) + } } transformDot(mse, false) } diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go index eb1d7b0e07..42ea7bac46 100644 --- a/src/cmd/compile/internal/reflectdata/reflect.go +++ b/src/cmd/compile/internal/reflectdata/reflect.go @@ -1921,8 +1921,9 @@ func methodWrapper(rcvr *types.Type, method *types.Field, forItab bool) *obj.LSy // Target method uses shaped names. targs2 := make([]*types.Type, len(targs)) + origRParams := deref(orig).OrigSym().Def.(*ir.Name).Type().RParams() for i, t := range targs { - targs2[i] = typecheck.Shapify(t, i) + targs2[i] = typecheck.Shapify(t, i, origRParams[i]) } targs = targs2 diff --git a/src/cmd/compile/internal/typecheck/crawler.go b/src/cmd/compile/internal/typecheck/crawler.go index a25c741488..4394c6e698 100644 --- a/src/cmd/compile/internal/typecheck/crawler.go +++ b/src/cmd/compile/internal/typecheck/crawler.go @@ -232,7 +232,7 @@ func (p *crawler) checkForFullyInst(t *types.Type) { baseType := t.OrigSym().Def.(*ir.Name).Type() shapes := make([]*types.Type, len(t.RParams())) for i, t1 := range t.RParams() { - shapes[i] = Shapify(t1, i) + shapes[i] = Shapify(t1, i, baseType.RParams()[i]) } for j := range t.Methods().Slice() { baseNname := baseType.Methods().Slice()[j].Nname.(*ir.Name) diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go index 04a4ed392f..9f6966233d 100644 --- a/src/cmd/compile/internal/typecheck/subr.go +++ b/src/cmd/compile/internal/typecheck/subr.go @@ -1430,11 +1430,15 @@ func genericTypeName(sym *types.Sym) string { // For now, we only consider two types to have the same shape, if they have exactly // the same underlying type or they are both pointer types. // +// tparam is the associated typeparam. If there is a structural type for +// the associated type param (not common), then a pointer type t is mapped to its +// underlying type, rather than being merged with other pointers. +// // Shape types are also distinguished by the index of the type in a type param/arg // list. We need to do this so we can distinguish and substitute properly for two // type params in the same function that have the same shape for a particular // instantiation. -func Shapify(t *types.Type, index int) *types.Type { +func Shapify(t *types.Type, index int, tparam *types.Type) *types.Type { assert(!t.IsShape()) // Map all types with the same underlying type to the same shape. u := t.Underlying() @@ -1443,7 +1447,8 @@ func Shapify(t *types.Type, index int) *types.Type { // TODO: Make unsafe.Pointer the same shape as normal pointers. // Note: pointers to arrays are special because of slice-to-array-pointer // conversions. See issue 49295. - if u.Kind() == types.TPTR && u.Elem().Kind() != types.TARRAY { + if u.Kind() == types.TPTR && u.Elem().Kind() != types.TARRAY && + tparam.Bound().StructuralType() == nil { u = types.Types[types.TUINT8].PtrTo() } diff --git a/src/cmd/compile/internal/types/structuraltype.go b/src/cmd/compile/internal/types/structuraltype.go new file mode 100644 index 0000000000..2d49e77aae --- /dev/null +++ b/src/cmd/compile/internal/types/structuraltype.go @@ -0,0 +1,187 @@ +package types + +// Implementation of structural type computation for types. + +// TODO: we would like to depend only on the types2 computation of structural type, +// but we can only do that the next time we change the export format and export +// structural type info along with each constraint type, since the compiler imports +// types directly into types1 format. + +// A term describes elementary type sets: +// +// term{false, T} set of type T +// term{true, T} set of types with underlying type t +// term{} empty set (we specifically check for typ == nil) +type term struct { + tilde bool + typ *Type +} + +// StructuralType returns the structural type of an interface, or nil if it has no +// structural type. +func (t *Type) StructuralType() *Type { + sts, _ := specificTypes(t) + var su *Type + for _, st := range sts { + u := st.typ.Underlying() + if su != nil { + u = match(su, u) + if u == nil { + return nil + } + } + // su == nil || match(su, u) != nil + su = u + } + return su +} + +// If x and y are identical, match returns x. +// If x and y are identical channels but for their direction +// and one of them is unrestricted, match returns the channel +// with the restricted direction. +// In all other cases, match returns nil. +// x and y are assumed to be underlying types, hence are not named types. +func match(x, y *Type) *Type { + if IdenticalStrict(x, y) { + return x + } + + if x.IsChan() && y.IsChan() && IdenticalStrict(x.Elem(), y.Elem()) { + // We have channels that differ in direction only. + // If there's an unrestricted channel, select the restricted one. + // If both have the same direction, return x (either is fine). + switch { + case x.ChanDir().CanSend() && x.ChanDir().CanRecv(): + return y + case y.ChanDir().CanSend() && y.ChanDir().CanRecv(): + return x + } + } + return nil +} + +// specificTypes returns the list of specific types of an interface type or nil if +// there are none. It also returns a flag that indicates, for an empty term list +// result, whether it represents the empty set, or the infinite set of all types (in +// both cases, there are no specific types). +func specificTypes(t *Type) (list []term, inf bool) { + t.wantEtype(TINTER) + + // We have infinite term list before processing any type elements + // (or if there are no type elements). + inf = true + for _, m := range t.Methods().Slice() { + var r2 []term + inf2 := false + + switch { + case m.IsMethod(): + inf2 = true + + case m.Type.IsUnion(): + nt := m.Type.NumTerms() + for i := 0; i < nt; i++ { + t, tilde := m.Type.Term(i) + if t.IsInterface() { + r3, r3inf := specificTypes(t) + if r3inf { + // Union with an infinite set of types is + // infinite, so skip remaining terms. + r2 = nil + inf2 = true + break + } + // Add the elements of r3 to r2. + for _, r3e := range r3 { + r2 = insertType(r2, r3e) + } + } else { + r2 = insertType(r2, term{tilde, t}) + } + } + + case m.Type.IsInterface(): + r2, inf2 = specificTypes(m.Type) + + default: + // m.Type is a single non-interface type, so r2 is just a + // one-element list, inf2 is false. + r2 = []term{term{false, m.Type}} + } + + if inf2 { + // If the current type element has infinite types, + // its intersection with r is just r, so skip this type element. + continue + } + + if inf { + // If r is infinite, then the intersection of r and r2 is just r2. + list = r2 + inf = false + continue + } + + // r and r2 are finite, so intersect r and r2. + var r3 []term + for _, re := range list { + for _, r2e := range r2 { + if tm := intersect(re, r2e); tm.typ != nil { + r3 = append(r3, tm) + } + } + } + list = r3 + } + return +} + +// insertType adds t to the returned list if it is not already in list. +func insertType(list []term, tm term) []term { + for i, elt := range list { + if new := union(elt, tm); new.typ != nil { + // Replace existing elt with the union of elt and new. + list[i] = new + return list + } + } + return append(list, tm) +} + +// If x and y are disjoint, return term with nil typ (which means the union should +// include both types). If x and y are not disjoint, return the single type which is +// the union of x and y. +func union(x, y term) term { + if disjoint(x, y) { + return term{false, nil} + } + if x.tilde || !y.tilde { + return x + } + return y +} + +// intersect returns the intersection x ∩ y. +func intersect(x, y term) term { + if disjoint(x, y) { + return term{false, nil} + } + if !x.tilde || y.tilde { + return x + } + return y +} + +// disjoint reports whether x ∩ y == ∅. +func disjoint(x, y term) bool { + ux := x.typ + if y.tilde { + ux = ux.Underlying() + } + uy := y.typ + if x.tilde { + uy = uy.Underlying() + } + return !IdenticalStrict(ux, uy) +} diff --git a/src/cmd/compile/internal/types/structuraltype_test.go b/src/cmd/compile/internal/types/structuraltype_test.go new file mode 100644 index 0000000000..fc34458338 --- /dev/null +++ b/src/cmd/compile/internal/types/structuraltype_test.go @@ -0,0 +1,135 @@ +// Copyright 2022 The Go 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 StructuralType() calculates the correct value of structural type for +// unusual cases. + +package types + +import ( + "cmd/internal/src" + "testing" +) + +type test struct { + typ *Type + structuralType *Type +} + +func TestStructuralType(t *testing.T) { + // These are the few constants that need to be initialized in order to use + // the types package without using the typecheck package by calling + // typecheck.InitUniverse() (the normal way to initialize the types package). + PtrSize = 8 + RegSize = 8 + MaxWidth = 1 << 50 + + // type intType = int + intType := newType(TINT) + // type structf = struct { f int } + structf := NewStruct(nil, []*Field{ + NewField(src.NoXPos, LocalPkg.Lookup("f"), intType), + }) + + // type Sf structf + Sf := newType(TFORW) + Sf.sym = LocalPkg.Lookup("Sf") + Sf.SetUnderlying(structf) + + // type A int + A := newType(TFORW) + A.sym = LocalPkg.Lookup("A") + A.SetUnderlying(intType) + + // type B int + B := newType(TFORW) + B.sym = LocalPkg.Lookup("B") + B.SetUnderlying(intType) + + emptyInterface := NewInterface(BuiltinPkg, []*Field{}, false) + any := newType(TFORW) + any.sym = LocalPkg.Lookup("any") + any.SetUnderlying(emptyInterface) + + // The tests marked NONE have no structural type; all the others have a + // structural type of structf - "struct { f int }" + tests := []*test{ + { + // interface { struct { f int } } + embed(structf), + structf, + }, + { + // interface { struct { f int }; any } + embed(structf, any), + structf, + }, + { + // interface { Sf } + embed(Sf), + structf, + }, + { + // interface { any | Sf } + embed(any, Sf), + structf, + }, + { + // interface { struct { f int }; Sf } - NONE + embed(structf, Sf), + nil, + }, + { + // interface { struct { f int } | ~struct { f int } } + embed(NewUnion([]*Type{structf, structf}, []bool{false, true})), + structf, + }, + { + // interface { ~struct { f int } ; Sf } + embed(NewUnion([]*Type{structf}, []bool{true}), Sf), + structf, + }, + { + // interface { struct { f int } ; Sf } - NONE + embed(NewUnion([]*Type{structf}, []bool{false}), Sf), + nil, + }, + { + // interface { Sf | A; B | Sf} + embed(NewUnion([]*Type{Sf, A}, []bool{false, false}), + NewUnion([]*Type{B, Sf}, []bool{false, false})), + structf, + }, + { + // interface { Sf | A; A | Sf } - NONE + embed(NewUnion([]*Type{Sf, A}, []bool{false, false}), + NewUnion([]*Type{A, Sf}, []bool{false, false})), + nil, + }, + { + // interface { Sf | any } - NONE + embed(NewUnion([]*Type{Sf, any}, []bool{false, false})), + nil, + }, + { + // interface { Sf | any; Sf } + embed(NewUnion([]*Type{Sf, any}, []bool{false, false}), Sf), + structf, + }, + } + for _, tst := range tests { + if got, want := tst.typ.StructuralType(), tst.structuralType; got != want { + t.Errorf("StructuralType(%v) = %v, wanted %v", + tst.typ, got, want) + } + } +} + +func embed(types ...*Type) *Type { + fields := make([]*Field, len(types)) + for i, t := range types { + fields[i] = NewField(src.NoXPos, nil, t) + } + return NewInterface(LocalPkg, fields, false) +} diff --git a/src/go/internal/gcimporter/gcimporter_test.go b/src/go/internal/gcimporter/gcimporter_test.go index 15a7b176bb..c9c5946d9f 100644 --- a/src/go/internal/gcimporter/gcimporter_test.go +++ b/src/go/internal/gcimporter/gcimporter_test.go @@ -169,8 +169,9 @@ func TestImportTypeparamTests(t *testing.T) { } skip := map[string]string{ - "equal.go": "inconsistent embedded sorting", // TODO(rfindley): investigate this. - "nested.go": "fails to compile", // TODO(rfindley): investigate this. + "equal.go": "inconsistent embedded sorting", // TODO(rfindley): investigate this. + "nested.go": "fails to compile", // TODO(rfindley): investigate this. + "issue50417.go": "inconsistent interface member sorting", } for _, entry := range list { diff --git a/test/run.go b/test/run.go index 75073993b8..2a7f080f9d 100644 --- a/test/run.go +++ b/test/run.go @@ -2178,6 +2178,7 @@ var unifiedFailures = setOf( "typeparam/typeswitch2.go", // duplicate case failure due to stenciling "typeparam/typeswitch3.go", // duplicate case failure due to stenciling "typeparam/typeswitch4.go", // duplicate case failure due to stenciling + "typeparam/issue50417b.go", // Need to handle field access on a type param "typeparam/issue50552.go", // gives missing method for instantiated type ) diff --git a/test/typeparam/issue50417.go b/test/typeparam/issue50417.go index f6cf73b18f..cd46f3feab 100644 --- a/test/typeparam/issue50417.go +++ b/test/typeparam/issue50417.go @@ -22,12 +22,11 @@ func f0t[P ~struct{ f int }](p P) { p.f = 0 } -// TODO(danscales) enable once the compiler is fixed -// var _ = f0[Sf] -// var _ = f0t[Sf] +var _ = f0[Sf] +var _ = f0t[Sf] func f1[P interface { - Sf + ~struct{ f int } m() }](p P) { _ = p.f @@ -35,6 +34,8 @@ func f1[P interface { p.m() } +var _ = f1[Sfm] + type Sm struct{} func (Sm) m() {} @@ -54,8 +55,7 @@ func f2[P interface { p.m() } -// TODO(danscales) enable once the compiler is fixed -// var _ = f2[Sfm] +var _ = f2[Sfm] // special case: structural type is a named pointer type @@ -66,5 +66,75 @@ func f3[P interface{ PSfm }](p P) { p.f = 0 } -// TODO(danscales) enable once the compiler is fixed -// var _ = f3[PSfm] +var _ = f3[PSfm] + +// special case: structural type is an unnamed pointer type + +func f4[P interface{ *Sfm }](p P) { + _ = p.f + p.f = 0 +} + +var _ = f4[*Sfm] + +type A int +type B int +type C float64 + +type Int interface { + *Sf | A + *Sf | B +} + +func f5[P Int](p P) { + _ = p.f + p.f = 0 +} + +var _ = f5[*Sf] + +type Int2 interface { + *Sf | A + any + *Sf | C +} + +func f6[P Int2](p P) { + _ = p.f + p.f = 0 +} + +var _ = f6[*Sf] + +type Int3 interface { + Sf + ~struct{ f int } +} + +func f7[P Int3](p P) { + _ = p.f + p.f = 0 +} + +var _ = f7[Sf] + +type Em1 interface { + *Sf | A +} + +type Em2 interface { + *Sf | B +} + +type Int4 interface { + Em1 + Em2 + any +} + +func f8[P Int4](p P) { + _ = p.f + p.f = 0 +} + +var _ = f8[*Sf] diff --git a/test/typeparam/issue50417b.go b/test/typeparam/issue50417b.go new file mode 100644 index 0000000000..e6b205cb37 --- /dev/null +++ b/test/typeparam/issue50417b.go @@ -0,0 +1,50 @@ +// run -gcflags=-G=3 + +// Copyright 2022 The Go 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 MyStruct struct { + b1, b2 string + E +} + +type E struct { + val int +} + +type C interface { + ~struct { + b1, b2 string + E + } +} + +func f[T C]() T { + var x T = T{ + b1: "a", + b2: "b", + } + + if got, want := x.b2, "b"; got != want { + panic(fmt.Sprintf("got %d, want %d", got, want)) + } + x.b1 = "y" + x.val = 5 + + return x +} + +func main() { + x := f[MyStruct]() + if got, want := x.b1, "y"; got != want { + panic(fmt.Sprintf("got %d, want %d", got, want)) + } + if got, want := x.val, 5; got != want { + panic(fmt.Sprintf("got %d, want %d", got, want)) + } +} From 75bcdd59635a33e2a210ef6b02f5e3814571de4b Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Tue, 18 Jan 2022 12:21:18 -0500 Subject: [PATCH 647/752] net/http: skip TestClientTimeout_Headers_h{1,2} on windows/arm and windows/arm64 This extends the skip added in CL 375635 to the "_Headers" variant of the test, since we have observed similar failures in that variant on the builders. For #43120 Change-Id: Ib1c97fbb776b576271629272f3194da77913a941 Reviewed-on: https://go-review.googlesource.com/c/go/+/379156 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Damien Neil --- src/net/http/client_test.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/net/http/client_test.go b/src/net/http/client_test.go index ea59f68f35..e91d526824 100644 --- a/src/net/http/client_test.go +++ b/src/net/http/client_test.go @@ -1339,6 +1339,9 @@ func testClientTimeout_Headers(t *testing.T, h2 bool) { t.Error("net.Error.Timeout = false; want true") } if got := ne.Error(); !strings.Contains(got, "Client.Timeout exceeded") { + if runtime.GOOS == "windows" && strings.HasPrefix(runtime.GOARCH, "arm") { + testenv.SkipFlaky(t, 43120) + } t.Errorf("error string = %q; missing timeout substring", got) } } From 46f138f288cf5c8a34cf5688cb6bea9deafb4f84 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 18 Jan 2022 10:49:57 -0500 Subject: [PATCH 648/752] cmd/compile, go/types: fix checking of bad type switch Consider the following program: package p func f() { x := 1 v := 2 switch v.(type) { case int: println(x) println(x / 0) case 1: } } Before this CL, the compiler prints: x.go:4:2: x declared but not used x.go:6:9: v (variable of type int) is not an interface x is in fact used, and other errors in the switch go undiagnosed. This commit fixes that problem by processing the switch statement even when the 'not an interface' error is reported. Now the compiler drops the spurious 'declared but not used' and adds two previously undiagnosed problems: x.go:6:9: v (variable of type int) is not an interface x.go:9:15: invalid operation: division by zero x.go:10:7: 1 is not a type go/types was printing roughly the same thing the compiler did before, and now still prints roughly the same thing the compiler does after. (The only differences are in the exact reported columns.) Fixes #50493. Change-Id: I317883f29077b1b4bbd0e8793617fd3bb31aa0f8 Reviewed-on: https://go-review.googlesource.com/c/go/+/379117 Trust: Russ Cox Run-TryBot: Russ Cox Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/stmt.go | 15 ++++++++------- .../internal/types2/testdata/check/stmt0.src | 14 +++++++++++++- src/go/types/stmt.go | 14 +++++++------- src/go/types/testdata/check/stmt0.src | 14 +++++++++++++- 4 files changed, 41 insertions(+), 16 deletions(-) diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go index ae9cc69c99..98244cd5e9 100644 --- a/src/cmd/compile/internal/types2/stmt.go +++ b/src/cmd/compile/internal/types2/stmt.go @@ -305,7 +305,7 @@ L: } } seen[T] = e - if T != nil { + if T != nil && xtyp != nil { check.typeAssertion(e, x, xtyp, T, true) } } @@ -733,15 +733,16 @@ func (check *Checker) typeSwitchStmt(inner stmtContext, s *syntax.SwitchStmt, gu if x.mode == invalid { return } + // TODO(gri) we may want to permit type switches on type parameter values at some point + var xtyp *Interface if isTypeParam(x.typ) { check.errorf(&x, "cannot use type switch on type parameter value %s", &x) - return - } - xtyp, _ := under(x.typ).(*Interface) - if xtyp == nil { - check.errorf(&x, "%s is not an interface", &x) - return + } else { + xtyp, _ = under(x.typ).(*Interface) + if xtyp == nil { + check.errorf(&x, "%s is not an interface", &x) + } } check.multipleSwitchDefaults(s.Body) diff --git a/src/cmd/compile/internal/types2/testdata/check/stmt0.src b/src/cmd/compile/internal/types2/testdata/check/stmt0.src index 8b18d676ac..c4820c9f7f 100644 --- a/src/cmd/compile/internal/types2/testdata/check/stmt0.src +++ b/src/cmd/compile/internal/types2/testdata/check/stmt0.src @@ -695,7 +695,7 @@ func typeswitches() { _ = y } - switch x := i /* ERROR "not an interface" */ .(type) {} + switch /* ERROR "x declared but not used" */ x := i /* ERROR "not an interface" */ .(type) {} switch t := x.(type) { case nil: @@ -719,6 +719,18 @@ func typeswitches() { case T2 /* ERROR "wrong type for method m" */ : case I2 /* STRICT "wrong type for method m" */ : // only an error in strict mode (issue 8561) } + + + { + x := 1 + v := 2 + switch v /* ERROR "v [(]variable of type int[)] is not an interface" */ .(type) { + case int: + println(x) + println(x / /* ERROR "invalid operation: division by zero" */ 0) + case /* ERROR "1 is not a type" */ 1: + } + } } // Test that each case clause uses the correct type of the variable diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go index 8621d2800a..0a69789078 100644 --- a/src/go/types/stmt.go +++ b/src/go/types/stmt.go @@ -310,7 +310,7 @@ L: } } seen[T] = e - if T != nil { + if T != nil && xtyp != nil { check.typeAssertion(e, x, xtyp, T) } } @@ -686,14 +686,14 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) { return } // TODO(gri) we may want to permit type switches on type parameter values at some point + var xtyp *Interface if isTypeParam(x.typ) { check.errorf(&x, _InvalidTypeSwitch, "cannot use type switch on type parameter value %s", &x) - return - } - xtyp, _ := under(x.typ).(*Interface) - if xtyp == nil { - check.errorf(&x, _InvalidTypeSwitch, "%s is not an interface", &x) - return + } else { + xtyp, _ = under(x.typ).(*Interface) + if xtyp == nil { + check.errorf(&x, _InvalidTypeSwitch, "%s is not an interface", &x) + } } check.multipleDefaults(s.Body.List) diff --git a/src/go/types/testdata/check/stmt0.src b/src/go/types/testdata/check/stmt0.src index c7a718de70..a635af7cbb 100644 --- a/src/go/types/testdata/check/stmt0.src +++ b/src/go/types/testdata/check/stmt0.src @@ -695,7 +695,7 @@ func typeswitches() { _ = y } - switch x := i /* ERROR "not an interface" */ .(type) {} + switch x /* ERROR "x declared but not used" */ := i /* ERROR "not an interface" */ .(type) {} switch t := x.(type) { case nil: @@ -719,6 +719,18 @@ func typeswitches() { case T2 /* ERROR "wrong type for method m" */ : case I2 /* STRICT "wrong type for method m" */ : // only an error in strict mode (issue 8561) } + + + { + x := 1 + v := 2 + switch v /* ERROR "v [(]variable of type int[)] is not an interface" */ .(type) { + case int: + println(x) + println(x / 0 /* ERROR "invalid operation: division by zero" */) + case 1 /* ERROR "expected type, found 1" */: + } + } } // Test that each case clause uses the correct type of the variable From 71888fe4b0d804f44371944f93f12442a6b0a862 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 14 Jan 2022 11:46:42 -0500 Subject: [PATCH 649/752] doc/go1.18: add a release note for 'go mod tidy' checksum changes MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Updates #47738 Fixes #49598 Change-Id: I708dcb880a701699116227a9eaca994cf460fef9 Reviewed-on: https://go-review.googlesource.com/c/go/+/378577 Trust: Bryan Mills Run-TryBot: Bryan Mills Trust: Daniel Martí Reviewed-by: Daniel Martí TryBot-Result: Gopher Robot --- doc/go1.18.html | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index f23f2b8562..133bfe0ef2 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -300,6 +300,16 @@ Do not send CLs removing the interior tags from such phrases. option -fsanitize=address).

    +

    + The go mod tidy command now retains + additional checksums in the go.sum file for modules whose source + code is needed to verify that each imported package is provided by only one + module in the build list. Because this + condition is rare and failure to apply it results in a build error, this + change is not conditioned on the go version in the main + module's go.mod file. +

    +

    The go command now supports a "Workspace" mode. If a go.work file is found in the working directory or a From cf5d73e8a2ba8d382278c7f490db61e513768159 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 18 Jan 2022 10:31:59 -0500 Subject: [PATCH 650/752] cmd/compile, go/types: restore 'too many return values' error for func with no results Currently the code handles the case of returning values from a function with no result parameters as a special case. Consider this input: package p func f0_2() { return 1, 2 } func f0_1() { return 1 } func f1_0() int { return } func f1_2() int { return 1, 2 } func f2_0() (int, int) { return } func f2_1() (int, int) { return 1 } The errors are: x.go:3:33: no result values expected <<< x.go:4:33: no result values expected <<< x.go:5:26: not enough return values have () want (int) x.go:6:36: too many return values have (number, number) want (int) x.go:7:26: not enough return values have () want (int, int) x.go:8:33: not enough return values have (number) want (int, int) There are two problems with the current special case emitting the errors on the marked line: 1. It calls them 'result values' instead of 'return values'. 2. It doesn't show the type being returned, which can be useful to programmers. Using the general case solves both these problems, so this CL removes the special case and calls the general case instead. Now those two errors read: x.go:3:33: too many return values have (number, number) want () x.go:4:33: too many return values have (number) want () Fixes #50653. Change-Id: If6b47dcece14ed4febb3a2d3d78270d5be1cb24d Reviewed-on: https://go-review.googlesource.com/c/go/+/379116 Trust: Russ Cox Run-TryBot: Russ Cox Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/stmt.go | 40 +++++++++---------- .../internal/types2/testdata/check/stmt0.src | 2 +- .../types2/testdata/check/vardecl.src | 4 +- src/go/types/stmt.go | 36 ++++++++--------- src/go/types/testdata/check/stmt0.src | 2 +- src/go/types/testdata/check/vardecl.src | 4 +- test/fixedbugs/issue4215.go | 2 +- test/fixedbugs/issue48834.go | 2 +- 8 files changed, 44 insertions(+), 48 deletions(-) diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go index 98244cd5e9..b23d7aeef2 100644 --- a/src/cmd/compile/internal/types2/stmt.go +++ b/src/cmd/compile/internal/types2/stmt.go @@ -474,30 +474,28 @@ func (check *Checker) stmt(ctxt stmtContext, s syntax.Stmt) { case *syntax.ReturnStmt: res := check.sig.results + // Return with implicit results allowed for function with named results. + // (If one is named, all are named.) results := unpackExpr(s.Results) - if res.Len() > 0 { - // function returns results - // (if one, say the first, result parameter is named, all of them are named) - if len(results) == 0 && res.vars[0].name != "" { - // spec: "Implementation restriction: A compiler may disallow an empty expression - // list in a "return" statement if a different entity (constant, type, or variable) - // with the same name as a result parameter is in scope at the place of the return." - for _, obj := range res.vars { - if alt := check.lookup(obj.name); alt != nil && alt != obj { - var err error_ - err.errorf(s, "result parameter %s not in scope at return", obj.name) - err.errorf(alt, "inner declaration of %s", obj) - check.report(&err) - // ok to continue - } + if len(results) == 0 && res.Len() > 0 && res.vars[0].name != "" { + // spec: "Implementation restriction: A compiler may disallow an empty expression + // list in a "return" statement if a different entity (constant, type, or variable) + // with the same name as a result parameter is in scope at the place of the return." + for _, obj := range res.vars { + if alt := check.lookup(obj.name); alt != nil && alt != obj { + var err error_ + err.errorf(s, "result parameter %s not in scope at return", obj.name) + err.errorf(alt, "inner declaration of %s", obj) + check.report(&err) + // ok to continue } - } else { - // return has results or result parameters are unnamed - check.initVars(res.vars, results, s) } - } else if len(results) > 0 { - check.error(results[0], "no result values expected") - check.use(results...) + } else { + var lhs []*Var + if res.Len() > 0 { + lhs = res.vars + } + check.initVars(lhs, results, s) } case *syntax.BranchStmt: diff --git a/src/cmd/compile/internal/types2/testdata/check/stmt0.src b/src/cmd/compile/internal/types2/testdata/check/stmt0.src index c4820c9f7f..ed7ce05327 100644 --- a/src/cmd/compile/internal/types2/testdata/check/stmt0.src +++ b/src/cmd/compile/internal/types2/testdata/check/stmt0.src @@ -375,7 +375,7 @@ func continues() { func returns0() { return - return 0 /* ERROR no result values expected */ + return 0 /* ERROR too many return values */ } func returns1(x float64) (int, *float64) { diff --git a/src/cmd/compile/internal/types2/testdata/check/vardecl.src b/src/cmd/compile/internal/types2/testdata/check/vardecl.src index 827b9b9d69..c3fe61c3d4 100644 --- a/src/cmd/compile/internal/types2/testdata/check/vardecl.src +++ b/src/cmd/compile/internal/types2/testdata/check/vardecl.src @@ -177,8 +177,8 @@ func _() { func _() { var x int - return x /* ERROR no result values expected */ - return math /* ERROR no result values expected */ .Sin(0) + return x /* ERROR too many return values */ + return math /* ERROR too many return values */ .Sin(0) } func _() int { diff --git a/src/go/types/stmt.go b/src/go/types/stmt.go index 0a69789078..802673567d 100644 --- a/src/go/types/stmt.go +++ b/src/go/types/stmt.go @@ -503,27 +503,25 @@ func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) { case *ast.ReturnStmt: res := check.sig.results - if res.Len() > 0 { - // function returns results - // (if one, say the first, result parameter is named, all of them are named) - if len(s.Results) == 0 && res.vars[0].name != "" { - // spec: "Implementation restriction: A compiler may disallow an empty expression - // list in a "return" statement if a different entity (constant, type, or variable) - // with the same name as a result parameter is in scope at the place of the return." - for _, obj := range res.vars { - if alt := check.lookup(obj.name); alt != nil && alt != obj { - check.errorf(s, _OutOfScopeResult, "result parameter %s not in scope at return", obj.name) - check.errorf(alt, _OutOfScopeResult, "\tinner declaration of %s", obj) - // ok to continue - } + // Return with implicit results allowed for function with named results. + // (If one is named, all are named.) + if len(s.Results) == 0 && res.Len() > 0 && res.vars[0].name != "" { + // spec: "Implementation restriction: A compiler may disallow an empty expression + // list in a "return" statement if a different entity (constant, type, or variable) + // with the same name as a result parameter is in scope at the place of the return." + for _, obj := range res.vars { + if alt := check.lookup(obj.name); alt != nil && alt != obj { + check.errorf(s, _OutOfScopeResult, "result parameter %s not in scope at return", obj.name) + check.errorf(alt, _OutOfScopeResult, "\tinner declaration of %s", obj) + // ok to continue } - } else { - // return has results or result parameters are unnamed - check.initVars(res.vars, s.Results, s) } - } else if len(s.Results) > 0 { - check.error(s.Results[0], _WrongResultCount, "no result values expected") - check.use(s.Results...) + } else { + var lhs []*Var + if res.Len() > 0 { + lhs = res.vars + } + check.initVars(lhs, s.Results, s) } case *ast.BranchStmt: diff --git a/src/go/types/testdata/check/stmt0.src b/src/go/types/testdata/check/stmt0.src index a635af7cbb..ec8bf71013 100644 --- a/src/go/types/testdata/check/stmt0.src +++ b/src/go/types/testdata/check/stmt0.src @@ -375,7 +375,7 @@ func continues() { func returns0() { return - return 0 /* ERROR no result values expected */ + return 0 /* ERROR too many return values */ } func returns1(x float64) (int, *float64) { diff --git a/src/go/types/testdata/check/vardecl.src b/src/go/types/testdata/check/vardecl.src index 787f7878f1..56abf97722 100644 --- a/src/go/types/testdata/check/vardecl.src +++ b/src/go/types/testdata/check/vardecl.src @@ -169,8 +169,8 @@ func _() { func _() { var x int - return x /* ERROR no result values expected */ - return math /* ERROR no result values expected */ .Sin(0) + return x /* ERROR too many return values */ + return math /* ERROR too many return values */ .Sin(0) } func _() int { diff --git a/test/fixedbugs/issue4215.go b/test/fixedbugs/issue4215.go index b6ece4bf21..9f32f5b100 100644 --- a/test/fixedbugs/issue4215.go +++ b/test/fixedbugs/issue4215.go @@ -11,7 +11,7 @@ func foo() (int, int) { } func foo2() { - 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|no result values expected" + return int(2), 2 // ERROR "too many (arguments to return|return values)\n\thave \(int, number\)\n\twant \(\)|return with value in function with no return type" } func foo3(v int) (a, b, c, d int) { diff --git a/test/fixedbugs/issue48834.go b/test/fixedbugs/issue48834.go index cf97d132c3..584dfa5764 100644 --- a/test/fixedbugs/issue48834.go +++ b/test/fixedbugs/issue48834.go @@ -20,5 +20,5 @@ func _() int { } func _() { - return 1 // ERROR "too many arguments to return\n\thave \(number\)\n\twant \(\)|no result values expected" + return 1 // ERROR "too many (arguments to return|return values)\n\thave \(number\)\n\twant \(\)" } From 626f13d0ca08f04f98e7a29a08028c21e38868c0 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Tue, 18 Jan 2022 13:45:05 -0800 Subject: [PATCH 651/752] cmd/compile: add missing copyright notice Also, simplify one expression (missed comment on previous review). Change-Id: Ic2d212442c2738e03c733336bb990e28c8912ca4 Reviewed-on: https://go-review.googlesource.com/c/go/+/379254 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: Matthew Dempsky --- src/cmd/compile/internal/types/structuraltype.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/cmd/compile/internal/types/structuraltype.go b/src/cmd/compile/internal/types/structuraltype.go index 2d49e77aae..ee1341be21 100644 --- a/src/cmd/compile/internal/types/structuraltype.go +++ b/src/cmd/compile/internal/types/structuraltype.go @@ -1,3 +1,7 @@ +// Copyright 2022 The Go 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 // Implementation of structural type computation for types. @@ -107,7 +111,7 @@ func specificTypes(t *Type) (list []term, inf bool) { default: // m.Type is a single non-interface type, so r2 is just a // one-element list, inf2 is false. - r2 = []term{term{false, m.Type}} + r2 = []term{{false, m.Type}} } if inf2 { From fa4df6597eb7ed07a9a835a8b68c37282709f79e Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 12 Jan 2022 14:01:44 -0800 Subject: [PATCH 652/752] go/types, types2: avoid field/method lookup error on invalid types Fixes #49541. Change-Id: I27a52d0722a7408758682e7ddcd608c0a6c4881b Reviewed-on: https://go-review.googlesource.com/c/go/+/378175 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/call.go | 5 +++ .../compile/internal/types2/instantiate.go | 5 ++- .../types2/testdata/fixedbugs/issue49541.go2 | 44 +++++++++++++++++++ src/cmd/compile/internal/types2/typeset.go | 2 +- src/go/types/call.go | 5 +++ src/go/types/instantiate.go | 5 ++- .../types/testdata/fixedbugs/issue49541.go2 | 44 +++++++++++++++++++ src/go/types/typeset.go | 2 +- 8 files changed, 108 insertions(+), 4 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue49541.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue49541.go2 diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go index ea1c27aa2b..15a42ca3dc 100644 --- a/src/cmd/compile/internal/types2/call.go +++ b/src/cmd/compile/internal/types2/call.go @@ -531,6 +531,11 @@ func (check *Checker) selector(x *operand, e *syntax.SelectorExpr) { obj, index, indirect = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, sel) if obj == nil { + // Don't report another error if the underlying type was invalid (issue #49541). + if under(x.typ) == Typ[Invalid] { + goto Error + } + if index != nil { // TODO(gri) should provide actual type where the conflict happens check.errorf(e.Sel, "ambiguous selector %s.%s", x.expr, sel) diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go index b2e1087c41..5d5a660419 100644 --- a/src/cmd/compile/internal/types2/instantiate.go +++ b/src/cmd/compile/internal/types2/instantiate.go @@ -161,7 +161,10 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { Vu := under(V) Tu := under(T) if Vu == Typ[Invalid] || Tu == Typ[Invalid] { - return nil + return nil // avoid follow-on errors + } + if p, _ := Vu.(*Pointer); p != nil && under(p.base) == Typ[Invalid] { + return nil // avoid follow-on errors (see issue #49541 for an example) } errorf := func(format string, args ...interface{}) error { diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49541.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49541.go2 new file mode 100644 index 0000000000..b7bf12a186 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49541.go2 @@ -0,0 +1,44 @@ +// Copyright 2022 The Go 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 S[A, B any] struct { + f int +} + +func (S[A, B]) m() {} + +// TODO(gri) We should only report one error below. See issue #50588. + +func _[A any](s S /* ERROR cannot infer B */ /* ERROR got 1 arguments but 2 type parameters */ [A]) { + // we should see no follow-on errors below + s.f = 1 + s.m() +} + +// another test case from the issue + +func _() { + X(Interface[*F /* ERROR cannot infer B */ /* ERROR got 1 arguments but 2 type parameters */ [string]](Impl{})) +} + +func X[Q Qer](fs Interface[Q]) { +} + +type Impl struct{} + +func (Impl) M() {} + +type Interface[Q Qer] interface { + M() +} + +type Qer interface { + Q() +} + +type F[A, B any] struct{} + +func (f *F[A, B]) Q() {} diff --git a/src/cmd/compile/internal/types2/typeset.go b/src/cmd/compile/internal/types2/typeset.go index 0d8d02662b..8670c17861 100644 --- a/src/cmd/compile/internal/types2/typeset.go +++ b/src/cmd/compile/internal/types2/typeset.go @@ -135,7 +135,7 @@ func (s *_TypeSet) is(f func(*term) bool) bool { // underIs calls f with the underlying types of the specific type terms // of s and reports whether all calls to f returned true. If there are -// no specific terms, is returns the result of f(nil). +// no specific terms, underIs returns the result of f(nil). func (s *_TypeSet) underIs(f func(Type) bool) bool { if !s.hasTerms() { return f(nil) diff --git a/src/go/types/call.go b/src/go/types/call.go index d5b83451c4..aa87c48a65 100644 --- a/src/go/types/call.go +++ b/src/go/types/call.go @@ -533,6 +533,11 @@ func (check *Checker) selector(x *operand, e *ast.SelectorExpr) { obj, index, indirect = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, sel) if obj == nil { + // Don't report another error if the underlying type was invalid (issue #49541). + if under(x.typ) == Typ[Invalid] { + goto Error + } + if index != nil { // TODO(gri) should provide actual type where the conflict happens check.errorf(e.Sel, _AmbiguousSelector, "ambiguous selector %s.%s", x.expr, sel) diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go index e6a5cbf8ae..1a0823575b 100644 --- a/src/go/types/instantiate.go +++ b/src/go/types/instantiate.go @@ -161,7 +161,10 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { Vu := under(V) Tu := under(T) if Vu == Typ[Invalid] || Tu == Typ[Invalid] { - return nil + return nil // avoid follow-on errors + } + if p, _ := Vu.(*Pointer); p != nil && under(p.base) == Typ[Invalid] { + return nil // avoid follow-on errors (see issue #49541 for an example) } errorf := func(format string, args ...any) error { diff --git a/src/go/types/testdata/fixedbugs/issue49541.go2 b/src/go/types/testdata/fixedbugs/issue49541.go2 new file mode 100644 index 0000000000..b7bf12a186 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue49541.go2 @@ -0,0 +1,44 @@ +// Copyright 2022 The Go 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 S[A, B any] struct { + f int +} + +func (S[A, B]) m() {} + +// TODO(gri) We should only report one error below. See issue #50588. + +func _[A any](s S /* ERROR cannot infer B */ /* ERROR got 1 arguments but 2 type parameters */ [A]) { + // we should see no follow-on errors below + s.f = 1 + s.m() +} + +// another test case from the issue + +func _() { + X(Interface[*F /* ERROR cannot infer B */ /* ERROR got 1 arguments but 2 type parameters */ [string]](Impl{})) +} + +func X[Q Qer](fs Interface[Q]) { +} + +type Impl struct{} + +func (Impl) M() {} + +type Interface[Q Qer] interface { + M() +} + +type Qer interface { + Q() +} + +type F[A, B any] struct{} + +func (f *F[A, B]) Q() {} diff --git a/src/go/types/typeset.go b/src/go/types/typeset.go index 96f740e5cf..3739cd83d6 100644 --- a/src/go/types/typeset.go +++ b/src/go/types/typeset.go @@ -133,7 +133,7 @@ func (s *_TypeSet) is(f func(*term) bool) bool { // underIs calls f with the underlying types of the specific type terms // of s and reports whether all calls to f returned true. If there are -// no specific terms, is returns the result of f(nil). +// no specific terms, underIs returns the result of f(nil). func (s *_TypeSet) underIs(f func(Type) bool) bool { if !s.hasTerms() { return f(nil) From 50869f377fd72a921d27e3522a05604b7753b3ab Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 18 Jan 2022 15:21:37 -0800 Subject: [PATCH 653/752] go/types, types2: report error for invalid string(1 << s) For #45114. Fixes #45117. Change-Id: I71d6650ae2c4c06952fce19959120f15f13c08a2 Reviewed-on: https://go-review.googlesource.com/c/go/+/379256 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/api_test.go | 1 - src/cmd/compile/internal/types2/conversions.go | 4 ++-- src/cmd/compile/internal/types2/testdata/check/shifts.src | 2 +- .../internal/types2/testdata/fixedbugs/issue45114.go | 8 ++++++++ src/go/types/api_test.go | 1 - src/go/types/conversions.go | 4 ++-- src/go/types/testdata/check/shifts.src | 2 +- src/go/types/testdata/fixedbugs/issue45114.go | 8 ++++++++ test/fixedbugs/bug193.go | 4 +--- 9 files changed, 23 insertions(+), 11 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue45114.go create mode 100644 src/go/types/testdata/fixedbugs/issue45114.go diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go index 28c1f97e87..2493bfb200 100644 --- a/src/cmd/compile/internal/types2/api_test.go +++ b/src/cmd/compile/internal/types2/api_test.go @@ -109,7 +109,6 @@ func TestValuesInfo(t *testing.T) { {`package c5d; var _ = string(65)`, `65`, `untyped int`, `65`}, {`package c5e; var _ = string('A')`, `'A'`, `untyped rune`, `65`}, {`package c5f; type T string; var _ = T('A')`, `'A'`, `untyped rune`, `65`}, - {`package c5g; var s uint; var _ = string(1 << s)`, `1 << s`, `untyped int`, ``}, {`package d0; var _ = []byte("foo")`, `"foo"`, `string`, `"foo"`}, {`package d1; var _ = []byte(string("foo"))`, `"foo"`, `string`, `"foo"`}, diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go index 253868cf93..7fe1d5056b 100644 --- a/src/cmd/compile/internal/types2/conversions.go +++ b/src/cmd/compile/internal/types2/conversions.go @@ -98,13 +98,13 @@ func (check *Checker) conversion(x *operand, T Type) { // - For conversions of untyped constants to non-constant types, also // use the default type (e.g., []byte("foo") should report string // not []byte as type for the constant "foo"). - // - For integer to string conversions, keep the argument type. + // - For constant integer to string conversions, keep the argument type. // (See also the TODO below.) if x.typ == Typ[UntypedNil] { // ok } else if IsInterface(T) && !isTypeParam(T) || constArg && !isConstType(T) { final = Default(x.typ) - } else if isInteger(x.typ) && allString(T) { + } else if x.mode == constant_ && isInteger(x.typ) && allString(T) { final = x.typ } check.updateExprType(x.expr, final, true) diff --git a/src/cmd/compile/internal/types2/testdata/check/shifts.src b/src/cmd/compile/internal/types2/testdata/check/shifts.src index 60db731cf4..37bc84c0f6 100644 --- a/src/cmd/compile/internal/types2/testdata/check/shifts.src +++ b/src/cmd/compile/internal/types2/testdata/check/shifts.src @@ -381,7 +381,7 @@ func issue21727() { var a = make([]int, 1< Date: Tue, 18 Jan 2022 18:04:30 -0800 Subject: [PATCH 654/752] spec: add another example for an invalid shift case Fixes #45114. Change-Id: I969e5f1037254fc0ffbba2fc07a81a3987e6b05f Reviewed-on: https://go-review.googlesource.com/c/go/+/379275 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index 7c20236016..0d7de5e6d1 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1,6 +1,6 @@ @@ -4259,7 +4259,8 @@ var p = 1<<s == 1<<33 // 1 has type int; p == true var u = 1.0<<s // illegal: 1.0 has type float64, cannot shift var u1 = 1.0<<s != 0 // illegal: 1.0 has type float64, cannot shift var u2 = 1<<s != 1.0 // illegal: 1 has type float64, cannot shift -var v float32 = 1<<s // illegal: 1 has type float32, cannot shift +var v1 float32 = 1<<s // illegal: 1 has type float32, cannot shift +var v2 = string(1<<s) // illegal: 1 is converted to a string, cannot shift var w int64 = 1.0<<33 // 1.0<<33 is a constant shift expression; w == 1<<33 var x = a[1.0<<s] // panics: 1.0 has type int, but 1<<33 overflows array bounds var b = make([]byte, 1.0<<s) // 1.0 has type int; len(b) == 1<<33 From 2a061fdd47ccb5420229ce5f9f057e194be76995 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 14 Jan 2022 11:15:28 -0500 Subject: [PATCH 655/752] cmd/go: fix TestScript/version_buildvcs_git_gpg This test was missed in CL 358539, presumably because the 'longtest' builders lack a 'gpg' executable. Updates #49168 Fixes #50675 Change-Id: Ie3bfc761a5e4304531119625742f3def9df8af3f Reviewed-on: https://go-review.googlesource.com/c/go/+/378575 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/cmd/go/testdata/script/version_buildvcs_git_gpg.txt | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/cmd/go/testdata/script/version_buildvcs_git_gpg.txt b/src/cmd/go/testdata/script/version_buildvcs_git_gpg.txt index 6d429c5a52..dcf97d7c44 100644 --- a/src/cmd/go/testdata/script/version_buildvcs_git_gpg.txt +++ b/src/cmd/go/testdata/script/version_buildvcs_git_gpg.txt @@ -34,9 +34,9 @@ exec git log # Verify commit signature does not interfere with versioning go install go version -m $GOBIN/a -stdout '^\tbuild\tgitrevision\t' -stdout '^\tbuild\tgitcommittime\t' -stdout '^\tbuild\tgituncommitted\tfalse$' +stdout '^\tbuild\tvcs\.revision=' +stdout '^\tbuild\tvcs\.time=' +stdout '^\tbuild\tvcs\.modified=false$' -- repo/README -- Far out in the uncharted backwaters of the unfashionable end of the western From ca33b34e17b5f4673a40c894a4f807c01d1ecebe Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Tue, 18 Jan 2022 16:27:40 -0500 Subject: [PATCH 656/752] runtime: deflake TestPreemptionAfterSyscall This test occasionally takes very slightly longer than the 3 second timeout on slow builders (especially windows-386-2008), so increase the timeout to 5 seconds. It fails with much longer timeouts on Plan 9, so skip it as flaky there. Updates #41015. Change-Id: I426a7adfae92c18a0f8a223dd92762b0b91565e1 Reviewed-on: https://go-review.googlesource.com/c/go/+/379214 Trust: Austin Clements Reviewed-by: Cherry Mui Reviewed-by: Bryan Mills --- src/runtime/proc_test.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/runtime/proc_test.go b/src/runtime/proc_test.go index cc899a24c6..719d0d1aee 100644 --- a/src/runtime/proc_test.go +++ b/src/runtime/proc_test.go @@ -1044,7 +1044,7 @@ func testPreemptionAfterSyscall(t *testing.T, syscallDuration time.Duration) { interations = 1 } const ( - maxDuration = 3 * time.Second + maxDuration = 5 * time.Second nroutines = 8 ) @@ -1080,6 +1080,10 @@ func testPreemptionAfterSyscall(t *testing.T, syscallDuration time.Duration) { } func TestPreemptionAfterSyscall(t *testing.T) { + if runtime.GOOS == "plan9" { + testenv.SkipFlaky(t, 41015) + } + for _, i := range []time.Duration{10, 100, 1000} { d := i * time.Microsecond t.Run(fmt.Sprint(d), func(t *testing.T) { From d93ff73ae207763871bee38590242be968b2e743 Mon Sep 17 00:00:00 2001 From: Cherry Mui Date: Tue, 18 Jan 2022 18:36:00 -0500 Subject: [PATCH 657/752] cmd/compile: don't elide extension for LoadReg to FP register on MIPS64 For an extension operation like MOWWreg, if the operand is already extended, we optimize the second extension out. Usually a LoadReg of a proper type would come already extended, as a MOVW/MOVWU etc. instruction does. But for a LoadReg to a floating point register, the instruction does not do the extension. So we cannot elide the extension. Fixes #50671. Change-Id: Id8991df78d5acdecd3fd6138c558428cbd5f6ba3 Reviewed-on: https://go-review.googlesource.com/c/go/+/379236 Trust: Cherry Mui Run-TryBot: Cherry Mui TryBot-Result: Gopher Robot Reviewed-by: David Chase --- src/cmd/compile/internal/mips64/ssa.go | 5 +++- test/fixedbugs/issue50671.go | 35 ++++++++++++++++++++++++++ 2 files changed, 39 insertions(+), 1 deletion(-) create mode 100644 test/fixedbugs/issue50671.go diff --git a/src/cmd/compile/internal/mips64/ssa.go b/src/cmd/compile/internal/mips64/ssa.go index 990b9788f7..6e12c6cb94 100644 --- a/src/cmd/compile/internal/mips64/ssa.go +++ b/src/cmd/compile/internal/mips64/ssa.go @@ -320,7 +320,10 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) { for a.Op == ssa.OpCopy || a.Op == ssa.OpMIPS64MOVVreg { a = a.Args[0] } - if a.Op == ssa.OpLoadReg { + if a.Op == ssa.OpLoadReg && mips.REG_R0 <= a.Reg() && a.Reg() <= mips.REG_R31 { + // LoadReg from a narrower type does an extension, except loading + // to a floating point register. So only eliminate the extension + // if it is loaded to an integer register. t := a.Type switch { case v.Op == ssa.OpMIPS64MOVBreg && t.Size() == 1 && t.IsSigned(), diff --git a/test/fixedbugs/issue50671.go b/test/fixedbugs/issue50671.go new file mode 100644 index 0000000000..9f4742bfcd --- /dev/null +++ b/test/fixedbugs/issue50671.go @@ -0,0 +1,35 @@ +// run + +// Copyright 2022 The Go 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 50671: sign extension eliminated incorrectly on MIPS64. + +package main + +//go:noinline +func F(x int32) (float64, int64) { + a := float64(x) + b := int64(x) + return a, b +} + +var a, b, c float64 + +// Poison some floating point registers with non-zero high bits. +// +//go:noinline +func poison(x float64) { + a = x - 123.45 + b = a * 1.2 + c = b + 3.4 +} + +func main() { + poison(333.3) + _, b := F(123) + if b != 123 { + panic("FAIL") + } +} From bec2cc370871b998a131f5f363dab4a14b5f2eb2 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 12 Jan 2022 10:26:04 -0500 Subject: [PATCH 658/752] runtime: eliminate arbitrary timeout in TestStackGrowth Instead, allow the test to run up until nearly the test's deadline, whatever that may be, and then crash with a panic (instead of calling t.Errorf) to get a useful goroutine dump. With the arbitrary timeout removed, we can now also run this test in short mode, reducing its impact on test latency. Fixes #19381 Change-Id: Ie1fae321a2973fcb9b69a012103363f16214f529 Reviewed-on: https://go-review.googlesource.com/c/go/+/378034 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Austin Clements TryBot-Result: Gopher Robot --- src/runtime/stack_test.go | 70 +++++++++++++++------------------------ 1 file changed, 27 insertions(+), 43 deletions(-) diff --git a/src/runtime/stack_test.go b/src/runtime/stack_test.go index 4c2671b31f..1a59086901 100644 --- a/src/runtime/stack_test.go +++ b/src/runtime/stack_test.go @@ -7,11 +7,9 @@ package runtime_test import ( "bytes" "fmt" - "os" "reflect" "regexp" . "runtime" - "strconv" "strings" "sync" "sync/atomic" @@ -83,12 +81,7 @@ func TestStackGrowth(t *testing.T) { t.Skip("-quick") } - if GOARCH == "wasm" { - t.Skip("fails on wasm (too slow?)") - } - - // Don't make this test parallel as this makes the 20 second - // timeout unreliable on slow builders. (See issue #19381.) + t.Parallel() var wg sync.WaitGroup @@ -102,6 +95,7 @@ func TestStackGrowth(t *testing.T) { growDuration = time.Since(start) }() wg.Wait() + t.Log("first growStack took", growDuration) // in locked goroutine wg.Add(1) @@ -114,48 +108,38 @@ func TestStackGrowth(t *testing.T) { wg.Wait() // in finalizer + var finalizerStart time.Time + var started, progress uint32 wg.Add(1) - go func() { + s := new(string) // Must be of a type that avoids the tiny allocator, or else the finalizer might not run. + SetFinalizer(s, func(ss *string) { defer wg.Done() - done := make(chan bool) - var startTime time.Time - var started, progress uint32 - go func() { - s := new(string) - SetFinalizer(s, func(ss *string) { - startTime = time.Now() - atomic.StoreUint32(&started, 1) - growStack(&progress) - done <- true - }) - s = nil - done <- true - }() - <-done - GC() + finalizerStart = time.Now() + atomic.StoreUint32(&started, 1) + growStack(&progress) + }) + setFinalizerTime := time.Now() + s = nil - timeout := 20 * time.Second - if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" { - scale, err := strconv.Atoi(s) - if err == nil { - timeout *= time.Duration(scale) - } - } - - select { - case <-done: - case <-time.After(timeout): + if d, ok := t.Deadline(); ok { + // Pad the timeout by an arbitrary 5% to give the AfterFunc time to run. + timeout := time.Until(d) * 19 / 20 + timer := time.AfterFunc(timeout, func() { + // Panic — instead of calling t.Error and returning from the test — so + // that we get a useful goroutine dump if the test times out, especially + // if GOTRACEBACK=system or GOTRACEBACK=crash is set. if atomic.LoadUint32(&started) == 0 { - t.Log("finalizer did not start") + panic("finalizer did not start") } else { - t.Logf("finalizer started %s ago and finished %d iterations", time.Since(startTime), atomic.LoadUint32(&progress)) + panic(fmt.Sprintf("finalizer started %s ago (%s after registration) and ran %d iterations, but did not return", time.Since(finalizerStart), finalizerStart.Sub(setFinalizerTime), atomic.LoadUint32(&progress))) } - t.Log("first growStack took", growDuration) - t.Error("finalizer did not run") - return - } - }() + }) + defer timer.Stop() + } + + GC() wg.Wait() + t.Logf("finalizer started after %s and ran %d iterations in %v", finalizerStart.Sub(setFinalizerTime), atomic.LoadUint32(&progress), time.Since(finalizerStart)) } // ... and in init From 3e45eb3ce1f28ccb6e4150b6c2c09ca8568874e6 Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Tue, 7 Dec 2021 15:59:14 -0500 Subject: [PATCH 659/752] runtime: do not inherit labels on system goroutines GC background mark worker goroutines are created when the first GC is triggered (or next GC after GOMAXPROCS increases). Since the GC can be triggered from a user goroutine, those workers will inherit any pprof labels from the user goroutine. That isn't meaningful, so avoid it by excluding system goroutines from inheriting labels. Fixes #50032 Change-Id: Ib425ae561a3466007ff5deec86b9c51829ab5507 Reviewed-on: https://go-review.googlesource.com/c/go/+/369983 Reviewed-by: Austin Clements Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot --- src/runtime/proc.go | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/runtime/proc.go b/src/runtime/proc.go index 7509f7632f..eee0a25fee 100644 --- a/src/runtime/proc.go +++ b/src/runtime/proc.go @@ -4300,11 +4300,13 @@ func newproc1(fn *funcval, callergp *g, callerpc uintptr) *g { newg.gopc = callerpc newg.ancestors = saveAncestors(callergp) newg.startpc = fn.fn - if _g_.m.curg != nil { - newg.labels = _g_.m.curg.labels - } if isSystemGoroutine(newg, false) { atomic.Xadd(&sched.ngsys, +1) + } else { + // Only user goroutines inherit pprof labels. + if _g_.m.curg != nil { + newg.labels = _g_.m.curg.labels + } } // Track initial transition? newg.trackingSeq = uint8(fastrand()) From 985d97e602cb39c7739c072250e09ba61e440318 Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Tue, 7 Dec 2021 12:01:04 -0500 Subject: [PATCH 660/752] runtime/pprof: assert that labels never appear on unexpected samples This makes TestLabelSystemstack much more strict, enabling it to detect any misplacement of labels. Unfortunately, there are several edge cases where we may not have an obviously correct stack trace, so we generally except the runtime package, with the exception of background goroutines that we know should not be labeled. For #50007 For #50032 Change-Id: I8dce7e7da04f278ce297422227901efe52782ca0 Reviewed-on: https://go-review.googlesource.com/c/go/+/369984 Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot Reviewed-by: Austin Clements --- src/runtime/pprof/pprof_test.go | 107 +++++++++++++++++++++++++------- 1 file changed, 83 insertions(+), 24 deletions(-) diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index b8b1382ad1..44d27d2b31 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -1435,47 +1435,89 @@ func TestLabelSystemstack(t *testing.T) { matches := matchAndAvoidStacks(stackContainsLabeled, []string{"runtime.systemstack;key=value"}, avoidFunctions()) p := testCPUProfile(t, matches, func(dur time.Duration) { - Do(context.Background(), Labels("key", "value"), func(context.Context) { - var wg sync.WaitGroup - stop := make(chan struct{}) - for i := 0; i < runtime.GOMAXPROCS(0); i++ { - wg.Add(1) - go func() { - defer wg.Done() - labelHog(stop, gogc) - }() - } - - time.Sleep(dur) - close(stop) - wg.Wait() + Do(context.Background(), Labels("key", "value"), func(ctx context.Context) { + parallelLabelHog(ctx, dur, gogc) }) }) - // labelHog should always be labeled. + // Two conditions to check: + // * labelHog should always be labeled. + // * The label should _only_ appear on labelHog and the Do call above. for _, s := range p.Sample { + isLabeled := s.Label != nil && contains(s.Label["key"], "value") + var ( + mayBeLabeled bool + mustBeLabeled bool + mustNotBeLabeled bool + ) for _, loc := range s.Location { for _, l := range loc.Line { - if l.Function.Name != "runtime/pprof.labelHog" { - continue + switch l.Function.Name { + case "runtime/pprof.labelHog", "runtime/pprof.parallelLabelHog": + mustBeLabeled = true + case "runtime/pprof.Do": + // Do sets the labels, so samples may + // or may not be labeled depending on + // which part of the function they are + // at. + mayBeLabeled = true + case "runtime.bgsweep", "runtime.bgscavenge", "runtime.forcegchelper", "runtime.gcBgMarkWorker", "runtime.runfinq", "runtime.sysmon": + // Runtime system goroutines or threads + // (such as those identified by + // runtime.isSystemGoroutine). These + // should never be labeled. + mustNotBeLabeled = true + case "gogo", "gosave_systemstack_switch": + // These are context switch critical + // that we can't do a full traceback + // from. Typically this would be + // covered by the runtime check below, + // but these symbols don't have the + // package name. + mayBeLabeled = true } - if s.Label == nil { - t.Errorf("labelHog sample labels got nil want key=value") - continue - } - if !contains(s.Label["key"], "value") { - t.Errorf("labelHog sample labels got %+v want contains key=value", s.Label) - continue + if strings.HasPrefix(l.Function.Name, "runtime.") { + // There are many places in the runtime + // where we can't do a full traceback. + // Ideally we'd list them all, but + // barring that allow anything in the + // runtime, unless explicitly excluded + // above. + mayBeLabeled = true } } } + if mustNotBeLabeled { + // If this must not be labeled, then mayBeLabeled hints + // are not relevant. + mayBeLabeled = false + } + if mustBeLabeled && !isLabeled { + var buf bytes.Buffer + fprintStack(&buf, s.Location) + t.Errorf("Sample labeled got false want true: %s", buf.String()) + } + if mustNotBeLabeled && isLabeled { + var buf bytes.Buffer + fprintStack(&buf, s.Location) + t.Errorf("Sample labeled got true want false: %s", buf.String()) + } + if isLabeled && !(mayBeLabeled || mustBeLabeled) { + var buf bytes.Buffer + fprintStack(&buf, s.Location) + t.Errorf("Sample labeled got true want false: %s", buf.String()) + } } } // labelHog is designed to burn CPU time in a way that a high number of CPU // samples end up running on systemstack. func labelHog(stop chan struct{}, gogc int) { + // Regression test for issue 50032. We must give GC an opportunity to + // be initially triggered by a labelled goroutine. + runtime.GC() + for i := 0; ; i++ { select { case <-stop: @@ -1486,6 +1528,23 @@ func labelHog(stop chan struct{}, gogc int) { } } +// parallelLabelHog runs GOMAXPROCS goroutines running labelHog. +func parallelLabelHog(ctx context.Context, dur time.Duration, gogc int) { + var wg sync.WaitGroup + stop := make(chan struct{}) + for i := 0; i < runtime.GOMAXPROCS(0); i++ { + wg.Add(1) + go func() { + defer wg.Done() + labelHog(stop, gogc) + }() + } + + time.Sleep(dur) + close(stop) + wg.Wait() +} + // Check that there is no deadlock when the program receives SIGPROF while in // 64bit atomics' critical section. Used to happen on mips{,le}. See #20146. func TestAtomicLoadStore64(t *testing.T) { From efbecc7eff88a0d54f3ea9fca290e1808e197ae2 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 18 Jan 2022 19:58:14 -0800 Subject: [PATCH 661/752] go/types, types2: explicitly check for non-nil type in LookupFieldOrMethod Document and enforce API expectation. Add a test so we don't inadvertently change the function behavior with respect to nil type arguments. Fixes #50620. Change-Id: Ic000bff7504a03006bd248a319c7a2d49dcf09c8 Reviewed-on: https://go-review.googlesource.com/c/go/+/379374 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/api_test.go | 12 ++++++++++++ src/cmd/compile/internal/types2/lookup.go | 6 +++++- src/go/types/api_test.go | 12 ++++++++++++ src/go/types/lookup.go | 6 +++++- 4 files changed, 34 insertions(+), 2 deletions(-) diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go index 2493bfb200..3b75818d56 100644 --- a/src/cmd/compile/internal/types2/api_test.go +++ b/src/cmd/compile/internal/types2/api_test.go @@ -1443,6 +1443,18 @@ var _ = a.C2 makePkg("main", mainSrc) // don't crash when type-checking this package } +func TestLookupFieldOrMethodOnNil(t *testing.T) { + // LookupFieldOrMethod on a nil type is expected to produce a run-time panic. + defer func() { + const want = "LookupFieldOrMethod on nil type" + p := recover() + if s, ok := p.(string); !ok || s != want { + t.Fatalf("got %v, want %s", p, want) + } + }() + LookupFieldOrMethod(nil, false, nil, "") +} + func TestLookupFieldOrMethod(t *testing.T) { // Test cases assume a lookup of the form a.f or x.f, where a stands for an // addressable value, and x for a non-addressable value (even though a variable diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index 2b710040a4..61e8aa5054 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -19,7 +19,7 @@ import ( // in T and returns the corresponding *Var or *Func, an index sequence, and a // bool indicating if there were any pointer indirections on the path to the // field or method. If addressable is set, T is the type of an addressable -// variable (only matters for method lookups). +// variable (only matters for method lookups). T must not be nil. // // The last index entry is the field or method index in the (possibly embedded) // type where the entry was found, either: @@ -42,6 +42,10 @@ import ( // the method's formal receiver base type, nor was the receiver addressable. // func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) { + if T == nil { + panic("LookupFieldOrMethod on nil type") + } + // Methods cannot be associated to a named pointer type. // (spec: "The type denoted by T is called the receiver base type; // it must not be a pointer or interface type and it must be declared diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go index 8c80494de7..7986534e78 100644 --- a/src/go/types/api_test.go +++ b/src/go/types/api_test.go @@ -1426,6 +1426,18 @@ var _ = a.C2 makePkg("main", mainSrc) // don't crash when type-checking this package } +func TestLookupFieldOrMethodOnNil(t *testing.T) { + // LookupFieldOrMethod on a nil type is expected to produce a run-time panic. + defer func() { + const want = "LookupFieldOrMethod on nil type" + p := recover() + if s, ok := p.(string); !ok || s != want { + t.Fatalf("got %v, want %s", p, want) + } + }() + LookupFieldOrMethod(nil, false, nil, "") +} + func TestLookupFieldOrMethod(t *testing.T) { // Test cases assume a lookup of the form a.f or x.f, where a stands for an // addressable value, and x for a non-addressable value (even though a variable diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go index b9c5048b5d..d35e53aa10 100644 --- a/src/go/types/lookup.go +++ b/src/go/types/lookup.go @@ -19,7 +19,7 @@ import ( // in T and returns the corresponding *Var or *Func, an index sequence, and a // bool indicating if there were any pointer indirections on the path to the // field or method. If addressable is set, T is the type of an addressable -// variable (only matters for method lookups). +// variable (only matters for method lookups). T must not be nil. // // The last index entry is the field or method index in the (possibly embedded) // type where the entry was found, either: @@ -42,6 +42,10 @@ import ( // the method's formal receiver base type, nor was the receiver addressable. // func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) { + if T == nil { + panic("LookupFieldOrMethod on nil type") + } + // Methods cannot be associated to a named pointer type. // (spec: "The type denoted by T is called the receiver base type; // it must not be a pointer or interface type and it must be declared From d1640d86522c08e662eec86de985e9781e879e20 Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Wed, 19 Jan 2022 14:25:12 -0500 Subject: [PATCH 662/752] runtime/pprof: compare all samples vs rusage in TestCPUProfileMultithreadMagnitude TestCPUProfileMultithreadMagnitude compares pprof results vs OS rusage to verify that pprof is capturing all CPU usage. Presently it compares the sum of cpuHog1 samples vs rusage. However, background usage from the scheduler, GC, etc can cause additional CPU usage causing test failures if rusage is too far off from the cpuHog1 samples. That said, this test doesn't actually need to care about cpuHog1 samples. It simply cares that pprof samples match rusage, not what the breakdown of usage was. As a result, we can compare the sum of _all_ pprof samples vs rusage, which should implicitly include any background CPU usage. Fixes #50097. Change-Id: I649a18de5b3dcf58b62be5962fa508d14cd4dc79 Reviewed-on: https://go-review.googlesource.com/c/go/+/379535 Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot Reviewed-by: Michael Knyszek --- src/runtime/pprof/pprof_test.go | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index 44d27d2b31..54604598cc 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -154,14 +154,6 @@ func TestCPUProfileMultithreadMagnitude(t *testing.T) { maxDiff = 0.40 } - // This test compares the process's total CPU time against the CPU - // profiler's view of time spent in direct execution of user code. - // Background work, especially from the garbage collector, adds noise to - // that measurement. Disable automatic triggering of the GC, and then - // request a complete GC cycle (up through sweep termination). - defer debug.SetGCPercent(debug.SetGCPercent(-1)) - runtime.GC() - compare := func(a, b time.Duration, maxDiff float64) error { if a <= 0 || b <= 0 { return fmt.Errorf("Expected both time reports to be positive") @@ -221,11 +213,14 @@ func TestCPUProfileMultithreadMagnitude(t *testing.T) { } } + // cpuHog1 called above is the primary source of CPU + // load, but there may be some background work by the + // runtime. Since the OS rusage measurement will + // include all work done by the process, also compare + // against all samples in our profile. var value time.Duration for _, sample := range p.Sample { - if stackContains("runtime/pprof.cpuHog1", uintptr(sample.Value[0]), sample.Location, sample.Label) { - value += time.Duration(sample.Value[1]) * time.Nanosecond - } + value += time.Duration(sample.Value[1]) * time.Nanosecond } t.Logf("compare %s vs %s", cpuTime, value) From a4d3c73ac3cc109ac2088beadf4d51987a60c625 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 18 Jan 2022 19:14:25 -0800 Subject: [PATCH 663/752] doc/go1.18: don't mention -buildinfo flag It was removed in CL 378576. For #50501 Change-Id: I26b8f0e99a40fa5c616aa4849a6ab15dd0d072f8 Reviewed-on: https://go-review.googlesource.com/c/go/+/379314 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Bryan Mills --- doc/go1.18.html | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 133bfe0ef2..a43b65d0a2 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -253,10 +253,10 @@ Do not send CLs removing the interior tags from such phrases. including build and tool tags (set with -tags), compiler, assembler, and linker flags (like -gcflags), whether cgo was enabled, and if it was, the values of the cgo environment variables - (like CGO_CFLAGS). This information may be omitted using the - flag -buildinfo=false. Both VCS and build information may be - read together with module information using go - version -m file or + (like CGO_CFLAGS). + Both VCS and build information may be read together with module + information using + go version -m file or runtime/debug.ReadBuildInfo (for the currently running binary) or the new debug/buildinfo package. From 1efc5815dd316953a8f37e58f7e3542a6aac3adf Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 18 Jan 2022 17:52:16 -0800 Subject: [PATCH 664/752] go/types, types2: use orig. compiler error message for a shift error Slightly better for cases such as string(1 << s). Leaves type-checker tests alone for now because there are multiple dozens. For #45117. Change-Id: I47b314c713fabe424c2158674bf965416a8a6f5c Reviewed-on: https://go-review.googlesource.com/c/go/+/379274 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/expr.go | 23 +++++++++++++++-------- src/go/types/expr.go | 21 ++++++++++++++------- test/fixedbugs/issue28079c.go | 2 +- 3 files changed, 30 insertions(+), 16 deletions(-) diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index 0147e2adfd..3d6d9153ee 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -504,8 +504,11 @@ func (check *Checker) invalidConversion(code errorCode, x *operand, target Type) // Also, if x is a constant, it must be representable as a value of typ, // and if x is the (formerly untyped) lhs operand of a non-constant // shift, it must be an integer value. -// func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) { + check.updateExprType0(nil, x, typ, final) +} + +func (check *Checker) updateExprType0(parent, x syntax.Expr, typ Type, final bool) { old, found := check.untyped[x] if !found { return // nothing to do @@ -548,7 +551,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) { // No operands to take care of. case *syntax.ParenExpr: - check.updateExprType(x.X, typ, final) + check.updateExprType0(x, x.X, typ, final) // case *syntax.UnaryExpr: // // If x is a constant, the operands were constants. @@ -559,7 +562,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) { // if old.val != nil { // break // } - // check.updateExprType(x.X, typ, final) + // check.updateExprType0(x, x.X, typ, final) case *syntax.Operation: if x.Y == nil { @@ -580,7 +583,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) { if old.val != nil { break } - check.updateExprType(x.X, typ, final) + check.updateExprType0(x, x.X, typ, final) break } @@ -594,11 +597,11 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) { } else if isShift(x.Op) { // The result type depends only on lhs operand. // The rhs type was updated when checking the shift. - check.updateExprType(x.X, typ, final) + check.updateExprType0(x, x.X, typ, final) } else { // The operand types match the result type. - check.updateExprType(x.X, typ, final) - check.updateExprType(x.Y, typ, final) + check.updateExprType0(x, x.X, typ, final) + check.updateExprType0(x, x.Y, typ, final) } default: @@ -622,7 +625,11 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) { // We already know from the shift check that it is representable // as an integer if it is a constant. if !allInteger(typ) { - check.errorf(x, invalidOp+"shifted operand %s (type %s) must be integer", x, typ) + if check.conf.CompilerErrorMessages { + check.errorf(x, invalidOp+"%s (shift of type %s)", parent, typ) + } else { + check.errorf(x, invalidOp+"shifted operand %s (type %s) must be integer", x, typ) + } return } // Even if we have an integer, if the value is a constant we diff --git a/src/go/types/expr.go b/src/go/types/expr.go index 73b01f4aa4..36f0f467be 100644 --- a/src/go/types/expr.go +++ b/src/go/types/expr.go @@ -472,8 +472,11 @@ func (check *Checker) invalidConversion(code errorCode, x *operand, target Type) // Also, if x is a constant, it must be representable as a value of typ, // and if x is the (formerly untyped) lhs operand of a non-constant // shift, it must be an integer value. -// func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) { + check.updateExprType0(nil, x, typ, final) +} + +func (check *Checker) updateExprType0(parent, x ast.Expr, typ Type, final bool) { old, found := check.untyped[x] if !found { return // nothing to do @@ -515,7 +518,7 @@ func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) { // No operands to take care of. case *ast.ParenExpr: - check.updateExprType(x.X, typ, final) + check.updateExprType0(x, x.X, typ, final) case *ast.UnaryExpr: // If x is a constant, the operands were constants. @@ -526,7 +529,7 @@ func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) { if old.val != nil { break } - check.updateExprType(x.X, typ, final) + check.updateExprType0(x, x.X, typ, final) case *ast.BinaryExpr: if old.val != nil { @@ -538,11 +541,11 @@ func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) { } else if isShift(x.Op) { // The result type depends only on lhs operand. // The rhs type was updated when checking the shift. - check.updateExprType(x.X, typ, final) + check.updateExprType0(x, x.X, typ, final) } else { // The operand types match the result type. - check.updateExprType(x.X, typ, final) - check.updateExprType(x.Y, typ, final) + check.updateExprType0(x, x.X, typ, final) + check.updateExprType0(x, x.Y, typ, final) } default: @@ -566,7 +569,11 @@ func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) { // We already know from the shift check that it is representable // as an integer if it is a constant. if !allInteger(typ) { - check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s (type %s) must be integer", x, typ) + if compilerErrorMessages { + check.invalidOp(x, _InvalidShiftOperand, "%s (shift of type %s)", parent, typ) + } else { + check.invalidOp(x, _InvalidShiftOperand, "shifted operand %s (type %s) must be integer", x, typ) + } return } // Even if we have an integer, if the value is a constant we diff --git a/test/fixedbugs/issue28079c.go b/test/fixedbugs/issue28079c.go index f6954eda42..dfac8d0155 100644 --- a/test/fixedbugs/issue28079c.go +++ b/test/fixedbugs/issue28079c.go @@ -11,5 +11,5 @@ package p import "unsafe" func f() { - _ = complex(1< Date: Mon, 17 Jan 2022 13:24:06 -0800 Subject: [PATCH 665/752] cmd/compile: add early a CONVIFACE normally created in the order phase Most CONVIFACEs are created in the transform phase (or old typechecker, in -G=0 mode). But if the main result of a multi-value assignment (map, channel, or dot-type) must be converted to an interface during the assignment, that CONVIFACE is not created until (*orderState).as2ok in the order phase (because the AS2* ops and their sub-ops are so tightly intertwined). But we need to create the CONVIFACE during the stenciling/transform phase to enable dictionary lookups. So, in transformAssign(), if we are doing a special multi-value assignment involving a type-param-derived type, assign the results first to temps, so that we can manifest the CONVIFACE during the transform in assigning the first temp to lhs[0]. Added a test for both AS2RECV (channel receives) and AS2MAPR (maps). I don't think we can have a type assertion on a type-param-derived type. Fixes #50642 Change-Id: I4d079fc46c93d8494d7db4ea8234d91522edb02a Reviewed-on: https://go-review.googlesource.com/c/go/+/379054 Reviewed-by: Matthew Dempsky Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/noder/transform.go | 31 ++++++++++ test/typeparam/issue50642.go | 63 +++++++++++++++++++++ 2 files changed, 94 insertions(+) create mode 100644 test/typeparam/issue50642.go diff --git a/src/cmd/compile/internal/noder/transform.go b/src/cmd/compile/internal/noder/transform.go index 6f49106f5e..5f1f41163b 100644 --- a/src/cmd/compile/internal/noder/transform.go +++ b/src/cmd/compile/internal/noder/transform.go @@ -356,6 +356,37 @@ assignOK: } checkLHS(0, r.Type()) checkLHS(1, types.UntypedBool) + t := lhs[0].Type() + if t != nil && rhs[0].Type().HasShape() && t.IsInterface() && !types.IdenticalStrict(t, rhs[0].Type()) { + // This is a multi-value assignment (map, channel, or dot-type) + // where the main result is converted to an interface during the + // assignment. Normally, the needed CONVIFACE is not created + // until (*orderState).as2ok(), because the AS2* ops and their + // sub-ops are so tightly intertwined. But we need to create the + // CONVIFACE now to enable dictionary lookups. So, assign the + // results first to temps, so that we can manifest the CONVIFACE + // in assigning the first temp to lhs[0]. If we added the + // CONVIFACE into rhs[0] directly, we would break a lot of later + // code that depends on the tight coupling between the AS2* ops + // and their sub-ops. (Issue #50642). + v := typecheck.Temp(rhs[0].Type()) + ok := typecheck.Temp(types.Types[types.TBOOL]) + as := ir.NewAssignListStmt(base.Pos, stmt.Op(), []ir.Node{v, ok}, []ir.Node{r}) + as.Def = true + as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, v)) + as.PtrInit().Append(ir.NewDecl(base.Pos, ir.ODCL, ok)) + as.SetTypecheck(1) + // Change stmt to be a normal assignment of the temps to the final + // left-hand-sides. We re-create the original multi-value assignment + // so that it assigns to the temps and add it as an init of stmt. + // + // TODO: fix the order of evaluation, so that the lval of lhs[0] + // is evaluated before rhs[0] (similar to problem in #50672). + stmt.SetOp(ir.OAS2) + stmt.PtrInit().Append(as) + // assignconvfn inserts the CONVIFACE. + stmt.Rhs = []ir.Node{assignconvfn(v, t), ok} + } return } diff --git a/test/typeparam/issue50642.go b/test/typeparam/issue50642.go new file mode 100644 index 0000000000..0cdbc360f9 --- /dev/null +++ b/test/typeparam/issue50642.go @@ -0,0 +1,63 @@ +// run -gcflags=-G=3 + +// 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 Temp[T any] struct { +} + +var temp, temp1 any +var ch any + +func (it Temp[T]) HasNext() bool { + var ok bool + temp1 = <-ch.(chan T) + // test conversion of T to interface{} during an OAS2RECV + temp, ok = <-ch.(chan T) + return ok +} + +type MyInt int + +func (i MyInt) String() string { + return "a" +} + +type Stringer interface { + String() string +} + +type Temp2[T Stringer] struct { +} + +var temp2 Stringer + +func (it Temp2[T]) HasNext() string { + var x map[int]T + + var ok bool + // test conversion of T to Stringer during an OAS2MAPR + temp2, ok = x[43] + _ = ok + return temp2.String() +} + +func main() { + ch1 := make(chan int, 2) + ch1 <- 5 + ch1 <- 6 + ch = ch1 + iter := Temp[int]{} + iter.HasNext() + + iter2 := Temp2[MyInt]{} + if got, want := iter2.HasNext(), "a"; got != want { + panic(fmt.Sprintf("got %v, want %v", got, want)) + } + +} From bb7fb8a5fac1ad9570c554c366826d649350acbe Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 18 Jan 2022 19:44:34 -0800 Subject: [PATCH 666/752] runtime: print error if mmap fails Fixes #49687 Change-Id: Ife7f64f4c98449eaff7327e09bc1fb67acee72c9 Reviewed-on: https://go-review.googlesource.com/c/go/+/379354 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Austin Clements --- src/runtime/mem_aix.go | 1 + src/runtime/mem_bsd.go | 1 + src/runtime/mem_darwin.go | 1 + src/runtime/mem_linux.go | 1 + 4 files changed, 4 insertions(+) diff --git a/src/runtime/mem_aix.go b/src/runtime/mem_aix.go index 957aa4dcc2..489d7928e1 100644 --- a/src/runtime/mem_aix.go +++ b/src/runtime/mem_aix.go @@ -72,6 +72,7 @@ func sysMap(v unsafe.Pointer, n uintptr, sysStat *sysMemStat) { throw("runtime: out of memory") } if err != 0 { + print("runtime: mprotect(", v, ", ", n, ") returned ", err, "\n") throw("runtime: cannot map pages in arena address space") } } diff --git a/src/runtime/mem_bsd.go b/src/runtime/mem_bsd.go index b152571792..49337eafbf 100644 --- a/src/runtime/mem_bsd.go +++ b/src/runtime/mem_bsd.go @@ -73,6 +73,7 @@ func sysMap(v unsafe.Pointer, n uintptr, sysStat *sysMemStat) { throw("runtime: out of memory") } if p != v || err != 0 { + print("runtime: mmap(", v, ", ", n, ") returned ", p, ", ", err, "\n") throw("runtime: cannot map pages in arena address space") } } diff --git a/src/runtime/mem_darwin.go b/src/runtime/mem_darwin.go index 7fccd2bb8e..9f836c0818 100644 --- a/src/runtime/mem_darwin.go +++ b/src/runtime/mem_darwin.go @@ -66,6 +66,7 @@ func sysMap(v unsafe.Pointer, n uintptr, sysStat *sysMemStat) { throw("runtime: out of memory") } if p != v || err != 0 { + print("runtime: mmap(", v, ", ", n, ") returned ", p, ", ", err, "\n") throw("runtime: cannot map pages in arena address space") } } diff --git a/src/runtime/mem_linux.go b/src/runtime/mem_linux.go index f8f9c53170..f8333014c2 100644 --- a/src/runtime/mem_linux.go +++ b/src/runtime/mem_linux.go @@ -189,6 +189,7 @@ func sysMap(v unsafe.Pointer, n uintptr, sysStat *sysMemStat) { throw("runtime: out of memory") } if p != v || err != 0 { + print("runtime: mmap(", v, ", ", n, ") returned ", p, ", ", err, "\n") throw("runtime: cannot map pages in arena address space") } } From e4ab8b0fe6d34c6cbfe29031a9c4df58ac1c452f Mon Sep 17 00:00:00 2001 From: luochuanhang Date: Tue, 18 Jan 2022 01:59:20 +0000 Subject: [PATCH 667/752] regexp: add the missing is MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: I23264972329aa3414067cd0e0986b69bb39bbeb5 GitHub-Last-Rev: d1d668a3cbe852d9a06f03369e7e635232d85139 GitHub-Pull-Request: golang/go#50650 Reviewed-on: https://go-review.googlesource.com/c/go/+/378935 Reviewed-by: Ian Lance Taylor Trust: Daniel Martí --- src/regexp/regexp.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/regexp/regexp.go b/src/regexp/regexp.go index af7259c9bf..f975bb3894 100644 --- a/src/regexp/regexp.go +++ b/src/regexp/regexp.go @@ -42,7 +42,7 @@ // successive submatches of the expression. Submatches are matches of // parenthesized subexpressions (also known as capturing groups) within the // regular expression, numbered from left to right in order of opening -// parenthesis. Submatch 0 is the match of the entire expression, submatch 1 +// parenthesis. Submatch 0 is the match of the entire expression, submatch 1 is // the match of the first parenthesized subexpression, and so on. // // If 'Index' is present, matches and submatches are identified by byte index From e7d5857a5a82551b8a70b6174ec73422442250ce Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 19 Jan 2022 15:48:17 -0800 Subject: [PATCH 668/752] cmd/compile/internal/importer, gcimporter: use *TypeParam as tparamIndex map value This is a map from identifiers to type parameters, use *TypeParam as map value instead of Type. Change-Id: Ib006393418c6352bcffc1c6796c5e002c33d9f4e Reviewed-on: https://go-review.googlesource.com/c/go/+/379634 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Trust: Dan Scales Reviewed-by: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/importer/iimport.go | 4 ++-- src/go/internal/gcimporter/iimport.go | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/cmd/compile/internal/importer/iimport.go b/src/cmd/compile/internal/importer/iimport.go index 7c51d3b16f..691e9b6976 100644 --- a/src/cmd/compile/internal/importer/iimport.go +++ b/src/cmd/compile/internal/importer/iimport.go @@ -126,7 +126,7 @@ func ImportData(imports map[string]*types2.Package, data, path string) (pkg *typ typCache: make(map[uint64]types2.Type), // Separate map for typeparams, keyed by their package and unique // name (name with subscript). - tparamIndex: make(map[ident]types2.Type), + tparamIndex: make(map[ident]*types2.TypeParam), } for i, pt := range predeclared { @@ -202,7 +202,7 @@ type iimporter struct { declData string pkgIndex map[*types2.Package]map[string]uint64 typCache map[uint64]types2.Type - tparamIndex map[ident]types2.Type + tparamIndex map[ident]*types2.TypeParam interfaceList []*types2.Interface } diff --git a/src/go/internal/gcimporter/iimport.go b/src/go/internal/gcimporter/iimport.go index c5b89aa042..ee8dd0ee7c 100644 --- a/src/go/internal/gcimporter/iimport.go +++ b/src/go/internal/gcimporter/iimport.go @@ -127,7 +127,7 @@ func iImportData(fset *token.FileSet, imports map[string]*types.Package, dataRea typCache: make(map[uint64]types.Type), // Separate map for typeparams, keyed by their package and unique // name (name with subscript). - tparamIndex: make(map[ident]types.Type), + tparamIndex: make(map[ident]*types.TypeParam), fake: fakeFileSet{ fset: fset, @@ -207,7 +207,7 @@ type iimporter struct { declData []byte pkgIndex map[*types.Package]map[string]uint64 typCache map[uint64]types.Type - tparamIndex map[ident]types.Type + tparamIndex map[ident]*types.TypeParam fake fakeFileSet interfaceList []*types.Interface From 9284279b44418b52221b4d68d400fa9220521726 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Wed, 19 Jan 2022 22:00:42 -0500 Subject: [PATCH 669/752] go/types, types2: use Identical rather than unification in missingMethod Now that we instantiate methods on instantiated types, there is no need to use unification to match signatures inside of missingMethod. Generally, we should never encounter uninstantiated signatures within statements. If we do encounter signatures that contain type parameters, it is because the signatures are themselves defined or instantiated using type parameters declared in the function scope (see example below). The current unification logic would not handle this. type S[T any] struct{} func (S[T]) m(T) func _[P any]() bool { var v interface{m(int)} _, ok = v.(S[P]) return ok } Change-Id: I754fb5535bba2fc7a209dc7419fd4015c413c9a6 Reviewed-on: https://go-review.googlesource.com/c/go/+/379540 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/lookup.go | 31 ++--------------------- src/go/types/lookup.go | 18 ++----------- 2 files changed, 4 insertions(+), 45 deletions(-) diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index 61e8aa5054..3e55c07b67 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -328,14 +328,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, panic("method with type parameters") } - // If the methods have type parameters we don't care whether they - // are the same or not, as long as they match up. Use unification - // to see if they can be made to match. - // TODO(gri) is this always correct? what about type bounds? - // (Alternative is to rename/subst type parameters and compare.) - u := newUnifier(true) - u.x.init(ftyp.TypeParams().list()) - if !u.unify(ftyp, mtyp) { + if !Identical(ftyp, mtyp) { return m, f } } @@ -388,27 +381,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, panic("method with type parameters") } - // If the methods have type parameters we don't care whether they - // are the same or not, as long as they match up. Use unification - // to see if they can be made to match. - // TODO(gri) is this always correct? what about type bounds? - // (Alternative is to rename/subst type parameters and compare.) - u := newUnifier(true) - if ftyp.TypeParams().Len() > 0 { - // We reach here only if we accept method type parameters. - // In this case, unification must consider any receiver - // and method type parameters as "free" type parameters. - assert(acceptMethodTypeParams) - // We don't have a test case for this at the moment since - // we can't parse method type parameters. Keeping the - // unimplemented call so that we test this code if we - // enable method type parameters. - unimplemented() - u.x.init(append(ftyp.RecvTypeParams().list(), ftyp.TypeParams().list()...)) - } else { - u.x.init(ftyp.RecvTypeParams().list()) - } - if !u.unify(ftyp, mtyp) { + if !Identical(ftyp, mtyp) { return m, f } } diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go index d35e53aa10..cc6be7493c 100644 --- a/src/go/types/lookup.go +++ b/src/go/types/lookup.go @@ -320,14 +320,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, panic("method with type parameters") } - // If the methods have type parameters we don't care whether they - // are the same or not, as long as they match up. Use unification - // to see if they can be made to match. - // TODO(gri) is this always correct? what about type bounds? - // (Alternative is to rename/subst type parameters and compare.) - u := newUnifier(true) - u.x.init(ftyp.TypeParams().list()) - if !u.unify(ftyp, mtyp) { + if !Identical(ftyp, mtyp) { return m, f } } @@ -375,14 +368,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method, panic("method with type parameters") } - // If the methods have type parameters we don't care whether they - // are the same or not, as long as they match up. Use unification - // to see if they can be made to match. - // TODO(gri) is this always correct? what about type bounds? - // (Alternative is to rename/subst type parameters and compare.) - u := newUnifier(true) - u.x.init(ftyp.RecvTypeParams().list()) - if !u.unify(ftyp, mtyp) { + if !Identical(ftyp, mtyp) { return m, f } } From 59122f85bd3a1231dd5b49fa83319d634bc96f23 Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Thu, 20 Jan 2022 11:17:51 -0500 Subject: [PATCH 670/752] runtime/pprof: allow labels on racecall in TestLabelSystemstack Fixes #50705. Change-Id: I85857f836cbe58447625df6cd56756d3a69880ff Reviewed-on: https://go-review.googlesource.com/c/go/+/379834 Trust: Michael Pratt Run-TryBot: Michael Pratt Reviewed-by: Bryan Mills TryBot-Result: Gopher Robot --- src/runtime/pprof/pprof_test.go | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index 54604598cc..19b9754e8b 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -1462,13 +1462,13 @@ func TestLabelSystemstack(t *testing.T) { // runtime.isSystemGoroutine). These // should never be labeled. mustNotBeLabeled = true - case "gogo", "gosave_systemstack_switch": - // These are context switch critical - // that we can't do a full traceback - // from. Typically this would be - // covered by the runtime check below, - // but these symbols don't have the - // package name. + case "gogo", "gosave_systemstack_switch", "racecall": + // These are context switch/race + // critical that we can't do a full + // traceback from. Typically this would + // be covered by the runtime check + // below, but these symbols don't have + // the package name. mayBeLabeled = true } From 65535bfe6dad2cb7535f6a5647b288e4489608f9 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Wed, 19 Jan 2022 13:38:05 -0500 Subject: [PATCH 671/752] cmd/go: ignore replaces of main modules in workspace modules And disallow replaces of any main modules in the go.work file itself. Change-Id: Ifa9ba9eaed047e6a75fcde230d96c7c450c1a1ad Reviewed-on: https://go-review.googlesource.com/c/go/+/379534 Trust: Michael Matloob Run-TryBot: Michael Matloob Reviewed-by: Bryan Mills TryBot-Result: Gopher Robot --- src/cmd/go/internal/modload/init.go | 7 +++ src/cmd/go/internal/modload/modfile.go | 3 ++ .../script/work_replace_main_module.txt | 45 +++++++++++++++++++ 3 files changed, 55 insertions(+) create mode 100644 src/cmd/go/testdata/script/work_replace_main_module.txt diff --git a/src/cmd/go/internal/modload/init.go b/src/cmd/go/internal/modload/init.go index fe7d0ef3e6..cdcfbeb8de 100644 --- a/src/cmd/go/internal/modload/init.go +++ b/src/cmd/go/internal/modload/init.go @@ -983,9 +983,16 @@ func makeMainModules(ms []module.Version, rootDirs []string, modFiles []*modfile workFileReplaceMap: toReplaceMap(workFileReplaces), highestReplaced: map[string]string{}, } + mainModulePaths := make(map[string]bool) + for _, m := range ms { + mainModulePaths[m.Path] = true + } replacedByWorkFile := make(map[string]bool) replacements := make(map[module.Version]module.Version) for _, r := range workFileReplaces { + if mainModulePaths[r.Old.Path] && r.Old.Version == "" { + base.Errorf("go: workspace module %v is replaced at all versions in the go.work file. To fix, remove the replacement from the go.work file or specify the version at which to replace the module.", r.Old.Path) + } replacedByWorkFile[r.Old.Path] = true v, ok := mainModules.highestReplaced[r.Old.Path] if !ok || semver.Compare(r.Old.Version, v) > 0 { diff --git a/src/cmd/go/internal/modload/modfile.go b/src/cmd/go/internal/modload/modfile.go index ec3f57ae3e..627cf1dbc0 100644 --- a/src/cmd/go/internal/modload/modfile.go +++ b/src/cmd/go/internal/modload/modfile.go @@ -340,6 +340,9 @@ func Replacement(mod module.Version) module.Version { foundFrom, found, foundModRoot := "", module.Version{}, "" if MainModules == nil { return module.Version{} + } else if MainModules.Contains(mod.Path) && mod.Version == "" { + // Don't replace the workspace version of the main module. + return module.Version{} } if _, r, ok := replacement(mod, MainModules.WorkFileReplaceMap()); ok { return r diff --git a/src/cmd/go/testdata/script/work_replace_main_module.txt b/src/cmd/go/testdata/script/work_replace_main_module.txt new file mode 100644 index 0000000000..b213764280 --- /dev/null +++ b/src/cmd/go/testdata/script/work_replace_main_module.txt @@ -0,0 +1,45 @@ +# Ensure that replaces of the main module in workspace modules +# are ignored, and replaces in the go.work file are disallowed. +# This tests against an issue where requirements of the +# main module were being ignored because the main module +# was replaced in a transitive dependency with another +# version. + +go list example.com/dep + +cp replace_main_module.go.work go.work +! go list example.com/dep +stderr 'go: workspace module example.com/mainmoda is replaced at all versions in the go.work file. To fix, remove the replacement from the go.work file or specify the version at which to replace the module.' + +-- replace_main_module.go.work -- +go 1.18 +use ( + ./mainmoda + ./mainmodb +) +replace example.com/mainmoda => ../mainmodareplacement +-- go.work -- +go 1.18 +use ( + ./mainmoda + ./mainmodb +) +-- mainmoda/go.mod -- +module example.com/mainmoda + +go 1.18 + +require example.com/dep v1.0.0 +replace example.com/dep => ../dep + +-- dep/go.mod -- +module example.com/dep +-- dep/dep.go -- +package dep +-- mainmodb/go.mod -- +module example.com/mainmodb +go 1.18 +replace example.com/mainmoda => ../mainmodareplacement +-- mainmodareplacement/go.mod -- +module example.com/mainmoda +go 1.18 \ No newline at end of file From 2c2e08144f79d8746384c2a483bf03532dc0c443 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 18 Jan 2022 18:46:00 -0800 Subject: [PATCH 672/752] runtime: remove -tags=threadprof in tests Use an enviroment variable rather than a build tag to control starting a busy loop thread when testprogcgo starts. This lets us skip another build that invokes the C compiler and linker, which should avoid timeouts running the runtime tests. Fixes #44422 Change-Id: I516668d71a373da311d844990236566ff63e6d72 Reviewed-on: https://go-review.googlesource.com/c/go/+/379294 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor Reviewed-by: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Austin Clements --- src/runtime/crash_cgo_test.go | 28 +++---------------- .../testdata/testprogcgo/threadprof.go | 19 ++++++++----- 2 files changed, 16 insertions(+), 31 deletions(-) diff --git a/src/runtime/crash_cgo_test.go b/src/runtime/crash_cgo_test.go index 6f1265c014..9444554d37 100644 --- a/src/runtime/crash_cgo_test.go +++ b/src/runtime/crash_cgo_test.go @@ -7,7 +7,6 @@ package runtime_test import ( - "bytes" "fmt" "internal/testenv" "os" @@ -95,17 +94,8 @@ func TestCgoExternalThreadSIGPROF(t *testing.T) { t.Skipf("no pthreads on %s", runtime.GOOS) } - exe, err := buildTestProg(t, "testprogcgo", "-tags=threadprof") - if err != nil { - t.Fatal(err) - } - - got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoExternalThreadSIGPROF")).CombinedOutput() - if err != nil { - t.Fatalf("exit status: %v\n%s", err, got) - } - - if want := "OK\n"; string(got) != want { + got := runTestProg(t, "testprogcgo", "CgoExternalThreadSIGPROF", "GO_START_SIGPROF_THREAD=1") + if want := "OK\n"; got != want { t.Fatalf("expected %q, but got:\n%s", want, got) } } @@ -118,18 +108,8 @@ func TestCgoExternalThreadSignal(t *testing.T) { t.Skipf("no pthreads on %s", runtime.GOOS) } - exe, err := buildTestProg(t, "testprogcgo", "-tags=threadprof") - if err != nil { - t.Fatal(err) - } - - got, err := testenv.CleanCmdEnv(exec.Command(exe, "CgoExternalThreadSignal")).CombinedOutput() - if err != nil { - t.Fatalf("exit status: %v\n%s", err, got) - } - - want := []byte("OK\n") - if !bytes.Equal(got, want) { + got := runTestProg(t, "testprogcgo", "CgoExternalThreadSignal") + if want := "OK\n"; got != want { t.Fatalf("expected %q, but got:\n%s", want, got) } } diff --git a/src/runtime/testdata/testprogcgo/threadprof.go b/src/runtime/testdata/testprogcgo/threadprof.go index 8081173c0f..d62d4b4be8 100644 --- a/src/runtime/testdata/testprogcgo/threadprof.go +++ b/src/runtime/testdata/testprogcgo/threadprof.go @@ -2,21 +2,22 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// We only build this file with the tag "threadprof", since it starts -// a thread running a busy loop at constructor time. - -//go:build !plan9 && !windows && threadprof -// +build !plan9,!windows,threadprof +//go:build !plan9 && !windows +// +build !plan9,!windows package main /* #include +#include #include #include volatile int32_t spinlock; +// Note that this thread is only started if GO_START_SIGPROF_THREAD +// is set in the environment, which is only done when running the +// CgoExternalThreadSIGPROF test. static void *thread1(void *p) { (void)p; while (spinlock == 0) @@ -26,9 +27,13 @@ static void *thread1(void *p) { return NULL; } +// This constructor function is run when the program starts. +// It is used for the CgoExternalThreadSIGPROF test. __attribute__((constructor)) void issue9456() { - pthread_t tid; - pthread_create(&tid, 0, thread1, NULL); + if (getenv("GO_START_SIGPROF_THREAD") != NULL) { + pthread_t tid; + pthread_create(&tid, 0, thread1, NULL); + } } void **nullptr; From 32636cd1ffc6cd9ef81d09b8320d2aaad4a21117 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Tue, 18 Jan 2022 12:55:17 -0800 Subject: [PATCH 673/752] cmd/compile: make sure multiple blank typeparams remain unique In a method declaration "func (f *Foo[_, _]) String() string { ... }", the two blank typeparams have the same name, but our current design with types1 needs unique names for type params. Similarly, for export/import, we need unique names to keep the type params straight in generic types and connect the proper type param with the proper constraint. We make blank type params unique by changing them to $1, $2, etc in noder.typ0() via typecheck.TparamExportName(). We then revert $ back to _ during type2 import via typecheck.TparamName(). We similarly revert during gcimporter import. We don't need/want to revert in the types1 importer, since we want unique names for type params. Rob Findley has made a similar change to x/tools (and we tried to make the source code changes similar for the gcimporter and types2 importer changes). Fixes #50419 Change-Id: I855cc3d90d06bcf59541ed0c879e9a0e4ede45bb Reviewed-on: https://go-review.googlesource.com/c/go/+/379194 Reviewed-by: Robert Griesemer Trust: Dan Scales --- src/cmd/compile/internal/importer/iimport.go | 11 ++++--- src/cmd/compile/internal/noder/types.go | 9 +++-- src/cmd/compile/internal/typecheck/iexport.go | 31 +++++++++++++++++ src/cmd/compile/internal/types2/decl.go | 11 ------- src/go/internal/gcimporter/iimport.go | 28 ++++++++++++---- src/go/types/decl.go | 13 -------- test/typeparam/issue50419.go | 33 +++++++++++++++++++ test/typeparam/issue50481.go | 21 ------------ test/typeparam/issue50481b.dir/b.go | 16 +++++++++ test/typeparam/issue50481b.dir/main.go | 23 +++++++++++++ test/typeparam/issue50481b.go | 7 ++++ test/typeparam/issue50481c.dir/a.go | 30 +++++++++++++++++ test/typeparam/issue50481c.dir/main.go | 18 ++++++++++ test/typeparam/issue50481c.go | 7 ++++ test/typeparam/issue50481c.out | 1 + 15 files changed, 200 insertions(+), 59 deletions(-) create mode 100644 test/typeparam/issue50419.go delete mode 100644 test/typeparam/issue50481.go create mode 100644 test/typeparam/issue50481b.dir/b.go create mode 100644 test/typeparam/issue50481b.dir/main.go create mode 100644 test/typeparam/issue50481b.go create mode 100644 test/typeparam/issue50481c.dir/a.go create mode 100644 test/typeparam/issue50481c.dir/main.go create mode 100644 test/typeparam/issue50481c.go create mode 100644 test/typeparam/issue50481c.out diff --git a/src/cmd/compile/internal/importer/iimport.go b/src/cmd/compile/internal/importer/iimport.go index 691e9b6976..a827987a48 100644 --- a/src/cmd/compile/internal/importer/iimport.go +++ b/src/cmd/compile/internal/importer/iimport.go @@ -9,6 +9,7 @@ package importer import ( "cmd/compile/internal/syntax" + "cmd/compile/internal/typecheck" "cmd/compile/internal/types2" "encoding/binary" "fmt" @@ -376,12 +377,12 @@ func (r *importReader) obj(name string) { if r.p.exportVersion < iexportVersionGenerics { errorf("unexpected type param type") } - // Remove the "path" from the type param name that makes it unique - ix := strings.LastIndex(name, ".") - if ix < 0 { - errorf("missing path for type param") + name0 := typecheck.TparamName(name) + if name0 == "" { + errorf("malformed type parameter export name %s: missing prefix", name) } - tn := types2.NewTypeName(pos, r.currPkg, name[ix+1:], nil) + + tn := types2.NewTypeName(pos, r.currPkg, name0, nil) t := types2.NewTypeParam(tn, nil) // To handle recursive references to the typeparam within its // bound, save the partial type in tparamIndex before reading the bounds. diff --git a/src/cmd/compile/internal/noder/types.go b/src/cmd/compile/internal/noder/types.go index 3f3c9566ca..e7ce4c1089 100644 --- a/src/cmd/compile/internal/noder/types.go +++ b/src/cmd/compile/internal/noder/types.go @@ -239,10 +239,13 @@ func (g *irgen) typ0(typ types2.Type) *types.Type { // Save the name of the type parameter in the sym of the type. // Include the types2 subscript in the sym name pkg := g.tpkg(typ) - // Create the unique types1 name for a type param, using its context with a - // function, type, or method declaration. + // Create the unique types1 name for a type param, using its context + // with a function, type, or method declaration. Also, map blank type + // param names to a unique name based on their type param index. The + // unique blank names will be exported, but will be reverted during + // types2 and gcimporter import. assert(g.curDecl != "") - nm := g.curDecl + "." + typ.Obj().Name() + nm := typecheck.TparamExportName(g.curDecl, typ.Obj().Name(), typ.Index()) sym := pkg.Lookup(nm) if sym.Def != nil { // Make sure we use the same type param type for the same diff --git a/src/cmd/compile/internal/typecheck/iexport.go b/src/cmd/compile/internal/typecheck/iexport.go index 7ebabe7314..ae3c41ca04 100644 --- a/src/cmd/compile/internal/typecheck/iexport.go +++ b/src/cmd/compile/internal/typecheck/iexport.go @@ -243,6 +243,7 @@ import ( "io" "math/big" "sort" + "strconv" "strings" "cmd/compile/internal/base" @@ -730,6 +731,36 @@ func (w *exportWriter) qualifiedIdent(n *ir.Name) { w.pkg(s.Pkg) } +const blankMarker = "$" + +// TparamExportName creates a unique name for type param in a method or a generic +// type, using the specified unique prefix and the index of the type param. The index +// is only used if the type param is blank, in which case the blank is replace by +// "$". A unique name is needed for later substitution in the compiler and +// export/import that keeps blank type params associated with the correct constraint. +func TparamExportName(prefix string, name string, index int) string { + if name == "_" { + name = blankMarker + strconv.Itoa(index) + } + return prefix + "." + name +} + +// TparamName returns the real name of a type parameter, after stripping its +// qualifying prefix and reverting blank-name encoding. See TparamExportName +// for details. +func TparamName(exportName string) string { + // Remove the "path" from the type param name that makes it unique. + ix := strings.LastIndex(exportName, ".") + if ix < 0 { + return "" + } + name := exportName[ix+1:] + if strings.HasPrefix(name, blankMarker) { + return "_" + } + return name +} + func (w *exportWriter) selector(s *types.Sym) { if w.currPkg == nil { base.Fatalf("missing currPkg") diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index 69388f78be..d61d2a8b0d 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -632,19 +632,8 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list []*syntax.Fiel // Declare type parameters up-front. // The scope of type parameters starts at the beginning of the type parameter // list (so we can have mutually recursive parameterized type bounds). - nblanks := 0 for i, f := range list { tparams[i] = check.declareTypeParam(f.Name) - // Issue #50481: For now, disallow multiple blank type parameters because - // it causes problems with export data. Report an error unless we are in - // testing mode ("assert" is defined). - // We expect to lift this restriction for Go 1.19. - if f.Name.Value == "_" { - nblanks++ - if nblanks == 2 && Universe.Lookup("assert") == nil { - check.softErrorf(f, "cannot have multiple blank type parameters (temporary restriction, see issue #50481)") - } - } } // Set the type parameters before collecting the type constraints because diff --git a/src/go/internal/gcimporter/iimport.go b/src/go/internal/gcimporter/iimport.go index ee8dd0ee7c..8ec4c5413b 100644 --- a/src/go/internal/gcimporter/iimport.go +++ b/src/go/internal/gcimporter/iimport.go @@ -369,12 +369,10 @@ func (r *importReader) obj(name string) { if r.p.exportVersion < iexportVersionGenerics { errorf("unexpected type param type") } - // Remove the "path" from the type param name that makes it unique - ix := strings.LastIndex(name, ".") - if ix < 0 { - errorf("missing path for type param") - } - tn := types.NewTypeName(pos, r.currPkg, name[ix+1:], nil) + // Remove the "path" from the type param name that makes it unique, + // and revert any unique name used for blank typeparams. + name0 := tparamName(name) + tn := types.NewTypeName(pos, r.currPkg, name0, nil) t := types.NewTypeParam(tn, nil) // To handle recursive references to the typeparam within its // bound, save the partial type in tparamIndex before reading the bounds. @@ -772,3 +770,21 @@ func baseType(typ types.Type) *types.Named { n, _ := typ.(*types.Named) return n } + +const blankMarker = "$" + +// tparamName returns the real name of a type parameter, after stripping its +// qualifying prefix and reverting blank-name encoding. See tparamExportName +// for details. +func tparamName(exportName string) string { + // Remove the "path" from the type param name that makes it unique. + ix := strings.LastIndex(exportName, ".") + if ix < 0 { + errorf("malformed type parameter export name %s: missing prefix", exportName) + } + name := exportName[ix+1:] + if strings.HasPrefix(name, blankMarker) { + return "_" + } + return name +} diff --git a/src/go/types/decl.go b/src/go/types/decl.go index bbd3f04b7e..02af0d5f3e 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -684,21 +684,8 @@ func (check *Checker) collectTypeParams(dst **TypeParamList, list *ast.FieldList // Declare type parameters up-front, with empty interface as type bound. // The scope of type parameters starts at the beginning of the type parameter // list (so we can have mutually recursive parameterized interfaces). - nblanks := 0 for _, f := range list.List { tparams = check.declareTypeParams(tparams, f.Names) - // Issue #50481: For now, disallow multiple blank type parameters because - // it causes problems with export data. Report an error unless we are in - // testing mode ("assert" is defined). - // We expect to lift this restriction for Go 1.19. - for _, name := range f.Names { - if name.Name == "_" { - nblanks++ - if nblanks == 2 && Universe.Lookup("assert") == nil { - check.softErrorf(name, _InvalidBlank, "cannot have multiple blank type parameters (temporary restriction, see issue #50481)") - } - } - } } // Set the type parameters before collecting the type constraints because diff --git a/test/typeparam/issue50419.go b/test/typeparam/issue50419.go new file mode 100644 index 0000000000..ff9d08d089 --- /dev/null +++ b/test/typeparam/issue50419.go @@ -0,0 +1,33 @@ +// run -gcflags=-G=3 + +// Copyright 2022 The Go 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 type substitution works correctly even for a method of a generic type +// that has multiple blank type params. + +package main + +import ( + "fmt" +) + +func main() { + foo := &Foo[string, int]{ + valueA: "i am a string", + valueB: 123, + } + if got, want := fmt.Sprintln(foo), "i am a string 123\n"; got != want { + panic(fmt.Sprintf("got %s, want %s", got, want)) + } +} + +type Foo[T1 any, T2 any] struct { + valueA T1 + valueB T2 +} + +func (f *Foo[_, _]) String() string { + return fmt.Sprintf("%v %v", f.valueA, f.valueB) +} diff --git a/test/typeparam/issue50481.go b/test/typeparam/issue50481.go deleted file mode 100644 index 23038356bf..0000000000 --- a/test/typeparam/issue50481.go +++ /dev/null @@ -1,21 +0,0 @@ -// errorcheck -G=3 - -// Copyright 2022 The Go 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 _[_ any] struct{} -type _[_, _ any] struct{} // ERROR "cannot have multiple blank type parameters" -type _[_, _, _ any] struct{} // ERROR "cannot have multiple blank type parameters" -type _[a, _, b, _, c, _ any] struct{} // ERROR "cannot have multiple blank type parameters" - -func _[_ any]() {} -func _[_, _ any]() {} // ERROR "cannot have multiple blank type parameters" -func _[_, _, _ any]() {} // ERROR "cannot have multiple blank type parameters" -func _[a, _, b, _, c, _ any]() {} // ERROR "cannot have multiple blank type parameters" - -type S[P1, P2 any] struct{} - -func (_ S[_, _]) m() {} // this is ok diff --git a/test/typeparam/issue50481b.dir/b.go b/test/typeparam/issue50481b.dir/b.go new file mode 100644 index 0000000000..d458357c51 --- /dev/null +++ b/test/typeparam/issue50481b.dir/b.go @@ -0,0 +1,16 @@ +// Copyright 2022 The Go 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 "fmt" + +type Foo[T1 ~string, T2 ~int] struct { + ValueA T1 + ValueB T2 +} + +func (f *Foo[_, _]) String() string { + return fmt.Sprintf("%v %v", f.ValueA, f.ValueB) +} diff --git a/test/typeparam/issue50481b.dir/main.go b/test/typeparam/issue50481b.dir/main.go new file mode 100644 index 0000000000..909d6e43fd --- /dev/null +++ b/test/typeparam/issue50481b.dir/main.go @@ -0,0 +1,23 @@ +// Copyright 2022 The Go 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 type substitution and export/import works correctly even for a method of +// a generic type that has multiple blank type params. + +package main + +import ( + "b" + "fmt" +) + +func main() { + foo := &b.Foo[string, int]{ + ValueA: "i am a string", + ValueB: 123, + } + if got, want := fmt.Sprintln(foo), "i am a string 123\n"; got != want { + panic(fmt.Sprintf("got %s, want %s", got, want)) + } +} diff --git a/test/typeparam/issue50481b.go b/test/typeparam/issue50481b.go new file mode 100644 index 0000000000..642f4bf49f --- /dev/null +++ b/test/typeparam/issue50481b.go @@ -0,0 +1,7 @@ +// rundir -G=3 + +// Copyright 2022 The Go 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/typeparam/issue50481c.dir/a.go b/test/typeparam/issue50481c.dir/a.go new file mode 100644 index 0000000000..384ba23f98 --- /dev/null +++ b/test/typeparam/issue50481c.dir/a.go @@ -0,0 +1,30 @@ +// Copyright 2022 The Go 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 A interface { + int | int64 +} + +type B interface { + string +} + +type C interface { + String() string +} + +type Myint int + +func (i Myint) String() string { + return "aa" +} + +type T[P A, _ C, _ B] int + +func (v T[P, Q, R]) test() { + var r Q + r.String() +} diff --git a/test/typeparam/issue50481c.dir/main.go b/test/typeparam/issue50481c.dir/main.go new file mode 100644 index 0000000000..4661976034 --- /dev/null +++ b/test/typeparam/issue50481c.dir/main.go @@ -0,0 +1,18 @@ +// Copyright 2022 The Go 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 type substitution works and export/import works correctly even for a +// generic type that has multiple blank type params. + +package main + +import ( + "a" + "fmt" +) + +func main() { + var x a.T[int, a.Myint, string] + fmt.Printf("%v\n", x) +} diff --git a/test/typeparam/issue50481c.go b/test/typeparam/issue50481c.go new file mode 100644 index 0000000000..642f4bf49f --- /dev/null +++ b/test/typeparam/issue50481c.go @@ -0,0 +1,7 @@ +// rundir -G=3 + +// Copyright 2022 The Go 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/typeparam/issue50481c.out b/test/typeparam/issue50481c.out new file mode 100644 index 0000000000..573541ac97 --- /dev/null +++ b/test/typeparam/issue50481c.out @@ -0,0 +1 @@ +0 From d15481b8c7f5f73a8b987a0c1deea04659ed0bb0 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 20 Jan 2022 16:20:33 -0800 Subject: [PATCH 674/752] Revert "doc/go1.18: document type parameter name restriction" This reverts CL 376414. For #47694. For #50481. Change-Id: Ie73961046e52e6e5d3262ef0aeaa24bec7eaa937 Reviewed-on: https://go-review.googlesource.com/c/go/+/379835 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 6 ------ 1 file changed, 6 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index a43b65d0a2..4d1b6520ee 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -108,12 +108,6 @@ Do not send CLs removing the interior tags from such phrases. interface type with a non-empty method set. Whether this will ever be permitted is unclear at present. -

  • - A generic type or function currently may declare at most one blank (_) - type parameter name. Note that it is always possible to use an arbitrary new - (unused) identifier in place of a blank type parameter name. - We plan to remove this restriction in Go 1.19. -

    • From 9eba5ff5219a76c3c4e020fa27e966a226174d7e Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Fri, 21 Jan 2022 11:07:52 -0500 Subject: [PATCH 675/752] runtime/pprof: TestLabelSystemstack parallelLabelHog.func1 must be labeled The closure in parallelLabelHog should be labeled in a addition to parallelLabelHog itself. Generally samples on that goroutine land on labelHog, but there is a small portion of the closure outside of labelHog. Fixes #50740. Change-Id: I363b6d8eec2e6920c215686e2039fce6d5b29a98 Reviewed-on: https://go-review.googlesource.com/c/go/+/380055 Reviewed-by: Bryan Mills Trust: Michael Pratt --- src/runtime/pprof/pprof_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index 19b9754e8b..1a44ab7ad7 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -1448,7 +1448,7 @@ func TestLabelSystemstack(t *testing.T) { for _, loc := range s.Location { for _, l := range loc.Line { switch l.Function.Name { - case "runtime/pprof.labelHog", "runtime/pprof.parallelLabelHog": + case "runtime/pprof.labelHog", "runtime/pprof.parallelLabelHog", "runtime/pprof.parallelLabelHog.func1": mustBeLabeled = true case "runtime/pprof.Do": // Do sets the labels, so samples may From 35b0db7607a33da662a510f85d30f18cd40c1149 Mon Sep 17 00:00:00 2001 From: Michael Matloob Date: Fri, 21 Jan 2022 16:05:02 -0500 Subject: [PATCH 676/752] cmd/go: evaluate root symlink in matchPackages This fixes checks for crossing module boundaries when the root of the module is a symlink. We're comparing paths by string, so we need to follow the symlink to get the proper path to compare. Change-Id: Idf5f0dd5c49bcae5fffb5372e99a7fab89169a9d Reviewed-on: https://go-review.googlesource.com/c/go/+/380057 Trust: Michael Matloob Run-TryBot: Michael Matloob Reviewed-by: Bryan Mills TryBot-Result: Gopher Robot --- src/cmd/go/internal/modload/search.go | 5 +++++ .../testdata/script/work_root_is_symlink.txt | 20 +++++++++++++++++++ 2 files changed, 25 insertions(+) create mode 100644 src/cmd/go/testdata/script/work_root_is_symlink.txt diff --git a/src/cmd/go/internal/modload/search.go b/src/cmd/go/internal/modload/search.go index 799c48e50a..771968d023 100644 --- a/src/cmd/go/internal/modload/search.go +++ b/src/cmd/go/internal/modload/search.go @@ -54,6 +54,11 @@ func matchPackages(ctx context.Context, m *search.Match, tags map[string]bool, f ) walkPkgs := func(root, importPathRoot string, prune pruning) { + // Follow root if it's a symlink so path == root comparisons don't + // spuriously fail when root is a symlink and it points to path. + if r, err := filepath.EvalSymlinks(root); err == nil { + root = r + } root = filepath.Clean(root) err := fsys.Walk(root, func(path string, fi fs.FileInfo, err error) error { if err != nil { diff --git a/src/cmd/go/testdata/script/work_root_is_symlink.txt b/src/cmd/go/testdata/script/work_root_is_symlink.txt new file mode 100644 index 0000000000..a1c0b46b67 --- /dev/null +++ b/src/cmd/go/testdata/script/work_root_is_symlink.txt @@ -0,0 +1,20 @@ +# Test that cmd/go follows the symlink and properly determines +# the module boundary when the working directory is a symlink. + +[!symlink] skip + +symlink worksym -> workspace +cd worksym +go list all +stdout example.com/workspace + +-- workspace/go.work -- +go 1.18 + +use . +-- workspace/go.mod -- +module example.com/workspace + +go 1.18 +-- workspace/pkg.go -- +package workspace \ No newline at end of file From b7fa0f941f05fdf8420f15cd5ebe2f209da172e0 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Fri, 21 Jan 2022 14:30:39 -0800 Subject: [PATCH 677/752] spec: minor formatting and link cleanups Mostly from CL 367954. Change-Id: Id003b0f785a286a1a649e4d6e8c87d0418a36545 Reviewed-on: https://go-review.googlesource.com/c/go/+/379920 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Robert Griesemer --- doc/go_spec.html | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index 0d7de5e6d1..b25cf5fa6e 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1,6 +1,6 @@ @@ -1602,7 +1602,6 @@ slice. If the key type is an interface type, these comparison operators must be defined for the dynamic key values; failure will cause a run-time panic. - 

    @@ -2260,7 +2259,6 @@ Functions:
 	make new panic print println real recover
    -

    Exported identifiers

    @@ -2936,7 +2934,7 @@ or a parenthesized expression.

    An operand name denoting a type-parameterized function -may be followed by a list of type arguments; the +may be followed by a list of type arguments; the resulting operand is an instantiated function.

    @@ -4130,8 +4128,8 @@ with the same underlying array.

    Instantiations

    -A parameterized function or type is instantiated by substituting type arguments -for the type parameters. +A parameterized function or type is instantiated by substituting +type arguments for the type parameters. Instantiation proceeds in two phases:

    @@ -4337,7 +4335,6 @@ The bitwise logical and shift operators apply to integers only. >> right shift integer >> integer >= 0 -

    Integer operators

    @@ -4430,6 +4427,7 @@ the unsigned integer's type. Loosely speaking, these unsigned integer operations discard high bits upon overflow, and programs may rely on "wrap around".

    +

    For signed integers, the operations +, -, *, /, and << may legally @@ -5934,7 +5932,7 @@ For a string value, the "range" clause iterates over the Unicode code points in the string starting at byte index 0. On successive iterations, the index value will be the index of the first byte of successive UTF-8-encoded code points in the string, and the second value, of type rune, will be the value of -the corresponding code point. If the iteration encounters an invalid +the corresponding code point. If the iteration encounters an invalid UTF-8 sequence, the second value will be 0xFFFD, the Unicode replacement character, and the next iteration will advance a single byte in the string. @@ -6485,7 +6483,6 @@ The multi-valued receive operation returns a received value along with an indication of whether the channel is closed.

    -

    Length and capacity

    @@ -6502,12 +6499,12 @@ len(s) string type string length in bytes []T slice length map[K]T map length (number of defined keys) chan T number of elements queued in channel buffer - type parameter see below + type parameter see below cap(s) [n]T, *[n]T array length (== n) []T slice capacity chan T channel buffer capacity - type parameter see below + type parameter see below

    From 0ef6dd74409506eb084bd8d2fe61e0e70ed9e5a4 Mon Sep 17 00:00:00 2001 From: Bryan Mills Date: Sat, 22 Jan 2022 03:42:40 +0000 Subject: [PATCH 678/752] Revert "cmd/go: evaluate root symlink in matchPackages" This reverts CL 380057. Reason for revert: appears to have broken x/tools tests on macOS. Change-Id: If1340bcb9b78f7271798c4dd923553e33db7f72e Reviewed-on: https://go-review.googlesource.com/c/go/+/380294 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Emmanuel Odeke --- src/cmd/go/internal/modload/search.go | 5 ----- .../testdata/script/work_root_is_symlink.txt | 20 ------------------- 2 files changed, 25 deletions(-) delete mode 100644 src/cmd/go/testdata/script/work_root_is_symlink.txt diff --git a/src/cmd/go/internal/modload/search.go b/src/cmd/go/internal/modload/search.go index 771968d023..799c48e50a 100644 --- a/src/cmd/go/internal/modload/search.go +++ b/src/cmd/go/internal/modload/search.go @@ -54,11 +54,6 @@ func matchPackages(ctx context.Context, m *search.Match, tags map[string]bool, f ) walkPkgs := func(root, importPathRoot string, prune pruning) { - // Follow root if it's a symlink so path == root comparisons don't - // spuriously fail when root is a symlink and it points to path. - if r, err := filepath.EvalSymlinks(root); err == nil { - root = r - } root = filepath.Clean(root) err := fsys.Walk(root, func(path string, fi fs.FileInfo, err error) error { if err != nil { diff --git a/src/cmd/go/testdata/script/work_root_is_symlink.txt b/src/cmd/go/testdata/script/work_root_is_symlink.txt deleted file mode 100644 index a1c0b46b67..0000000000 --- a/src/cmd/go/testdata/script/work_root_is_symlink.txt +++ /dev/null @@ -1,20 +0,0 @@ -# Test that cmd/go follows the symlink and properly determines -# the module boundary when the working directory is a symlink. - -[!symlink] skip - -symlink worksym -> workspace -cd worksym -go list all -stdout example.com/workspace - --- workspace/go.work -- -go 1.18 - -use . --- workspace/go.mod -- -module example.com/workspace - -go 1.18 --- workspace/pkg.go -- -package workspace \ No newline at end of file From 19d819d49c73c8e47749b3c4cbbc2e58a259269a Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Mon, 24 Jan 2022 09:27:31 -0500 Subject: [PATCH 679/752] runtime: call fflush before exiting in C test Very, very rarely TestVectoredHandlerDontCrashOnLibrary fails because the C subprocess exits with a 0 status code and no output. This appears to happen because C does not actually guarantee that stdout will be flushed on exit and somehow, very rarely, it is not flushed. Add explicit fflushes to fix this. This reduces the failure rate of TestVectoredHandlerDontCrashOnLibrary from 0.0013% to 0% in 250,000 iterations. Fixes #49959. Change-Id: I892cf49a165ac91134c5da37588a2ab11e1f3f8b Reviewed-on: https://go-review.googlesource.com/c/go/+/380494 Trust: Austin Clements Run-TryBot: Austin Clements TryBot-Result: Gopher Robot Reviewed-by: Bryan Mills --- src/runtime/testdata/testwinlib/main.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/runtime/testdata/testwinlib/main.c b/src/runtime/testdata/testwinlib/main.c index e84a32f753..c3fe3cb071 100644 --- a/src/runtime/testdata/testwinlib/main.c +++ b/src/runtime/testdata/testwinlib/main.c @@ -41,17 +41,20 @@ int main() if (NULL == exceptionHandlerHandle) { printf("cannot add vectored exception handler\n"); + fflush(stdout); return 2; } void *continueHandlerHandle = AddVectoredContinueHandler(0, customContinueHandlder); if (NULL == continueHandlerHandle) { printf("cannot add vectored continue handler\n"); + fflush(stdout); return 2; } CallMeBack(throwFromC); RemoveVectoredContinueHandler(continueHandlerHandle); RemoveVectoredExceptionHandler(exceptionHandlerHandle); printf("exceptionCount: %d\ncontinueCount: %d\n", exceptionCount, continueCount); + fflush(stdout); return 0; -} \ No newline at end of file +} From f9df4ea0c9426eecb93375d31e36cccf95b46e1f Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Thu, 20 Jan 2022 13:33:28 -0800 Subject: [PATCH 680/752] cmd/compile: improve comments, mainly in cmd/compile/internal/types Add some useful comments, mainly relates to types.Type. (No non-comment changes.) Change-Id: I3665ed69b180c4e790af2f9243f65c805083391a Reviewed-on: https://go-review.googlesource.com/c/go/+/379918 Reviewed-by: Matthew Dempsky Trust: Dan Scales --- src/cmd/compile/internal/typecheck/subr.go | 2 ++ src/cmd/compile/internal/types/type.go | 33 ++++++++++++++++------ 2 files changed, 27 insertions(+), 8 deletions(-) diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go index 9f6966233d..ac90d87f26 100644 --- a/src/cmd/compile/internal/typecheck/subr.go +++ b/src/cmd/compile/internal/typecheck/subr.go @@ -173,6 +173,8 @@ func AddImplicitDots(n *ir.SelectorExpr) *ir.SelectorExpr { return n } +// CalcMethods calculates all the methods (including embedding) of a non-interface +// type t. func CalcMethods(t *types.Type) { if t == nil || t.AllMethods().Len() != 0 { return diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go index 7d22e2da23..fe352e0b6e 100644 --- a/src/cmd/compile/internal/types/type.go +++ b/src/cmd/compile/internal/types/type.go @@ -75,7 +75,7 @@ const ( TNIL TBLANK - // pseudo-types for frame layout + // pseudo-types used temporarily only during frame layout (CalcSize()) TFUNCARGS TCHANARGS @@ -136,6 +136,14 @@ var ( ) // A Type represents a Go type. +// +// There may be multiple unnamed types with identical structure. However, there must +// be a unique Type object for each unique named (defined) type. After noding, a +// package-level type can be looked up by building its unique symbol sym (sym = +// package.Lookup(name)) and checking sym.Def. If sym.Def is non-nil, the type +// already exists at package scope and is available at sym.Def.(*ir.Name).Type(). +// Local types (which may have the same name as a package-level type) are +// distinguished by the value of vargen. type Type struct { // extra contains extra etype-specific fields. // As an optimization, those etype-specific structs which contain exactly @@ -154,6 +162,7 @@ type Type struct { // TSLICE: Slice // TSSA: string // TTYPEPARAM: *Typeparam + // TUNION: *Union extra interface{} // width is the width of this Type in bytes. @@ -230,7 +239,7 @@ func (t *Type) SetRecur(b bool) { t.flags.set(typeRecur, b) } // Generic types should never have alg functions. func (t *Type) SetHasTParam(b bool) { t.flags.set(typeHasTParam, b); t.flags.set(typeNoalg, b) } -// Should always do SetHasShape(true) when doing SeIsShape(true). +// Should always do SetHasShape(true) when doing SetIsShape(true). func (t *Type) SetIsShape(b bool) { t.flags.set(typeIsShape, b) } func (t *Type) SetHasShape(b bool) { t.flags.set(typeHasShape, b) } @@ -494,13 +503,17 @@ type Field struct { Embedded uint8 // embedded field - Pos src.XPos + Pos src.XPos + + // Name of field/method/parameter. Can be nil for interface fields embedded + // in interfaces and unnamed parameters. Sym *Sym Type *Type // field type Note string // literal string annotation - // For fields that represent function parameters, Nname points - // to the associated ONAME Node. + // For fields that represent function parameters, Nname points to the + // associated ONAME Node. For fields that represent methods, Nname points to + // the function name node. Nname Object // Offset in bytes of this field or method within its enclosing struct @@ -1018,7 +1031,9 @@ func (t *Type) Methods() *Fields { } // AllMethods returns a pointer to all the methods (including embedding) for type t. -// For an interface type, this is the set of methods that are typically iterated over. +// For an interface type, this is the set of methods that are typically iterated +// over. For non-interface types, AllMethods() only returns a valid result after +// CalcMethods() has been called at least once. func (t *Type) AllMethods() *Fields { if t.kind == TINTER { // Calculate the full method set of an interface type on the fly @@ -1749,8 +1764,9 @@ func (t *Type) SetVargen() { t.vargen = typeGen } -// SetUnderlying sets the underlying type. SetUnderlying automatically updates any -// types that were waiting for this type to be completed. +// SetUnderlying sets the underlying type of an incomplete type (i.e. type whose kind +// is currently TFORW). SetUnderlying automatically updates any types that were waiting +// for this type to be completed. func (t *Type) SetUnderlying(underlying *Type) { if underlying.kind == TFORW { // This type isn't computed yet; when it is, update n. @@ -2210,4 +2226,5 @@ var ( var SimType [NTYPE]Kind +// Fake package for shape types (see typecheck.Shapify()). var ShapePkg = NewPkg("go.shape", "go.shape") From f88c3b9f4d087895c3eab5ac4dd8459c76d0d0d8 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Wed, 19 Jan 2022 14:46:58 -0800 Subject: [PATCH 681/752] cmd/compile: distinguish bound calls/field access in getInstInfo Given we have support for field access to type params with a single structural type, we need to distinguish between methods calls and field access when we have an OXDOT node on an expression which is a typeparam (or correspondingly a shape). We were missing checks in getInstInfo, which figures out the dictionary format, which then caused problems when we generate the dictionaries. We don't need/want dictionary entries for field access, only for bound method calls. Added a new function isBoundMethod() to distinguish OXDOT nodes which are bound calls vs. field accesses on a shape. Removed isShapeDeref() - we can't have field access or method call on a pointer to variable of type param type. Fixes #50690 Change-Id: Id692f65e6f427f28cd2cfe474dd30e53c71877a7 Reviewed-on: https://go-review.googlesource.com/c/go/+/379674 Trust: Dan Scales Reviewed-by: Keith Randall --- src/cmd/compile/internal/noder/stencil.go | 54 +++++++++++--------- test/typeparam/issue50690a.go | 62 +++++++++++++++++++++++ test/typeparam/issue50690a.out | 1 + test/typeparam/issue50690b.go | 41 +++++++++++++++ test/typeparam/issue50690b.out | 1 + test/typeparam/issue50690c.go | 36 +++++++++++++ test/typeparam/issue50690c.out | 1 + 7 files changed, 173 insertions(+), 23 deletions(-) create mode 100644 test/typeparam/issue50690a.go create mode 100644 test/typeparam/issue50690a.out create mode 100644 test/typeparam/issue50690b.go create mode 100644 test/typeparam/issue50690b.out create mode 100644 test/typeparam/issue50690c.go create mode 100644 test/typeparam/issue50690c.out diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go index 66c73a9427..50b6c0efcd 100644 --- a/src/cmd/compile/internal/noder/stencil.go +++ b/src/cmd/compile/internal/noder/stencil.go @@ -1036,13 +1036,13 @@ func (subst *subster) node(n ir.Node) ir.Node { } case ir.OXDOT: - // Finish the transformation of an OXDOT, unless this was a - // bound call (a direct call on a type param). A bound call - // will be transformed during the dictPass. Otherwise, m - // will be transformed to an OMETHVALUE node. It will be - // transformed to an ODOTMETH or ODOTINTER node if we find in - // the OCALL case below that the method value is actually - // called. + // Finish the transformation of an OXDOT, unless this is + // bound call or field access on a type param. A bound call + // or field access on a type param will be transformed during + // the dictPass. Otherwise, m will be transformed to an + // OMETHVALUE node. It will be transformed to an ODOTMETH or + // ODOTINTER node if we find in the OCALL case below that the + // method value is actually called. mse := m.(*ir.SelectorExpr) if src := mse.X.Type(); !src.IsShape() { transformDot(mse, false) @@ -1101,10 +1101,11 @@ func (subst *subster) node(n ir.Node) ir.Node { transformEarlyCall(call) case ir.OXDOT: - // This is the case of a bound call on a typeparam, - // which will be handled in the dictPass. - // As with OFUNCINST, we must transform the arguments of the call now, - // so any needed CONVIFACE nodes are exposed. + // This is the case of a bound call or a field access + // on a typeparam, which will be handled in the + // dictPass. As with OFUNCINST, we must transform the + // arguments of the call now, so any needed CONVIFACE + // nodes are exposed. transformEarlyCall(call) case ir.ODOTTYPE, ir.ODOTTYPE2: @@ -1228,13 +1229,13 @@ func (g *genInst) dictPass(info *instInfo) { // No need for transformDot - buildClosure2 has already // transformed to OCALLINTER/ODOTINTER. } else { - dst := info.dictInfo.shapeToBound[m.(*ir.SelectorExpr).X.Type()] // If we can't find the selected method in the // AllMethods of the bound, then this must be an access // to a field of a structural type. If so, we skip the // dictionary lookups - transformDot() will convert to // the desired direct field access. - if typecheck.Lookdot1(mse, mse.Sel, dst, dst.AllMethods(), 1) != nil { + if isBoundMethod(info.dictInfo, mse) { + dst := info.dictInfo.shapeToBound[mse.X.Type()] // Implement x.M as a conversion-to-bound-interface // 1) convert x to the bound interface // 2) call M on that interface @@ -1873,11 +1874,15 @@ func (g *genInst) getInstInfo(st *ir.Func, shapes []*types.Type, instInfo *instI info.subDictCalls = append(info.subDictCalls, subDictInfo{callNode: n, savedXNode: ce.X}) } } - if ce.X.Op() == ir.OXDOT && - isShapeDeref(ce.X.(*ir.SelectorExpr).X.Type()) { + // Note: this XDOT code is not actually needed as long as we + // continue to disable type parameters on RHS of type + // declarations (#45639). + if ce.X.Op() == ir.OXDOT { callMap[ce.X] = true - infoPrint(" Optional subdictionary at generic bound call: %v\n", n) - info.subDictCalls = append(info.subDictCalls, subDictInfo{callNode: n, savedXNode: nil}) + if isBoundMethod(info, ce.X.(*ir.SelectorExpr)) { + infoPrint(" Optional subdictionary at generic bound call: %v\n", n) + info.subDictCalls = append(info.subDictCalls, subDictInfo{callNode: n, savedXNode: nil}) + } } case ir.OCALLMETH: ce := n.(*ir.CallExpr) @@ -1900,7 +1905,8 @@ func (g *genInst) getInstInfo(st *ir.Func, shapes []*types.Type, instInfo *instI info.itabConvs = append(info.itabConvs, n) } case ir.OXDOT: - if n.(*ir.SelectorExpr).X.Type().IsShape() { + se := n.(*ir.SelectorExpr) + if isBoundMethod(info, se) { infoPrint(" Itab for bound call: %v\n", n) info.itabConvs = append(info.itabConvs, n) } @@ -1956,11 +1962,13 @@ func (g *genInst) getInstInfo(st *ir.Func, shapes []*types.Type, instInfo *instI info.dictLen = len(info.shapeParams) + len(info.derivedTypes) + len(info.subDictCalls) + len(info.itabConvs) } -// isShapeDeref returns true if t is either a shape or a pointer to a shape. (We -// can't just use deref(t).IsShape(), since a shape type is a complex type and may -// have a pointer as part of its shape.) -func isShapeDeref(t *types.Type) bool { - return t.IsShape() || t.IsPtr() && t.Elem().IsShape() +// isBoundMethod returns true if the selection indicated by se is a bound method of +// se.X. se.X must be a shape type (i.e. substituted directly from a type param). If +// isBoundMethod returns false, then the selection must be a field access of a +// structural type. +func isBoundMethod(info *dictInfo, se *ir.SelectorExpr) bool { + bound := info.shapeToBound[se.X.Type()] + return typecheck.Lookdot1(se, se.Sel, bound, bound.AllMethods(), 1) != nil } // addType adds t to info.derivedTypes if it is parameterized type (which is not diff --git a/test/typeparam/issue50690a.go b/test/typeparam/issue50690a.go new file mode 100644 index 0000000000..5af3c9ead8 --- /dev/null +++ b/test/typeparam/issue50690a.go @@ -0,0 +1,62 @@ +// run -gcflags=-G=3 + +// Copyright 2022 The Go 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" +) + +// Numeric expresses a type constraint satisfied by any numeric type. +type Numeric interface { + ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | + ~int | ~int8 | ~int16 | ~int32 | ~int64 | + ~float32 | ~float64 | + ~complex64 | ~complex128 +} + +// Sum returns the sum of the provided arguments. +func Sum[T Numeric](args ...T) T { + var sum T + for i := 0; i < len(args); i++ { + sum += args[i] + } + return sum +} + +// Ledger is an identifiable, financial record. +type Ledger[T ~string, K Numeric] struct { + + // ID identifies the ledger. + ID T + + // Amounts is a list of monies associated with this ledger. + Amounts []K + + // SumFn is a function that can be used to sum the amounts + // in this ledger. + SumFn func(...K) K +} + +func PrintLedger[ + T ~string, + K Numeric, + L ~struct { + ID T + Amounts []K + SumFn func(...K) K + }, +](l L) { + fmt.Printf("%s has a sum of %v\n", l.ID, l.SumFn(l.Amounts...)) +} + +func main() { + PrintLedger(Ledger[string, int]{ + ID: "fake", + Amounts: []int{1, 2, 3}, + SumFn: Sum[int], + }) +} diff --git a/test/typeparam/issue50690a.out b/test/typeparam/issue50690a.out new file mode 100644 index 0000000000..293276716f --- /dev/null +++ b/test/typeparam/issue50690a.out @@ -0,0 +1 @@ +fake has a sum of 6 diff --git a/test/typeparam/issue50690b.go b/test/typeparam/issue50690b.go new file mode 100644 index 0000000000..498b9d37e1 --- /dev/null +++ b/test/typeparam/issue50690b.go @@ -0,0 +1,41 @@ +// run -gcflags=-G=3 + +// Copyright 2022 The Go 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 Printer[T ~string] struct { + PrintFn func(T) +} + +func Print[T ~string](s T) { + fmt.Println(s) +} + +func PrintWithPrinter[T ~string, S ~struct { + ID T + PrintFn func(T) +}](message T, obj S) { + obj.PrintFn(message) +} + +type PrintShop[T ~string] struct { + ID T + PrintFn func(T) +} + +func main() { + PrintWithPrinter( + "Hello, world.", + PrintShop[string]{ + ID: "fake", + PrintFn: Print[string], + }, + ) +} diff --git a/test/typeparam/issue50690b.out b/test/typeparam/issue50690b.out new file mode 100644 index 0000000000..f75ba05f34 --- /dev/null +++ b/test/typeparam/issue50690b.out @@ -0,0 +1 @@ +Hello, world. diff --git a/test/typeparam/issue50690c.go b/test/typeparam/issue50690c.go new file mode 100644 index 0000000000..aa9258f932 --- /dev/null +++ b/test/typeparam/issue50690c.go @@ -0,0 +1,36 @@ +// run -gcflags=-G=3 + +// Copyright 2022 The Go 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 Printer[T ~string] struct { + PrintFn func(T) +} + +func Print[T ~string](s T) { + fmt.Println(s) +} + +func PrintWithPrinter[T ~string, S struct { + ID T + PrintFn func(T) +}](message T, obj S) { + obj.PrintFn(message) +} + +func main() { + PrintWithPrinter( + "Hello, world.", + struct { + ID string + PrintFn func(string) + }{ID: "fake", PrintFn: Print[string]}, + ) +} diff --git a/test/typeparam/issue50690c.out b/test/typeparam/issue50690c.out new file mode 100644 index 0000000000..f75ba05f34 --- /dev/null +++ b/test/typeparam/issue50690c.out @@ -0,0 +1 @@ +Hello, world. From 97e740e8b0ff1b32b164b0cbef06c12c4d591f3f Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Fri, 21 Jan 2022 16:52:56 -0500 Subject: [PATCH 682/752] runtime: replace TestFutexsleep with TestTimediv TestFutexsleep was originally created in CL 7876043 as a regression test for buggy division logic in futexsleep. Several months later CL 11575044 moved this logic to timediv (called by futexsleep). This test calls runtime.Futexsleep, which temporarily disables asynchronous preemption. Unfortunately, TestFutexSleep calls this from multiple goroutines, creating a race condition that may result in asynchronous preemption remaining disabled for the remainder of the process lifetime. We could fix this by moving the async preemption disable to the main test function, however this test has had a history of flakiness. As an alternative, this CL replaces the test wholesale with a new test for timediv, covering the overflow logic without the difficulty of dealing with futex. Fixes #50749. Change-Id: If9e1dac63ef1535adb49f9a9ffcaff99b9135895 Reviewed-on: https://go-review.googlesource.com/c/go/+/380058 Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot Reviewed-by: Cherry Mui Reviewed-by: Michael Knyszek --- src/runtime/export_futex_test.go | 19 ------- src/runtime/export_test.go | 2 + src/runtime/futex_test.go | 87 -------------------------------- src/runtime/runtime_test.go | 76 ++++++++++++++++++++++++++++ 4 files changed, 78 insertions(+), 106 deletions(-) delete mode 100644 src/runtime/export_futex_test.go delete mode 100644 src/runtime/futex_test.go diff --git a/src/runtime/export_futex_test.go b/src/runtime/export_futex_test.go deleted file mode 100644 index 03157d8eed..0000000000 --- a/src/runtime/export_futex_test.go +++ /dev/null @@ -1,19 +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. - -//go:build dragonfly || freebsd || linux - -package runtime - -var Futexwakeup = futexwakeup - -//go:nosplit -func Futexsleep(addr *uint32, val uint32, ns int64) { - // Temporarily disable preemption so that a preemption signal - // doesn't interrupt the system call. - poff := debug.asyncpreemptoff - debug.asyncpreemptoff = 1 - futexsleep(addr, val, ns) - debug.asyncpreemptoff = poff -} diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go index 3c8f9eb49b..0f21838721 100644 --- a/src/runtime/export_test.go +++ b/src/runtime/export_test.go @@ -1328,3 +1328,5 @@ func Acquirem() { func Releasem() { releasem(getg().m) } + +var Timediv = timediv diff --git a/src/runtime/futex_test.go b/src/runtime/futex_test.go deleted file mode 100644 index 188d0c6525..0000000000 --- a/src/runtime/futex_test.go +++ /dev/null @@ -1,87 +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. - -// Futex is only available on DragonFly BSD, FreeBSD and Linux. -// The race detector emits calls to split stack functions so it breaks -// the test. - -//go:build (dragonfly || freebsd || linux) && !race - -package runtime_test - -import ( - "runtime" - "sync" - "sync/atomic" - "testing" - "time" -) - -type futexsleepTest struct { - mtx uint32 - ns int64 - msg string - ch chan *futexsleepTest -} - -var futexsleepTests = []futexsleepTest{ - beforeY2038: {mtx: 0, ns: 86400 * 1e9, msg: "before the year 2038"}, - afterY2038: {mtx: 0, ns: (1<<31 + 100) * 1e9, msg: "after the year 2038"}, -} - -const ( - beforeY2038 = iota - afterY2038 -) - -func TestFutexsleep(t *testing.T) { - if runtime.GOMAXPROCS(0) > 1 { - // futexsleep doesn't handle EINTR or other signals, - // so spurious wakeups may happen. - t.Skip("skipping; GOMAXPROCS>1") - } - - start := time.Now() - var wg sync.WaitGroup - for i := range futexsleepTests { - tt := &futexsleepTests[i] - tt.mtx = 0 - tt.ch = make(chan *futexsleepTest, 1) - wg.Add(1) - go func(tt *futexsleepTest) { - runtime.Entersyscall() - runtime.Futexsleep(&tt.mtx, 0, tt.ns) - runtime.Exitsyscall() - tt.ch <- tt - wg.Done() - }(tt) - } -loop: - for { - select { - case tt := <-futexsleepTests[beforeY2038].ch: - t.Errorf("futexsleep test %q finished early after %s", tt.msg, time.Since(start)) - break loop - case tt := <-futexsleepTests[afterY2038].ch: - // Looks like FreeBSD 10 kernel has changed - // the semantics of timedwait on userspace - // mutex to make broken stuff look broken. - switch { - case runtime.GOOS == "freebsd" && runtime.GOARCH == "386": - t.Log("freebsd/386 may not work correctly after the year 2038, see golang.org/issue/7194") - default: - t.Errorf("futexsleep test %q finished early after %s", tt.msg, time.Since(start)) - break loop - } - case <-time.After(time.Second): - break loop - } - } - for i := range futexsleepTests { - tt := &futexsleepTests[i] - atomic.StoreUint32(&tt.mtx, 1) - runtime.Futexwakeup(&tt.mtx, 1) - } - wg.Wait() -} diff --git a/src/runtime/runtime_test.go b/src/runtime/runtime_test.go index 1ca1fa2f05..12f261bdd2 100644 --- a/src/runtime/runtime_test.go +++ b/src/runtime/runtime_test.go @@ -6,6 +6,7 @@ package runtime_test import ( "flag" + "fmt" "io" . "runtime" "runtime/debug" @@ -362,3 +363,78 @@ func TestVersion(t *testing.T) { t.Fatalf("cr/nl in version: %q", vers) } } + +func TestTimediv(t *testing.T) { + for _, tc := range []struct { + num int64 + div int32 + ret int32 + rem int32 + }{ + { + num: 8, + div: 2, + ret: 4, + rem: 0, + }, + { + num: 9, + div: 2, + ret: 4, + rem: 1, + }, + { + // Used by runtime.check. + num: 12345*1000000000 + 54321, + div: 1000000000, + ret: 12345, + rem: 54321, + }, + { + num: 1<<32 - 1, + div: 2, + ret: 1<<31 - 1, // no overflow. + rem: 1, + }, + { + num: 1 << 32, + div: 2, + ret: 1<<31 - 1, // overflow. + rem: 0, + }, + { + num: 1 << 40, + div: 2, + ret: 1<<31 - 1, // overflow. + rem: 0, + }, + { + num: 1<<40 + 1, + div: 1 << 10, + ret: 1 << 30, + rem: 1, + }, + } { + name := fmt.Sprintf("%d div %d", tc.num, tc.div) + t.Run(name, func(t *testing.T) { + // Double check that the inputs make sense using + // standard 64-bit division. + ret64 := tc.num / int64(tc.div) + rem64 := tc.num % int64(tc.div) + if ret64 != int64(int32(ret64)) { + // Simulate timediv overflow value. + ret64 = 1<<31 - 1 + rem64 = 0 + } + if ret64 != int64(tc.ret) { + t.Errorf("%d / %d got ret %d rem %d want ret %d rem %d", tc.num, tc.div, ret64, rem64, tc.ret, tc.rem) + } + + var rem int32 + ret := Timediv(tc.num, tc.div, &rem) + if ret != tc.ret || rem != tc.rem { + t.Errorf("timediv %d / %d got ret %d rem %d want ret %d rem %d", tc.num, tc.div, ret, rem, tc.ret, tc.rem) + } + }) + } +} From 48ec6df16c285cda50bd38970b82402e8c46919b Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Sat, 22 Jan 2022 12:24:41 -0500 Subject: [PATCH 683/752] go/types: panic if named type instances are mutated Change-Id: Idc4d561c7037f33aa9c844b411c38c6cb5bbfbcd Reviewed-on: https://go-review.googlesource.com/c/go/+/380374 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/named.go | 10 +++++++++- src/go/types/named.go | 10 +++++++++- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go index 51ea27a6db..c4217fa508 100644 --- a/src/cmd/compile/internal/types2/named.go +++ b/src/cmd/compile/internal/types2/named.go @@ -88,7 +88,11 @@ func (t *Named) Origin() *Named { return t.orig } func (t *Named) TypeParams() *TypeParamList { return t.resolve(nil).tparams } // SetTypeParams sets the type parameters of the named type t. -func (t *Named) SetTypeParams(tparams []*TypeParam) { t.resolve(nil).tparams = bindTParams(tparams) } +// t must not have type arguments. +func (t *Named) SetTypeParams(tparams []*TypeParam) { + assert(t.targs.Len() == 0) + t.resolve(nil).tparams = bindTParams(tparams) +} // TypeArgs returns the type arguments used to instantiate the named type t. func (t *Named) TypeArgs() *TypeList { return t.targs } @@ -100,7 +104,9 @@ func (t *Named) NumMethods() int { return len(t.resolve(nil).methods) } func (t *Named) Method(i int) *Func { return t.resolve(nil).methods[i] } // SetUnderlying sets the underlying type and marks t as complete. +// t must not have type arguments. func (t *Named) SetUnderlying(underlying Type) { + assert(t.targs.Len() == 0) if underlying == nil { panic("underlying type must not be nil") } @@ -111,7 +117,9 @@ func (t *Named) SetUnderlying(underlying Type) { } // AddMethod adds method m unless it is already in the method list. +// t must not have type arguments. func (t *Named) AddMethod(m *Func) { + assert(t.targs.Len() == 0) t.resolve(nil) if i, _ := lookupMethod(t.methods, m.pkg, m.name); i < 0 { t.methods = append(t.methods, m) diff --git a/src/go/types/named.go b/src/go/types/named.go index 82a053dd0d..a44686bc36 100644 --- a/src/go/types/named.go +++ b/src/go/types/named.go @@ -90,7 +90,11 @@ func (t *Named) Origin() *Named { return t.orig } func (t *Named) TypeParams() *TypeParamList { return t.resolve(nil).tparams } // SetTypeParams sets the type parameters of the named type t. -func (t *Named) SetTypeParams(tparams []*TypeParam) { t.resolve(nil).tparams = bindTParams(tparams) } +// t must not have type arguments. +func (t *Named) SetTypeParams(tparams []*TypeParam) { + assert(t.targs.Len() == 0) + t.resolve(nil).tparams = bindTParams(tparams) +} // TypeArgs returns the type arguments used to instantiate the named type t. func (t *Named) TypeArgs() *TypeList { return t.targs } @@ -102,7 +106,9 @@ func (t *Named) NumMethods() int { return len(t.resolve(nil).methods) } func (t *Named) Method(i int) *Func { return t.resolve(nil).methods[i] } // SetUnderlying sets the underlying type and marks t as complete. +// t must not have type arguments. func (t *Named) SetUnderlying(underlying Type) { + assert(t.targs.Len() == 0) if underlying == nil { panic("underlying type must not be nil") } @@ -113,7 +119,9 @@ func (t *Named) SetUnderlying(underlying Type) { } // AddMethod adds method m unless it is already in the method list. +// t must not have type arguments. func (t *Named) AddMethod(m *Func) { + assert(t.targs.Len() == 0) t.resolve(nil) if i, _ := lookupMethod(t.methods, m.pkg, m.name); i < 0 { t.methods = append(t.methods, m) From b850f3629fa9c2dfb6a94a3d0e472a0cc87b949c Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Mon, 24 Jan 2022 10:30:36 -0800 Subject: [PATCH 684/752] cmd/compile: always print stack trace for -dpanic Change-Id: I40cfc87731d3a29670a3e183948898ea0cb2402d Reviewed-on: https://go-review.googlesource.com/c/go/+/380534 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor Reviewed-by: Russ Cox TryBot-Result: Gopher Robot --- src/cmd/compile/internal/base/print.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cmd/compile/internal/base/print.go b/src/cmd/compile/internal/base/print.go index 4afe2eb9ee..955f9d2077 100644 --- a/src/cmd/compile/internal/base/print.go +++ b/src/cmd/compile/internal/base/print.go @@ -217,10 +217,10 @@ func FatalfAt(pos src.XPos, format string, args ...interface{}) { fmt.Printf("\n") // If this is a released compiler version, ask for a bug report. - if strings.HasPrefix(buildcfg.Version, "go") { + if Debug.Panic == 0 && strings.HasPrefix(buildcfg.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") + fmt.Printf("https://go.dev/issue/new\n") } else { // Not a release; dump a stack trace, too. fmt.Println() From 0328b4f4cae6d2340ded9a7d2ce850b98d3bbcbe Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 14 Jan 2022 17:01:43 -0800 Subject: [PATCH 685/752] go/types, types2: move validType code into its own file The validType check is independent of the work of declaring objects. Move it into a separate file for better separation of concerns and code organization. No other changes - this is purely a code move. Preparation for fixing issue #48962. Change-Id: Ib08db2d009c4890882d0978b278e965ca3078851 Reviewed-on: https://go-review.googlesource.com/c/go/+/378674 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/decl.go | 90 ------------------- src/cmd/compile/internal/types2/validtype.go | 95 ++++++++++++++++++++ src/go/types/decl.go | 90 ------------------- src/go/types/validtype.go | 95 ++++++++++++++++++++ 4 files changed, 190 insertions(+), 180 deletions(-) create mode 100644 src/cmd/compile/internal/types2/validtype.go create mode 100644 src/go/types/validtype.go diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index d61d2a8b0d..22cea584d4 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -304,96 +304,6 @@ loop: return false } -type typeInfo uint - -// validType verifies that the given type does not "expand" infinitely -// producing a cycle in the type graph. Cycles are detected by marking -// defined types. -// (Cycles involving alias types, as in "type A = [10]A" are detected -// earlier, via the objDecl cycle detection mechanism.) -func (check *Checker) validType(typ Type, path []Object) typeInfo { - const ( - unknown typeInfo = iota - marked - valid - invalid - ) - - switch t := typ.(type) { - case *Array: - return check.validType(t.elem, path) - - case *Struct: - for _, f := range t.fields { - if check.validType(f.typ, path) == invalid { - return invalid - } - } - - case *Union: - for _, t := range t.terms { - if check.validType(t.typ, path) == invalid { - return invalid - } - } - - case *Interface: - for _, etyp := range t.embeddeds { - if check.validType(etyp, path) == invalid { - return invalid - } - } - - case *Named: - // If t is parameterized, we should be considering the instantiated (expanded) - // form of t, but in general we can't with this algorithm: if t is an invalid - // type it may be so because it infinitely expands through a type parameter. - // Instantiating such a type would lead to an infinite sequence of instantiations. - // In general, we need "type flow analysis" to recognize those cases. - // Example: type A[T any] struct{ x A[*T] } (issue #48951) - // In this algorithm we always only consider the original, uninstantiated type. - // This won't recognize some invalid cases with parameterized types, but it - // will terminate. - t = t.orig - - // don't touch the type if it is from a different package or the Universe scope - // (doing so would lead to a race condition - was issue #35049) - if t.obj.pkg != check.pkg { - return valid - } - - // don't report a 2nd error if we already know the type is invalid - // (e.g., if a cycle was detected earlier, via under). - if t.underlying == Typ[Invalid] { - t.info = invalid - return invalid - } - - switch t.info { - case unknown: - t.info = marked - t.info = check.validType(t.fromRHS, append(path, t.obj)) // only types of current package added to path - case marked: - // cycle detected - for i, tn := range path { - if t.obj.pkg != check.pkg { - panic("type cycle via package-external type") - } - if tn == t.obj { - check.cycleError(path[i:]) - t.info = invalid - t.underlying = Typ[Invalid] - return invalid - } - } - panic("cycle start not found") - } - return t.info - } - - return valid -} - // cycleError reports a declaration cycle starting with // the object in cycle that is "first" in the source. func (check *Checker) cycleError(cycle []Object) { diff --git a/src/cmd/compile/internal/types2/validtype.go b/src/cmd/compile/internal/types2/validtype.go new file mode 100644 index 0000000000..24d65e2c24 --- /dev/null +++ b/src/cmd/compile/internal/types2/validtype.go @@ -0,0 +1,95 @@ +// Copyright 2022 The Go 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 types2 + +type typeInfo uint + +// validType verifies that the given type does not "expand" infinitely +// producing a cycle in the type graph. Cycles are detected by marking +// defined types. +// (Cycles involving alias types, as in "type A = [10]A" are detected +// earlier, via the objDecl cycle detection mechanism.) +func (check *Checker) validType(typ Type, path []Object) typeInfo { + const ( + unknown typeInfo = iota + marked + valid + invalid + ) + + switch t := typ.(type) { + case *Array: + return check.validType(t.elem, path) + + case *Struct: + for _, f := range t.fields { + if check.validType(f.typ, path) == invalid { + return invalid + } + } + + case *Union: + for _, t := range t.terms { + if check.validType(t.typ, path) == invalid { + return invalid + } + } + + case *Interface: + for _, etyp := range t.embeddeds { + if check.validType(etyp, path) == invalid { + return invalid + } + } + + case *Named: + // If t is parameterized, we should be considering the instantiated (expanded) + // form of t, but in general we can't with this algorithm: if t is an invalid + // type it may be so because it infinitely expands through a type parameter. + // Instantiating such a type would lead to an infinite sequence of instantiations. + // In general, we need "type flow analysis" to recognize those cases. + // Example: type A[T any] struct{ x A[*T] } (issue #48951) + // In this algorithm we always only consider the original, uninstantiated type. + // This won't recognize some invalid cases with parameterized types, but it + // will terminate. + t = t.orig + + // don't touch the type if it is from a different package or the Universe scope + // (doing so would lead to a race condition - was issue #35049) + if t.obj.pkg != check.pkg { + return valid + } + + // don't report a 2nd error if we already know the type is invalid + // (e.g., if a cycle was detected earlier, via under). + if t.underlying == Typ[Invalid] { + t.info = invalid + return invalid + } + + switch t.info { + case unknown: + t.info = marked + t.info = check.validType(t.fromRHS, append(path, t.obj)) // only types of current package added to path + case marked: + // cycle detected + for i, tn := range path { + if t.obj.pkg != check.pkg { + panic("type cycle via package-external type") + } + if tn == t.obj { + check.cycleError(path[i:]) + t.info = invalid + t.underlying = Typ[Invalid] + return invalid + } + } + panic("cycle start not found") + } + return t.info + } + + return valid +} diff --git a/src/go/types/decl.go b/src/go/types/decl.go index 02af0d5f3e..5b54465f18 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -303,96 +303,6 @@ loop: return false } -type typeInfo uint - -// validType verifies that the given type does not "expand" infinitely -// producing a cycle in the type graph. Cycles are detected by marking -// defined types. -// (Cycles involving alias types, as in "type A = [10]A" are detected -// earlier, via the objDecl cycle detection mechanism.) -func (check *Checker) validType(typ Type, path []Object) typeInfo { - const ( - unknown typeInfo = iota - marked - valid - invalid - ) - - switch t := typ.(type) { - case *Array: - return check.validType(t.elem, path) - - case *Struct: - for _, f := range t.fields { - if check.validType(f.typ, path) == invalid { - return invalid - } - } - - case *Union: - for _, t := range t.terms { - if check.validType(t.typ, path) == invalid { - return invalid - } - } - - case *Interface: - for _, etyp := range t.embeddeds { - if check.validType(etyp, path) == invalid { - return invalid - } - } - - case *Named: - // If t is parameterized, we should be considering the instantiated (expanded) - // form of t, but in general we can't with this algorithm: if t is an invalid - // type it may be so because it infinitely expands through a type parameter. - // Instantiating such a type would lead to an infinite sequence of instantiations. - // In general, we need "type flow analysis" to recognize those cases. - // Example: type A[T any] struct{ x A[*T] } (issue #48951) - // In this algorithm we always only consider the original, uninstantiated type. - // This won't recognize some invalid cases with parameterized types, but it - // will terminate. - t = t.orig - - // don't touch the type if it is from a different package or the Universe scope - // (doing so would lead to a race condition - was issue #35049) - if t.obj.pkg != check.pkg { - return valid - } - - // don't report a 2nd error if we already know the type is invalid - // (e.g., if a cycle was detected earlier, via under). - if t.underlying == Typ[Invalid] { - t.info = invalid - return invalid - } - - switch t.info { - case unknown: - t.info = marked - t.info = check.validType(t.fromRHS, append(path, t.obj)) // only types of current package added to path - case marked: - // cycle detected - for i, tn := range path { - if t.obj.pkg != check.pkg { - panic("type cycle via package-external type") - } - if tn == t.obj { - check.cycleError(path[i:]) - t.info = invalid - t.underlying = Typ[Invalid] - return invalid - } - } - panic("cycle start not found") - } - return t.info - } - - return valid -} - // cycleError reports a declaration cycle starting with // the object in cycle that is "first" in the source. func (check *Checker) cycleError(cycle []Object) { diff --git a/src/go/types/validtype.go b/src/go/types/validtype.go new file mode 100644 index 0000000000..8972a7ad85 --- /dev/null +++ b/src/go/types/validtype.go @@ -0,0 +1,95 @@ +// Copyright 2022 The Go 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 + +type typeInfo uint + +// validType verifies that the given type does not "expand" infinitely +// producing a cycle in the type graph. Cycles are detected by marking +// defined types. +// (Cycles involving alias types, as in "type A = [10]A" are detected +// earlier, via the objDecl cycle detection mechanism.) +func (check *Checker) validType(typ Type, path []Object) typeInfo { + const ( + unknown typeInfo = iota + marked + valid + invalid + ) + + switch t := typ.(type) { + case *Array: + return check.validType(t.elem, path) + + case *Struct: + for _, f := range t.fields { + if check.validType(f.typ, path) == invalid { + return invalid + } + } + + case *Union: + for _, t := range t.terms { + if check.validType(t.typ, path) == invalid { + return invalid + } + } + + case *Interface: + for _, etyp := range t.embeddeds { + if check.validType(etyp, path) == invalid { + return invalid + } + } + + case *Named: + // If t is parameterized, we should be considering the instantiated (expanded) + // form of t, but in general we can't with this algorithm: if t is an invalid + // type it may be so because it infinitely expands through a type parameter. + // Instantiating such a type would lead to an infinite sequence of instantiations. + // In general, we need "type flow analysis" to recognize those cases. + // Example: type A[T any] struct{ x A[*T] } (issue #48951) + // In this algorithm we always only consider the original, uninstantiated type. + // This won't recognize some invalid cases with parameterized types, but it + // will terminate. + t = t.orig + + // don't touch the type if it is from a different package or the Universe scope + // (doing so would lead to a race condition - was issue #35049) + if t.obj.pkg != check.pkg { + return valid + } + + // don't report a 2nd error if we already know the type is invalid + // (e.g., if a cycle was detected earlier, via under). + if t.underlying == Typ[Invalid] { + t.info = invalid + return invalid + } + + switch t.info { + case unknown: + t.info = marked + t.info = check.validType(t.fromRHS, append(path, t.obj)) // only types of current package added to path + case marked: + // cycle detected + for i, tn := range path { + if t.obj.pkg != check.pkg { + panic("type cycle via package-external type") + } + if tn == t.obj { + check.cycleError(path[i:]) + t.info = invalid + t.underlying = Typ[Invalid] + return invalid + } + } + panic("cycle start not found") + } + return t.info + } + + return valid +} From 4284d4555382ec9da4b301afe328faf850158ffb Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 12 Jan 2022 15:54:15 -0800 Subject: [PATCH 686/752] go/types, types2: use a map instead of a field for marking in validType With this change validType doesn't modify global state anymore. It also eliminates the need for an extra field in each object. Preparation for fixing issue #48962. Change-Id: If241ec77ff48911d5b43d89adabfb8ef54452c6b Reviewed-on: https://go-review.googlesource.com/c/go/+/378176 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/check.go | 2 ++ src/cmd/compile/internal/types2/decl.go | 2 +- src/cmd/compile/internal/types2/named.go | 1 - .../compile/internal/types2/sizeof_test.go | 2 +- src/cmd/compile/internal/types2/typexpr.go | 2 +- src/cmd/compile/internal/types2/validtype.go | 32 +++++++++++-------- src/go/types/check.go | 2 ++ src/go/types/decl.go | 2 +- src/go/types/named.go | 1 - src/go/types/sizeof_test.go | 2 +- src/go/types/typexpr.go | 2 +- src/go/types/validtype.go | 32 +++++++++++-------- 12 files changed, 46 insertions(+), 36 deletions(-) diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go index 22a921d0d7..cce324633e 100644 --- a/src/cmd/compile/internal/types2/check.go +++ b/src/cmd/compile/internal/types2/check.go @@ -111,6 +111,7 @@ type Checker struct { nextID uint64 // unique Id for type parameters (first valid Id is 1) 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 + infoMap map[*Named]typeInfo // maps named types to their associated type info (for cycle detection) // pkgPathMap maps package names to the set of distinct import paths we've // seen for that name, anywhere in the import graph. It is used for @@ -221,6 +222,7 @@ func NewChecker(conf *Config, pkg *Package, info *Info) *Checker { version: version, objMap: make(map[Object]*declInfo), impMap: make(map[importKey]*Package), + infoMap: make(map[*Named]typeInfo), } } diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index 22cea584d4..ab2983c80f 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -477,7 +477,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named var rhs Type check.later(func() { - check.validType(obj.typ, nil) + check.validType(obj.typ) // If typ is local, an error was already reported where typ is specified/defined. if check.isImportedConstraint(rhs) && !check.allowVersion(check.pkg, 1, 18) { check.versionErrorf(tdecl.Type, "go1.18", "using type constraint %s", rhs) diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go index c4217fa508..834a25066b 100644 --- a/src/cmd/compile/internal/types2/named.go +++ b/src/cmd/compile/internal/types2/named.go @@ -12,7 +12,6 @@ import ( // A Named represents a named (defined) type. type Named struct { check *Checker - info typeInfo // for cycle detection obj *TypeName // corresponding declared object for declared types; placeholder for instantiated types orig *Named // original, uninstantiated type fromRHS Type // type (on RHS of declaration) this *Named type is derived from (for cycle reporting) diff --git a/src/cmd/compile/internal/types2/sizeof_test.go b/src/cmd/compile/internal/types2/sizeof_test.go index 8db2d60e80..52a1df1aa4 100644 --- a/src/cmd/compile/internal/types2/sizeof_test.go +++ b/src/cmd/compile/internal/types2/sizeof_test.go @@ -31,7 +31,7 @@ func TestSizeof(t *testing.T) { {Interface{}, 44, 88}, {Map{}, 16, 32}, {Chan{}, 12, 24}, - {Named{}, 68, 128}, + {Named{}, 64, 120}, {TypeParam{}, 28, 48}, {term{}, 12, 24}, diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go index 9121c2c1f6..580b53d3c7 100644 --- a/src/cmd/compile/internal/types2/typexpr.go +++ b/src/cmd/compile/internal/types2/typexpr.go @@ -487,7 +487,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, xlist []syntax.Expr, def * } } - check.validType(inst, nil) + check.validType(inst) }) return inst diff --git a/src/cmd/compile/internal/types2/validtype.go b/src/cmd/compile/internal/types2/validtype.go index 24d65e2c24..9cb427b44d 100644 --- a/src/cmd/compile/internal/types2/validtype.go +++ b/src/cmd/compile/internal/types2/validtype.go @@ -4,14 +4,18 @@ package types2 -type typeInfo uint - -// validType verifies that the given type does not "expand" infinitely +// validType verifies that the given type does not "expand" indefinitely // producing a cycle in the type graph. Cycles are detected by marking // defined types. // (Cycles involving alias types, as in "type A = [10]A" are detected // earlier, via the objDecl cycle detection mechanism.) -func (check *Checker) validType(typ Type, path []Object) typeInfo { +func (check *Checker) validType(typ Type) { + check.validType0(typ, nil) +} + +type typeInfo uint + +func (check *Checker) validType0(typ Type, path []Object) typeInfo { const ( unknown typeInfo = iota marked @@ -21,25 +25,25 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo { switch t := typ.(type) { case *Array: - return check.validType(t.elem, path) + return check.validType0(t.elem, path) case *Struct: for _, f := range t.fields { - if check.validType(f.typ, path) == invalid { + if check.validType0(f.typ, path) == invalid { return invalid } } case *Union: for _, t := range t.terms { - if check.validType(t.typ, path) == invalid { + if check.validType0(t.typ, path) == invalid { return invalid } } case *Interface: for _, etyp := range t.embeddeds { - if check.validType(etyp, path) == invalid { + if check.validType0(etyp, path) == invalid { return invalid } } @@ -65,14 +69,14 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo { // don't report a 2nd error if we already know the type is invalid // (e.g., if a cycle was detected earlier, via under). if t.underlying == Typ[Invalid] { - t.info = invalid + check.infoMap[t] = invalid return invalid } - switch t.info { + switch check.infoMap[t] { case unknown: - t.info = marked - t.info = check.validType(t.fromRHS, append(path, t.obj)) // only types of current package added to path + check.infoMap[t] = marked + check.infoMap[t] = check.validType0(t.fromRHS, append(path, t.obj)) // only types of current package added to path case marked: // cycle detected for i, tn := range path { @@ -81,14 +85,14 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo { } if tn == t.obj { check.cycleError(path[i:]) - t.info = invalid + check.infoMap[t] = invalid t.underlying = Typ[Invalid] return invalid } } panic("cycle start not found") } - return t.info + return check.infoMap[t] } return valid diff --git a/src/go/types/check.go b/src/go/types/check.go index bad4d5c9cd..90b46b8075 100644 --- a/src/go/types/check.go +++ b/src/go/types/check.go @@ -118,6 +118,7 @@ type Checker struct { nextID uint64 // unique Id for type parameters (first valid Id is 1) 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 + infoMap map[*Named]typeInfo // maps named types to their associated type info (for cycle detection) // pkgPathMap maps package names to the set of distinct import paths we've // seen for that name, anywhere in the import graph. It is used for @@ -229,6 +230,7 @@ func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Ch version: version, objMap: make(map[Object]*declInfo), impMap: make(map[importKey]*Package), + infoMap: make(map[*Named]typeInfo), } } diff --git a/src/go/types/decl.go b/src/go/types/decl.go index 5b54465f18..a9e89464f6 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -530,7 +530,7 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) { var rhs Type check.later(func() { - check.validType(obj.typ, nil) + check.validType(obj.typ) // If typ is local, an error was already reported where typ is specified/defined. if check.isImportedConstraint(rhs) && !check.allowVersion(check.pkg, 1, 18) { check.errorf(tdecl.Type, _UnsupportedFeature, "using type constraint %s requires go1.18 or later", rhs) diff --git a/src/go/types/named.go b/src/go/types/named.go index a44686bc36..6c77146485 100644 --- a/src/go/types/named.go +++ b/src/go/types/named.go @@ -12,7 +12,6 @@ import ( // A Named represents a named (defined) type. type Named struct { check *Checker - info typeInfo // for cycle detection obj *TypeName // corresponding declared object for declared types; placeholder for instantiated types orig *Named // original, uninstantiated type fromRHS Type // type (on RHS of declaration) this *Named type is derived of (for cycle reporting) diff --git a/src/go/types/sizeof_test.go b/src/go/types/sizeof_test.go index 24cbc22839..b78099d0d0 100644 --- a/src/go/types/sizeof_test.go +++ b/src/go/types/sizeof_test.go @@ -30,7 +30,7 @@ func TestSizeof(t *testing.T) { {Interface{}, 44, 88}, {Map{}, 16, 32}, {Chan{}, 12, 24}, - {Named{}, 68, 128}, + {Named{}, 64, 120}, {TypeParam{}, 28, 48}, {term{}, 12, 24}, diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go index b961f7c47f..82de90b67a 100644 --- a/src/go/types/typexpr.go +++ b/src/go/types/typexpr.go @@ -472,7 +472,7 @@ func (check *Checker) instantiatedType(ix *typeparams.IndexExpr, def *Named) (re } } - check.validType(inst, nil) + check.validType(inst) }) return inst diff --git a/src/go/types/validtype.go b/src/go/types/validtype.go index 8972a7ad85..d20a2b5bfa 100644 --- a/src/go/types/validtype.go +++ b/src/go/types/validtype.go @@ -4,14 +4,18 @@ package types -type typeInfo uint - -// validType verifies that the given type does not "expand" infinitely +// validType verifies that the given type does not "expand" indefinitely // producing a cycle in the type graph. Cycles are detected by marking // defined types. // (Cycles involving alias types, as in "type A = [10]A" are detected // earlier, via the objDecl cycle detection mechanism.) -func (check *Checker) validType(typ Type, path []Object) typeInfo { +func (check *Checker) validType(typ Type) { + check.validType0(typ, nil) +} + +type typeInfo uint + +func (check *Checker) validType0(typ Type, path []Object) typeInfo { const ( unknown typeInfo = iota marked @@ -21,25 +25,25 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo { switch t := typ.(type) { case *Array: - return check.validType(t.elem, path) + return check.validType0(t.elem, path) case *Struct: for _, f := range t.fields { - if check.validType(f.typ, path) == invalid { + if check.validType0(f.typ, path) == invalid { return invalid } } case *Union: for _, t := range t.terms { - if check.validType(t.typ, path) == invalid { + if check.validType0(t.typ, path) == invalid { return invalid } } case *Interface: for _, etyp := range t.embeddeds { - if check.validType(etyp, path) == invalid { + if check.validType0(etyp, path) == invalid { return invalid } } @@ -65,14 +69,14 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo { // don't report a 2nd error if we already know the type is invalid // (e.g., if a cycle was detected earlier, via under). if t.underlying == Typ[Invalid] { - t.info = invalid + check.infoMap[t] = invalid return invalid } - switch t.info { + switch check.infoMap[t] { case unknown: - t.info = marked - t.info = check.validType(t.fromRHS, append(path, t.obj)) // only types of current package added to path + check.infoMap[t] = marked + check.infoMap[t] = check.validType0(t.fromRHS, append(path, t.obj)) // only types of current package added to path case marked: // cycle detected for i, tn := range path { @@ -81,14 +85,14 @@ func (check *Checker) validType(typ Type, path []Object) typeInfo { } if tn == t.obj { check.cycleError(path[i:]) - t.info = invalid + check.infoMap[t] = invalid t.underlying = Typ[Invalid] return invalid } } panic("cycle start not found") } - return t.info + return check.infoMap[t] } return valid From cdd9e939ef28390ecb04c780499f1e3cc2195234 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 18 Jan 2022 22:30:03 -0800 Subject: [PATCH 687/752] go/types, types2: validType argument must be *Named type Now that we have a separate top-level entry point for validType we can use the more narrow type *Named (instead of Type) for its argument. Preparation for fixing issue #48962. Change-Id: I93aee4abc87036c6a68323dc970efe8e617a9103 Reviewed-on: https://go-review.googlesource.com/c/go/+/379434 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/decl.go | 4 +++- src/cmd/compile/internal/types2/validtype.go | 2 +- src/go/types/decl.go | 4 +++- src/go/types/validtype.go | 2 +- 4 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index ab2983c80f..41093cb637 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -477,7 +477,9 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named var rhs Type check.later(func() { - check.validType(obj.typ) + if t, _ := obj.typ.(*Named); t != nil { // type may be invalid + check.validType(t) + } // If typ is local, an error was already reported where typ is specified/defined. if check.isImportedConstraint(rhs) && !check.allowVersion(check.pkg, 1, 18) { check.versionErrorf(tdecl.Type, "go1.18", "using type constraint %s", rhs) diff --git a/src/cmd/compile/internal/types2/validtype.go b/src/cmd/compile/internal/types2/validtype.go index 9cb427b44d..c7f7c13169 100644 --- a/src/cmd/compile/internal/types2/validtype.go +++ b/src/cmd/compile/internal/types2/validtype.go @@ -9,7 +9,7 @@ package types2 // defined types. // (Cycles involving alias types, as in "type A = [10]A" are detected // earlier, via the objDecl cycle detection mechanism.) -func (check *Checker) validType(typ Type) { +func (check *Checker) validType(typ *Named) { check.validType0(typ, nil) } diff --git a/src/go/types/decl.go b/src/go/types/decl.go index a9e89464f6..043f02491d 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -530,7 +530,9 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) { var rhs Type check.later(func() { - check.validType(obj.typ) + if t, _ := obj.typ.(*Named); t != nil { // type may be invalid + check.validType(t) + } // If typ is local, an error was already reported where typ is specified/defined. if check.isImportedConstraint(rhs) && !check.allowVersion(check.pkg, 1, 18) { check.errorf(tdecl.Type, _UnsupportedFeature, "using type constraint %s requires go1.18 or later", rhs) diff --git a/src/go/types/validtype.go b/src/go/types/validtype.go index d20a2b5bfa..c0e6ee34f6 100644 --- a/src/go/types/validtype.go +++ b/src/go/types/validtype.go @@ -9,7 +9,7 @@ package types // defined types. // (Cycles involving alias types, as in "type A = [10]A" are detected // earlier, via the objDecl cycle detection mechanism.) -func (check *Checker) validType(typ Type) { +func (check *Checker) validType(typ *Named) { check.validType0(typ, nil) } From 9dfd458e64a2d3fa92fb7b5da393163151f99cf2 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 14 Jan 2022 17:34:59 -0800 Subject: [PATCH 688/752] go/types, types2: remove special case for external types in validType Because validType doesn't modify global state anymore, there's no need to ignore imported types. When we start tracking type parameters, we need to include imported types because they may contribute to cycles that invalidate a type. This CL effectively reverts CL 202483 (issue #35049, which doesn't apply anymore because we don't change the state of imported objects). Preparation for fixing issue #48962. For #35049. For #48962. Change-Id: I06f15575ad197375c74ffd09c222250610186b15 Reviewed-on: https://go-review.googlesource.com/c/go/+/378675 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/validtype.go | 18 ++++++++++-------- src/go/types/validtype.go | 18 ++++++++++-------- 2 files changed, 20 insertions(+), 16 deletions(-) diff --git a/src/cmd/compile/internal/types2/validtype.go b/src/cmd/compile/internal/types2/validtype.go index c7f7c13169..101a8b3945 100644 --- a/src/cmd/compile/internal/types2/validtype.go +++ b/src/cmd/compile/internal/types2/validtype.go @@ -60,12 +60,6 @@ func (check *Checker) validType0(typ Type, path []Object) typeInfo { // will terminate. t = t.orig - // don't touch the type if it is from a different package or the Universe scope - // (doing so would lead to a race condition - was issue #35049) - if t.obj.pkg != check.pkg { - return valid - } - // don't report a 2nd error if we already know the type is invalid // (e.g., if a cycle was detected earlier, via under). if t.underlying == Typ[Invalid] { @@ -76,17 +70,25 @@ func (check *Checker) validType0(typ Type, path []Object) typeInfo { switch check.infoMap[t] { case unknown: check.infoMap[t] = marked - check.infoMap[t] = check.validType0(t.fromRHS, append(path, t.obj)) // only types of current package added to path + check.infoMap[t] = check.validType0(t.fromRHS, append(path, t.obj)) case marked: // cycle detected for i, tn := range path { + // Even though validType now can hande cycles through external + // types, we can't have cycles through external types because + // no such types are detected yet. + // TODO(gri) Remove this check once we can detect such cycles, + // and adjust cycleError accordingly. if t.obj.pkg != check.pkg { panic("type cycle via package-external type") } if tn == t.obj { check.cycleError(path[i:]) check.infoMap[t] = invalid - t.underlying = Typ[Invalid] + // don't modify imported types (leads to race condition, see #35049) + if t.obj.pkg == check.pkg { + t.underlying = Typ[Invalid] + } return invalid } } diff --git a/src/go/types/validtype.go b/src/go/types/validtype.go index c0e6ee34f6..865dc9528f 100644 --- a/src/go/types/validtype.go +++ b/src/go/types/validtype.go @@ -60,12 +60,6 @@ func (check *Checker) validType0(typ Type, path []Object) typeInfo { // will terminate. t = t.orig - // don't touch the type if it is from a different package or the Universe scope - // (doing so would lead to a race condition - was issue #35049) - if t.obj.pkg != check.pkg { - return valid - } - // don't report a 2nd error if we already know the type is invalid // (e.g., if a cycle was detected earlier, via under). if t.underlying == Typ[Invalid] { @@ -76,17 +70,25 @@ func (check *Checker) validType0(typ Type, path []Object) typeInfo { switch check.infoMap[t] { case unknown: check.infoMap[t] = marked - check.infoMap[t] = check.validType0(t.fromRHS, append(path, t.obj)) // only types of current package added to path + check.infoMap[t] = check.validType0(t.fromRHS, append(path, t.obj)) case marked: // cycle detected for i, tn := range path { + // Even though validType now can hande cycles through external + // types, we can't have cycles through external types because + // no such types are detected yet. + // TODO(gri) Remove this check once we can detect such cycles, + // and adjust cycleError accordingly. if t.obj.pkg != check.pkg { panic("type cycle via package-external type") } if tn == t.obj { check.cycleError(path[i:]) check.infoMap[t] = invalid - t.underlying = Typ[Invalid] + // don't modify imported types (leads to race condition, see #35049) + if t.obj.pkg == check.pkg { + t.underlying = Typ[Invalid] + } return invalid } } From 7520c080b45e9493b289d622aed8d8a0da528089 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 19 Jan 2022 18:10:40 -0800 Subject: [PATCH 689/752] go/types, types2: in SetUnderlying, set Named.fromRHS if not set yet This is necessary for cycle detection over imported types whose underlying types are set by importers with SetUnderlying. Preparation for fixing issue #48962. Change-Id: I3218cda7feb06440fdb8345c94bcaa5f7d64e94e Reviewed-on: https://go-review.googlesource.com/c/go/+/379694 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/named.go | 3 +++ src/go/types/named.go | 3 +++ 2 files changed, 6 insertions(+) diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go index 834a25066b..3ba53052d7 100644 --- a/src/cmd/compile/internal/types2/named.go +++ b/src/cmd/compile/internal/types2/named.go @@ -113,6 +113,9 @@ func (t *Named) SetUnderlying(underlying Type) { panic("underlying type must not be *Named") } t.resolve(nil).underlying = underlying + if t.fromRHS == nil { + t.fromRHS = underlying // for cycle detection + } } // AddMethod adds method m unless it is already in the method list. diff --git a/src/go/types/named.go b/src/go/types/named.go index 6c77146485..f0c22d29e3 100644 --- a/src/go/types/named.go +++ b/src/go/types/named.go @@ -115,6 +115,9 @@ func (t *Named) SetUnderlying(underlying Type) { panic("underlying type must not be *Named") } t.resolve(nil).underlying = underlying + if t.fromRHS == nil { + t.fromRHS = underlying // for cycle detection + } } // AddMethod adds method m unless it is already in the method list. From 2abfa30f9e0041e932411816ba07d68060eec304 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 14 Jan 2022 17:42:20 -0800 Subject: [PATCH 690/752] go/types, types2: consider type parameters for cycle detection In validType, when we see an instantiated type, proceed as with non-generic types but provide an environment in which to look up the values (the corresponding type arguments) of type parameters of the instantiated type. For each type parameter for which there is a type argument, proceed with validating that type argument. This corresponds to applying validType to the instantiated type without actually instantiating the type (and running into infinite instantiations in case of invalid recursive types). Also, when creating a type instance, use the correct source position for the instance (the start of the qualified identifier if we have an imported type). Fixes #48962. Change-Id: I196c78bf066e4a56284d53368b2eb71bd8d8a780 Reviewed-on: https://go-review.googlesource.com/c/go/+/379414 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley --- .../internal/types2/testdata/check/issues.go2 | 4 +- .../types2/testdata/check/typeinst.go2 | 2 +- .../types2/testdata/fixedbugs/issue39634.go2 | 2 +- .../types2/testdata/fixedbugs/issue39938.go2 | 34 +++--- .../types2/testdata/fixedbugs/issue48951.go2 | 12 +- .../types2/testdata/fixedbugs/issue48962.go2 | 13 ++ .../types2/testdata/fixedbugs/issue49043.go2 | 6 +- src/cmd/compile/internal/types2/typexpr.go | 3 +- src/cmd/compile/internal/types2/validtype.go | 112 ++++++++++++------ src/go/types/testdata/check/issues.go2 | 4 +- src/go/types/testdata/check/typeinst.go2 | 2 +- .../types/testdata/fixedbugs/issue39634.go2 | 2 +- .../types/testdata/fixedbugs/issue39938.go2 | 34 +++--- .../types/testdata/fixedbugs/issue48951.go2 | 12 +- .../types/testdata/fixedbugs/issue48962.go2 | 13 ++ .../types/testdata/fixedbugs/issue49043.go2 | 6 +- src/go/types/typexpr.go | 3 +- src/go/types/validtype.go | 112 ++++++++++++------ test/typeparam/issue48962.dir/a.go | 12 ++ test/typeparam/issue48962.dir/b.go | 51 ++++++++ test/typeparam/issue48962.go | 14 +-- 21 files changed, 316 insertions(+), 137 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue48962.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue48962.go2 create mode 100644 test/typeparam/issue48962.dir/a.go create mode 100644 test/typeparam/issue48962.dir/b.go diff --git a/src/cmd/compile/internal/types2/testdata/check/issues.go2 b/src/cmd/compile/internal/types2/testdata/check/issues.go2 index 5b6eebd4fd..0b80939653 100644 --- a/src/cmd/compile/internal/types2/testdata/check/issues.go2 +++ b/src/cmd/compile/internal/types2/testdata/check/issues.go2 @@ -145,8 +145,8 @@ type List3[TElem any] struct { } // Infinite generic type declarations must lead to an error. -type inf1 /* ERROR illegal cycle */ [T any] struct{ _ inf1[T] } -type inf2 /* ERROR illegal cycle */ [T any] struct{ inf2[T] } +type inf1[T any] struct{ _ inf1 /* ERROR illegal cycle */ [T] } +type inf2[T any] struct{ inf2 /* ERROR illegal cycle */ [T] } // The implementation of conversions T(x) between integers and floating-point // numbers checks that both T and x have either integer or floating-point diff --git a/src/cmd/compile/internal/types2/testdata/check/typeinst.go2 b/src/cmd/compile/internal/types2/testdata/check/typeinst.go2 index a3d1b5e28f..0e6dc0a98f 100644 --- a/src/cmd/compile/internal/types2/testdata/check/typeinst.go2 +++ b/src/cmd/compile/internal/types2/testdata/check/typeinst.go2 @@ -58,5 +58,5 @@ var _ T3[int] = T3[int](List[int]{1, 2, 3}) // Self-recursive generic types are not permitted -type self1 /* ERROR illegal cycle */ [P any] self1[P] +type self1[P any] self1 /* ERROR illegal cycle */ [P] type self2[P any] *self2[P] // this is ok diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39634.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39634.go2 index c56f23918d..b408dd7003 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39634.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39634.go2 @@ -37,7 +37,7 @@ func main7() { var _ foo7 = x7[int]{} } // func main8() {} // crash 9 -type foo9 /* ERROR illegal cycle */ [A any] interface { foo9[A] } +type foo9[A any] interface { foo9 /* ERROR illegal cycle */ [A] } func _() { var _ = new(foo9[int]) } // crash 12 diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39938.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39938.go2 index 114646786d..6bc9284849 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39938.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue39938.go2 @@ -2,22 +2,20 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// Check "infinite expansion" cycle errors across instantiated types. -// We can't detect these errors anymore at the moment. See #48962 for -// details. - package p +// All but E2 and E5 provide an "indirection" and break infinite expansion of a type. type E0[P any] []P type E1[P any] *P type E2[P any] struct{ _ P } type E3[P any] struct{ _ *P } +type E5[P any] struct{ _ [10]P } -type T0 /* illegal cycle */ struct { +type T0 struct { _ E0[T0] } -type T0_ /* illegal cycle */ struct { +type T0_ struct { E0[T0_] } @@ -25,7 +23,7 @@ type T1 struct { _ E1[T1] } -type T2 /* illegal cycle */ struct { +type T2 /* ERROR illegal cycle */ struct { _ E2[T2] } @@ -33,20 +31,24 @@ type T3 struct { _ E3[T3] } -// some more complex cases - -type T4 /* illegal cycle */ struct { - _ E0[E2[T4]] -} +type T4 /* ERROR illegal cycle */ [10]E5[T4] type T5 struct { - _ E0[E2[E0[E1[E2[[10]T5]]]]] + _ E0[E2[T5]] } -type T6 /* illegal cycle */ struct { - _ E0[[10]E2[E0[E2[E2[T6]]]]] +type T6 struct { + _ E0[E2[E0[E1[E2[[10]T6]]]]] } type T7 struct { - _ E0[[]E2[E0[E2[E2[T6]]]]] + _ E0[[10]E2[E0[E2[E2[T7]]]]] } + +type T8 struct { + _ E0[[]E2[E0[E2[E2[T8]]]]] +} + +type T9 /* ERROR illegal cycle */ [10]E2[E5[E2[T9]]] + +type T10 [10]E2[E5[E2[func(T10)]]] diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48951.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48951.go2 index cf02cc130a..a9365281ee 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48951.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48951.go2 @@ -5,17 +5,17 @@ package p type ( - A1 /* ERROR illegal cycle */ [P any] [10]A1[P] - A2 /* ERROR illegal cycle */ [P any] [10]A2[*P] + A1[P any] [10]A1 /* ERROR illegal cycle */ [P] + A2[P any] [10]A2 /* ERROR illegal cycle */ [*P] A3[P any] [10]*A3[P] L1[P any] []L1[P] - S1 /* ERROR illegal cycle */ [P any] struct{ f S1[P] } - S2 /* ERROR illegal cycle */ [P any] struct{ f S2[*P] } // like example in issue + S1[P any] struct{ f S1 /* ERROR illegal cycle */ [P] } + S2[P any] struct{ f S2 /* ERROR illegal cycle */ [*P] } // like example in issue S3[P any] struct{ f *S3[P] } - I1 /* ERROR illegal cycle */ [P any] interface{ I1[P] } - I2 /* ERROR illegal cycle */ [P any] interface{ I2[*P] } + I1[P any] interface{ I1 /* ERROR illegal cycle */ [P] } + I2[P any] interface{ I2 /* ERROR illegal cycle */ [*P] } I3[P any] interface{ *I3 /* ERROR interface contains type constraints */ [P] } ) diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48962.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48962.go2 new file mode 100644 index 0000000000..4270da1c73 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue48962.go2 @@ -0,0 +1,13 @@ +// Copyright 2022 The Go 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 T0[P any] struct { + f P +} + +type T1 /* ERROR illegal cycle */ struct { + _ T0[T1] +} diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49043.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49043.go2 index c37b0f1267..a360457d9f 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49043.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue49043.go2 @@ -6,13 +6,13 @@ package p // The example from the issue. type ( - N /* ERROR illegal cycle */ [P any] M[P] - M[P any] N[P] + N[P any] M /* ERROR illegal cycle */ [P] + M[P any] N /* ERROR illegal cycle */ [P] ) // A slightly more complicated case. type ( - A /* ERROR illegal cycle */ [P any] B[P] + A[P any] B /* ERROR illegal cycle */ [P] B[P any] C[P] C[P any] A[P] ) diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go index 580b53d3c7..0c7bd62643 100644 --- a/src/cmd/compile/internal/types2/typexpr.go +++ b/src/cmd/compile/internal/types2/typexpr.go @@ -440,7 +440,8 @@ func (check *Checker) instantiatedType(x syntax.Expr, xlist []syntax.Expr, def * // validation below. Ensure that the validation (and resulting errors) runs // for each instantiated type in the source. if inst == nil { - tname := NewTypeName(x.Pos(), orig.obj.pkg, orig.obj.name, nil) + // x may be a selector for an imported type; use its start pos rather than x.Pos(). + tname := NewTypeName(syntax.StartPos(x), orig.obj.pkg, orig.obj.name, nil) inst = check.newNamed(tname, orig, nil, nil, nil) // underlying, methods and tparams are set when named is resolved inst.targs = newTypeList(targs) inst = ctxt.update(h, orig, targs, inst).(*Named) diff --git a/src/cmd/compile/internal/types2/validtype.go b/src/cmd/compile/internal/types2/validtype.go index 101a8b3945..c508eadc7c 100644 --- a/src/cmd/compile/internal/types2/validtype.go +++ b/src/cmd/compile/internal/types2/validtype.go @@ -10,12 +10,17 @@ package types2 // (Cycles involving alias types, as in "type A = [10]A" are detected // earlier, via the objDecl cycle detection mechanism.) func (check *Checker) validType(typ *Named) { - check.validType0(typ, nil) + check.validType0(typ, nil, nil) } type typeInfo uint -func (check *Checker) validType0(typ Type, path []Object) typeInfo { +// validType0 checks if the given type is valid. If typ is a type parameter +// its value is looked up in the provided environment. The environment is +// nil if typ is not part of (the RHS of) an instantiated type, in that case +// any type parameter encountered must be from an enclosing function and can +// be ignored. The path is the list of type names that lead to the current typ. +func (check *Checker) validType0(typ Type, env *tparamEnv, path []Object) typeInfo { const ( unknown typeInfo = iota marked @@ -24,43 +29,39 @@ func (check *Checker) validType0(typ Type, path []Object) typeInfo { ) switch t := typ.(type) { + case nil: + // We should never see a nil type but be conservative and panic + // only in debug mode. + if debug { + panic("validType0(nil)") + } + case *Array: - return check.validType0(t.elem, path) + return check.validType0(t.elem, env, path) case *Struct: for _, f := range t.fields { - if check.validType0(f.typ, path) == invalid { + if check.validType0(f.typ, env, path) == invalid { return invalid } } case *Union: for _, t := range t.terms { - if check.validType0(t.typ, path) == invalid { + if check.validType0(t.typ, env, path) == invalid { return invalid } } case *Interface: for _, etyp := range t.embeddeds { - if check.validType0(etyp, path) == invalid { + if check.validType0(etyp, env, path) == invalid { return invalid } } case *Named: - // If t is parameterized, we should be considering the instantiated (expanded) - // form of t, but in general we can't with this algorithm: if t is an invalid - // type it may be so because it infinitely expands through a type parameter. - // Instantiating such a type would lead to an infinite sequence of instantiations. - // In general, we need "type flow analysis" to recognize those cases. - // Example: type A[T any] struct{ x A[*T] } (issue #48951) - // In this algorithm we always only consider the original, uninstantiated type. - // This won't recognize some invalid cases with parameterized types, but it - // will terminate. - t = t.orig - - // don't report a 2nd error if we already know the type is invalid + // Don't report a 2nd error if we already know the type is invalid // (e.g., if a cycle was detected earlier, via under). if t.underlying == Typ[Invalid] { check.infoMap[t] = invalid @@ -70,32 +71,77 @@ func (check *Checker) validType0(typ Type, path []Object) typeInfo { switch check.infoMap[t] { case unknown: check.infoMap[t] = marked - check.infoMap[t] = check.validType0(t.fromRHS, append(path, t.obj)) + check.infoMap[t] = check.validType0(t.orig.fromRHS, env.push(t), append(path, t.obj)) case marked: - // cycle detected + // We have seen type t before and thus must have a cycle. + check.infoMap[t] = invalid + // t cannot be in an imported package otherwise that package + // would have reported a type cycle and couldn't have been + // imported in the first place. + assert(t.obj.pkg == check.pkg) + t.underlying = Typ[Invalid] // t is in the current package (no race possibilty) + // Find the starting point of the cycle and report it. for i, tn := range path { - // Even though validType now can hande cycles through external - // types, we can't have cycles through external types because - // no such types are detected yet. - // TODO(gri) Remove this check once we can detect such cycles, - // and adjust cycleError accordingly. - if t.obj.pkg != check.pkg { - panic("type cycle via package-external type") - } if tn == t.obj { check.cycleError(path[i:]) - check.infoMap[t] = invalid - // don't modify imported types (leads to race condition, see #35049) - if t.obj.pkg == check.pkg { - t.underlying = Typ[Invalid] - } return invalid } } panic("cycle start not found") } return check.infoMap[t] + + case *TypeParam: + // A type parameter stands for the type (argument) it was instantiated with. + // Check the corresponding type argument for validity if we have one. + if env != nil { + if targ := env.tmap[t]; targ != nil { + // Type arguments found in targ must be looked + // up in the enclosing environment env.link. + return check.validType0(targ, env.link, path) + } + } } return valid } + +// A tparamEnv provides the environment for looking up the type arguments +// with which type parameters for a given instance were instantiated. +// If we don't have an instance, the corresponding tparamEnv is nil. +type tparamEnv struct { + tmap substMap + link *tparamEnv +} + +func (env *tparamEnv) push(typ *Named) *tparamEnv { + // If typ is not an instantiated type there are no typ-specific + // type parameters to look up and we don't need an environment. + targs := typ.TypeArgs() + if targs == nil { + return nil // no instance => nil environment + } + + // Populate tmap: remember the type argument for each type parameter. + // We cannot use makeSubstMap because the number of type parameters + // and arguments may not match due to errors in the source (too many + // or too few type arguments). Populate tmap "manually". + tparams := typ.TypeParams() + n, m := targs.Len(), tparams.Len() + if n > m { + n = m // too many targs + } + tmap := make(substMap, n) + for i := 0; i < n; i++ { + tmap[tparams.At(i)] = targs.At(i) + } + + return &tparamEnv{tmap: tmap, link: env} +} + +// TODO(gri) Alternative implementation: +// We may not need to build a stack of environments to +// look up the type arguments for type parameters. The +// same information should be available via the path: +// We should be able to just walk the path backwards +// and find the type arguments in the instance objects. diff --git a/src/go/types/testdata/check/issues.go2 b/src/go/types/testdata/check/issues.go2 index cec1ccb0cc..a11bcaac4b 100644 --- a/src/go/types/testdata/check/issues.go2 +++ b/src/go/types/testdata/check/issues.go2 @@ -145,8 +145,8 @@ type List3[TElem any] struct { } // Infinite generic type declarations must lead to an error. -type inf1 /* ERROR illegal cycle */ [T any] struct{ _ inf1[T] } -type inf2 /* ERROR illegal cycle */ [T any] struct{ inf2[T] } +type inf1[T any] struct{ _ inf1 /* ERROR illegal cycle */ [T] } +type inf2[T any] struct{ inf2 /* ERROR illegal cycle */ [T] } // The implementation of conversions T(x) between integers and floating-point // numbers checks that both T and x have either integer or floating-point diff --git a/src/go/types/testdata/check/typeinst.go2 b/src/go/types/testdata/check/typeinst.go2 index 65481202e4..6423cb801f 100644 --- a/src/go/types/testdata/check/typeinst.go2 +++ b/src/go/types/testdata/check/typeinst.go2 @@ -58,5 +58,5 @@ var _ T3[int] = T3[int](List[int]{1, 2, 3}) // Self-recursive generic types are not permitted -type self1 /* ERROR illegal cycle */ [P any] self1[P] +type self1[P any] self1 /* ERROR illegal cycle */ [P] type self2[P any] *self2[P] // this is ok diff --git a/src/go/types/testdata/fixedbugs/issue39634.go2 b/src/go/types/testdata/fixedbugs/issue39634.go2 index 2de2f4378a..34ab654f1c 100644 --- a/src/go/types/testdata/fixedbugs/issue39634.go2 +++ b/src/go/types/testdata/fixedbugs/issue39634.go2 @@ -37,7 +37,7 @@ func main7() { var _ foo7 = x7[int]{} } // func main8() {} // crash 9 -type foo9 /* ERROR illegal cycle */ [A any] interface { foo9[A] } +type foo9[A any] interface { foo9 /* ERROR illegal cycle */ [A] } func _() { var _ = new(foo9[int]) } // crash 12 diff --git a/src/go/types/testdata/fixedbugs/issue39938.go2 b/src/go/types/testdata/fixedbugs/issue39938.go2 index 114646786d..6bc9284849 100644 --- a/src/go/types/testdata/fixedbugs/issue39938.go2 +++ b/src/go/types/testdata/fixedbugs/issue39938.go2 @@ -2,22 +2,20 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// Check "infinite expansion" cycle errors across instantiated types. -// We can't detect these errors anymore at the moment. See #48962 for -// details. - package p +// All but E2 and E5 provide an "indirection" and break infinite expansion of a type. type E0[P any] []P type E1[P any] *P type E2[P any] struct{ _ P } type E3[P any] struct{ _ *P } +type E5[P any] struct{ _ [10]P } -type T0 /* illegal cycle */ struct { +type T0 struct { _ E0[T0] } -type T0_ /* illegal cycle */ struct { +type T0_ struct { E0[T0_] } @@ -25,7 +23,7 @@ type T1 struct { _ E1[T1] } -type T2 /* illegal cycle */ struct { +type T2 /* ERROR illegal cycle */ struct { _ E2[T2] } @@ -33,20 +31,24 @@ type T3 struct { _ E3[T3] } -// some more complex cases - -type T4 /* illegal cycle */ struct { - _ E0[E2[T4]] -} +type T4 /* ERROR illegal cycle */ [10]E5[T4] type T5 struct { - _ E0[E2[E0[E1[E2[[10]T5]]]]] + _ E0[E2[T5]] } -type T6 /* illegal cycle */ struct { - _ E0[[10]E2[E0[E2[E2[T6]]]]] +type T6 struct { + _ E0[E2[E0[E1[E2[[10]T6]]]]] } type T7 struct { - _ E0[[]E2[E0[E2[E2[T6]]]]] + _ E0[[10]E2[E0[E2[E2[T7]]]]] } + +type T8 struct { + _ E0[[]E2[E0[E2[E2[T8]]]]] +} + +type T9 /* ERROR illegal cycle */ [10]E2[E5[E2[T9]]] + +type T10 [10]E2[E5[E2[func(T10)]]] diff --git a/src/go/types/testdata/fixedbugs/issue48951.go2 b/src/go/types/testdata/fixedbugs/issue48951.go2 index cf02cc130a..a9365281ee 100644 --- a/src/go/types/testdata/fixedbugs/issue48951.go2 +++ b/src/go/types/testdata/fixedbugs/issue48951.go2 @@ -5,17 +5,17 @@ package p type ( - A1 /* ERROR illegal cycle */ [P any] [10]A1[P] - A2 /* ERROR illegal cycle */ [P any] [10]A2[*P] + A1[P any] [10]A1 /* ERROR illegal cycle */ [P] + A2[P any] [10]A2 /* ERROR illegal cycle */ [*P] A3[P any] [10]*A3[P] L1[P any] []L1[P] - S1 /* ERROR illegal cycle */ [P any] struct{ f S1[P] } - S2 /* ERROR illegal cycle */ [P any] struct{ f S2[*P] } // like example in issue + S1[P any] struct{ f S1 /* ERROR illegal cycle */ [P] } + S2[P any] struct{ f S2 /* ERROR illegal cycle */ [*P] } // like example in issue S3[P any] struct{ f *S3[P] } - I1 /* ERROR illegal cycle */ [P any] interface{ I1[P] } - I2 /* ERROR illegal cycle */ [P any] interface{ I2[*P] } + I1[P any] interface{ I1 /* ERROR illegal cycle */ [P] } + I2[P any] interface{ I2 /* ERROR illegal cycle */ [*P] } I3[P any] interface{ *I3 /* ERROR interface contains type constraints */ [P] } ) diff --git a/src/go/types/testdata/fixedbugs/issue48962.go2 b/src/go/types/testdata/fixedbugs/issue48962.go2 new file mode 100644 index 0000000000..4270da1c73 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue48962.go2 @@ -0,0 +1,13 @@ +// Copyright 2022 The Go 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 T0[P any] struct { + f P +} + +type T1 /* ERROR illegal cycle */ struct { + _ T0[T1] +} diff --git a/src/go/types/testdata/fixedbugs/issue49043.go2 b/src/go/types/testdata/fixedbugs/issue49043.go2 index c37b0f1267..a360457d9f 100644 --- a/src/go/types/testdata/fixedbugs/issue49043.go2 +++ b/src/go/types/testdata/fixedbugs/issue49043.go2 @@ -6,13 +6,13 @@ package p // The example from the issue. type ( - N /* ERROR illegal cycle */ [P any] M[P] - M[P any] N[P] + N[P any] M /* ERROR illegal cycle */ [P] + M[P any] N /* ERROR illegal cycle */ [P] ) // A slightly more complicated case. type ( - A /* ERROR illegal cycle */ [P any] B[P] + A[P any] B /* ERROR illegal cycle */ [P] B[P any] C[P] C[P any] A[P] ) diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go index 82de90b67a..1e629e3fdb 100644 --- a/src/go/types/typexpr.go +++ b/src/go/types/typexpr.go @@ -425,7 +425,8 @@ func (check *Checker) instantiatedType(ix *typeparams.IndexExpr, def *Named) (re // validation below. Ensure that the validation (and resulting errors) runs // for each instantiated type in the source. if inst == nil { - tname := NewTypeName(ix.X.Pos(), orig.obj.pkg, orig.obj.name, nil) + // x may be a selector for an imported type; use its start pos rather than x.Pos(). + tname := NewTypeName(ix.Pos(), orig.obj.pkg, orig.obj.name, nil) inst = check.newNamed(tname, orig, nil, nil, nil) // underlying, methods and tparams are set when named is resolved inst.targs = newTypeList(targs) inst = ctxt.update(h, orig, targs, inst).(*Named) diff --git a/src/go/types/validtype.go b/src/go/types/validtype.go index 865dc9528f..c4ec2f2e0a 100644 --- a/src/go/types/validtype.go +++ b/src/go/types/validtype.go @@ -10,12 +10,17 @@ package types // (Cycles involving alias types, as in "type A = [10]A" are detected // earlier, via the objDecl cycle detection mechanism.) func (check *Checker) validType(typ *Named) { - check.validType0(typ, nil) + check.validType0(typ, nil, nil) } type typeInfo uint -func (check *Checker) validType0(typ Type, path []Object) typeInfo { +// validType0 checks if the given type is valid. If typ is a type parameter +// its value is looked up in the provided environment. The environment is +// nil if typ is not part of (the RHS of) an instantiated type, in that case +// any type parameter encountered must be from an enclosing function and can +// be ignored. The path is the list of type names that lead to the current typ. +func (check *Checker) validType0(typ Type, env *tparamEnv, path []Object) typeInfo { const ( unknown typeInfo = iota marked @@ -24,43 +29,39 @@ func (check *Checker) validType0(typ Type, path []Object) typeInfo { ) switch t := typ.(type) { + case nil: + // We should never see a nil type but be conservative and panic + // only in debug mode. + if debug { + panic("validType0(nil)") + } + case *Array: - return check.validType0(t.elem, path) + return check.validType0(t.elem, env, path) case *Struct: for _, f := range t.fields { - if check.validType0(f.typ, path) == invalid { + if check.validType0(f.typ, env, path) == invalid { return invalid } } case *Union: for _, t := range t.terms { - if check.validType0(t.typ, path) == invalid { + if check.validType0(t.typ, env, path) == invalid { return invalid } } case *Interface: for _, etyp := range t.embeddeds { - if check.validType0(etyp, path) == invalid { + if check.validType0(etyp, env, path) == invalid { return invalid } } case *Named: - // If t is parameterized, we should be considering the instantiated (expanded) - // form of t, but in general we can't with this algorithm: if t is an invalid - // type it may be so because it infinitely expands through a type parameter. - // Instantiating such a type would lead to an infinite sequence of instantiations. - // In general, we need "type flow analysis" to recognize those cases. - // Example: type A[T any] struct{ x A[*T] } (issue #48951) - // In this algorithm we always only consider the original, uninstantiated type. - // This won't recognize some invalid cases with parameterized types, but it - // will terminate. - t = t.orig - - // don't report a 2nd error if we already know the type is invalid + // Don't report a 2nd error if we already know the type is invalid // (e.g., if a cycle was detected earlier, via under). if t.underlying == Typ[Invalid] { check.infoMap[t] = invalid @@ -70,32 +71,77 @@ func (check *Checker) validType0(typ Type, path []Object) typeInfo { switch check.infoMap[t] { case unknown: check.infoMap[t] = marked - check.infoMap[t] = check.validType0(t.fromRHS, append(path, t.obj)) + check.infoMap[t] = check.validType0(t.orig.fromRHS, env.push(t), append(path, t.obj)) case marked: - // cycle detected + // We have seen type t before and thus must have a cycle. + check.infoMap[t] = invalid + // t cannot be in an imported package otherwise that package + // would have reported a type cycle and couldn't have been + // imported in the first place. + assert(t.obj.pkg == check.pkg) + t.underlying = Typ[Invalid] // t is in the current package (no race possibilty) + // Find the starting point of the cycle and report it. for i, tn := range path { - // Even though validType now can hande cycles through external - // types, we can't have cycles through external types because - // no such types are detected yet. - // TODO(gri) Remove this check once we can detect such cycles, - // and adjust cycleError accordingly. - if t.obj.pkg != check.pkg { - panic("type cycle via package-external type") - } if tn == t.obj { check.cycleError(path[i:]) - check.infoMap[t] = invalid - // don't modify imported types (leads to race condition, see #35049) - if t.obj.pkg == check.pkg { - t.underlying = Typ[Invalid] - } return invalid } } panic("cycle start not found") } return check.infoMap[t] + + case *TypeParam: + // A type parameter stands for the type (argument) it was instantiated with. + // Check the corresponding type argument for validity if we have one. + if env != nil { + if targ := env.tmap[t]; targ != nil { + // Type arguments found in targ must be looked + // up in the enclosing environment env.link. + return check.validType0(targ, env.link, path) + } + } } return valid } + +// A tparamEnv provides the environment for looking up the type arguments +// with which type parameters for a given instance were instantiated. +// If we don't have an instance, the corresponding tparamEnv is nil. +type tparamEnv struct { + tmap substMap + link *tparamEnv +} + +func (env *tparamEnv) push(typ *Named) *tparamEnv { + // If typ is not an instantiated type there are no typ-specific + // type parameters to look up and we don't need an environment. + targs := typ.TypeArgs() + if targs == nil { + return nil // no instance => nil environment + } + + // Populate tmap: remember the type argument for each type parameter. + // We cannot use makeSubstMap because the number of type parameters + // and arguments may not match due to errors in the source (too many + // or too few type arguments). Populate tmap "manually". + tparams := typ.TypeParams() + n, m := targs.Len(), tparams.Len() + if n > m { + n = m // too many targs + } + tmap := make(substMap, n) + for i := 0; i < n; i++ { + tmap[tparams.At(i)] = targs.At(i) + } + + return &tparamEnv{tmap: tmap, link: env} +} + +// TODO(gri) Alternative implementation: +// We may not need to build a stack of environments to +// look up the type arguments for type parameters. The +// same information should be available via the path: +// We should be able to just walk the path backwards +// and find the type arguments in the instance objects. diff --git a/test/typeparam/issue48962.dir/a.go b/test/typeparam/issue48962.dir/a.go new file mode 100644 index 0000000000..a6d273476e --- /dev/null +++ b/test/typeparam/issue48962.dir/a.go @@ -0,0 +1,12 @@ +// Copyright 2022 The Go 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 ( + A[P any] [10]P + S[P any] struct{ f P } + P[P any] *P + M[K comparable, V any] map[K]V +) diff --git a/test/typeparam/issue48962.dir/b.go b/test/typeparam/issue48962.dir/b.go new file mode 100644 index 0000000000..a49f55de8d --- /dev/null +++ b/test/typeparam/issue48962.dir/b.go @@ -0,0 +1,51 @@ +// Copyright 2022 The Go 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 ( + lA[P any] [10]P + lS[P any] struct{ f P } + lP[P any] *P + lM[K comparable, V any] map[K]V +) + +// local cycles +type ( + A lA[A] // ERROR "invalid recursive type" + S lS[S] // ERROR "invalid recursive type" + P lP[P] // ok (indirection through lP) + M1 lM[int, M1] // ok (indirection through lM) + M2 lM[lA[byte], M2] // ok (indirection through lM) + + A2 lA[lS[lP[A2]]] // ok (indirection through lP) + A3 lA[lS[lS[A3]]] // ERROR "invalid recursive type" +) + +// cycles through imported types +type ( + Ai a.A[Ai] // ERROR "invalid recursive type" + Si a.S[Si] // ERROR "invalid recursive type" + Pi a.P[Pi] // ok (indirection through a.P) + M1i a.M[int, M1i] // ok (indirection through a.M) + M2i a.M[a.A[byte], M2i] // ok (indirection through a.M) + + A2i a.A[a.S[a.P[A2i]]] // ok (indirection through a.P) + A3i a.A[a.S[a.S[A3i]]] // ERROR "invalid recursive type" + + T2 a.S[T0[T2]] // ERROR "invalid recursive type" + T3 T0[Ai] // no follow-on error here +) + +// test case from issue + +type T0[P any] struct { + f P +} + +type T1 struct { // ERROR "invalid recursive type" + _ T0[T1] +} diff --git a/test/typeparam/issue48962.go b/test/typeparam/issue48962.go index de9a23cdd2..326d67b49a 100644 --- a/test/typeparam/issue48962.go +++ b/test/typeparam/issue48962.go @@ -1,15 +1,7 @@ -// errorcheck -G=3 +// errorcheckdir -G=3 -// Copyright 2021 The Go Authors. All rights reserved. +// Copyright 2022 The Go 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 T0[P any] struct { // ERROR "invalid recursive type" - f P -} - -type T1 struct { - _ T0[T1] -} +package ignored From fef14fdd1dc9106f872e75aae4fcd814abc47080 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 20 Jan 2022 17:23:07 -0800 Subject: [PATCH 691/752] go/types, types2: slightly better tracing output (debugging support) Change-Id: I48804eba94ec455c4764d52af148f4210faf7d94 Reviewed-on: https://go-review.googlesource.com/c/go/+/379836 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/decl.go | 4 +++- src/cmd/compile/internal/types2/typexpr.go | 2 +- src/go/types/decl.go | 4 +++- src/go/types/typexpr.go | 2 +- 4 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index 41093cb637..710ae5f9c8 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -278,7 +278,9 @@ loop: check.trace(obj.Pos(), "## cycle contains: %d values, %d type definitions", nval, ndef) } defer func() { - if !valid { + if valid { + check.trace(obj.Pos(), "=> cycle is valid") + } else { check.trace(obj.Pos(), "=> error: cycle is invalid") } }() diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go index 0c7bd62643..991df9a082 100644 --- a/src/cmd/compile/internal/types2/typexpr.go +++ b/src/cmd/compile/internal/types2/typexpr.go @@ -211,7 +211,7 @@ func goTypeName(typ Type) string { // func (check *Checker) typInternal(e0 syntax.Expr, def *Named) (T Type) { if check.conf.Trace { - check.trace(e0.Pos(), "type %s", e0) + check.trace(e0.Pos(), "-- type %s", e0) check.indent++ defer func() { check.indent-- diff --git a/src/go/types/decl.go b/src/go/types/decl.go index 043f02491d..279220bec0 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -277,7 +277,9 @@ loop: check.trace(obj.Pos(), "## cycle contains: %d values, %d type definitions", nval, ndef) } defer func() { - if !valid { + if valid { + check.trace(obj.Pos(), "=> cycle is valid") + } else { check.trace(obj.Pos(), "=> error: cycle is invalid") } }() diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go index 1e629e3fdb..451662e598 100644 --- a/src/go/types/typexpr.go +++ b/src/go/types/typexpr.go @@ -209,7 +209,7 @@ func goTypeName(typ Type) string { // func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) { if trace { - check.trace(e0.Pos(), "type %s", e0) + check.trace(e0.Pos(), "-- type %s", e0) check.indent++ defer func() { check.indent-- From fe85c244315f82b1a6a21cd6ddc0255eed92a357 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 20 Jan 2022 18:56:57 -0800 Subject: [PATCH 692/752] go/types, types2: report an error when using a broken alias The type checker doesn't have a general mechanism to "use" the type of a type alias whose type depends on a recursive type declaration which is not yet completely type-checked. In some cases, the type of a type alias is needed before it is determined; the type is incorrect (invalid) in that case but no error is reported. The type-checker is happy with this (incorrect type), but the compiler may crash under some circumstances. A correct fix will likely require some form of forwarding type which is a fairly pervasive change and may also affect the type checker API. This CL introduces a simple side table, a map of broken type aliases, which is consulted before the type associated with a type alias is used. If the type alias is broken, an error is reported. This is a stop-gap solution that prevents the compiler from crashing. The reported error refers to the corresponding issue which suggests a work-around that may be applicable in some cases. Also fix a minor error related to type cycles: If we have a cycle that doesn't start with a type, don't use a compiler error message that explicitly mentions "type". Fixes #50259. Fixes #50276. Fixes #50779. For #50729. Change-Id: Ie8e38f49ef724e742e8e78625e6d4f3d4014a52c Reviewed-on: https://go-review.googlesource.com/c/go/+/379916 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/check.go | 23 +++++++++++ src/cmd/compile/internal/types2/decl.go | 11 ++++-- .../types2/testdata/check/cycles5.src | 4 +- .../types2/testdata/fixedbugs/issue50259.go2 | 18 +++++++++ .../types2/testdata/fixedbugs/issue50276.go2 | 39 +++++++++++++++++++ .../types2/testdata/fixedbugs/issue50779.go2 | 23 +++++++++++ src/cmd/compile/internal/types2/typexpr.go | 4 ++ src/go/types/check.go | 23 +++++++++++ src/go/types/decl.go | 15 +++++-- src/go/types/testdata/check/cycles5.src | 4 +- .../types/testdata/fixedbugs/issue50259.go2 | 18 +++++++++ .../types/testdata/fixedbugs/issue50276.go2 | 39 +++++++++++++++++++ .../types/testdata/fixedbugs/issue50779.go2 | 23 +++++++++++ src/go/types/typexpr.go | 4 ++ test/typeparam/issue50259.go | 13 +++++++ 15 files changed, 251 insertions(+), 10 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50259.go2 create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50276.go2 create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50779.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50259.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50276.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50779.go2 create mode 100644 test/typeparam/issue50259.go diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go index cce324633e..bfed16993b 100644 --- a/src/cmd/compile/internal/types2/check.go +++ b/src/cmd/compile/internal/types2/check.go @@ -130,6 +130,7 @@ type Checker struct { imports []*PkgName // list of imported packages dotImportMap map[dotImportKey]*PkgName // maps dot-imported objects to the package they were dot-imported through recvTParamMap map[*syntax.Name]*TypeParam // maps blank receiver type parameters to their type + brokenAliases map[*TypeName]bool // set of aliases with broken (not yet determined) types unionTypeSets map[*Union]*_TypeSet // computed type sets for union types mono monoGraph // graph for detecting non-monomorphizable instantiation loops @@ -160,6 +161,27 @@ func (check *Checker) addDeclDep(to Object) { from.addDep(to) } +// brokenAlias records that alias doesn't have a determined type yet. +// It also sets alias.typ to Typ[Invalid]. +func (check *Checker) brokenAlias(alias *TypeName) { + if check.brokenAliases == nil { + check.brokenAliases = make(map[*TypeName]bool) + } + check.brokenAliases[alias] = true + alias.typ = Typ[Invalid] +} + +// validAlias records that alias has the valid type typ (possibly Typ[Invalid]). +func (check *Checker) validAlias(alias *TypeName, typ Type) { + delete(check.brokenAliases, alias) + alias.typ = typ +} + +// isBrokenAlias reports whether alias doesn't have a determined type yet. +func (check *Checker) isBrokenAlias(alias *TypeName) bool { + return alias.typ == Typ[Invalid] && check.brokenAliases[alias] +} + func (check *Checker) rememberUntyped(e syntax.Expr, lhs bool, mode operandMode, typ *Basic, val constant.Value) { m := check.untyped if m == nil { @@ -333,6 +355,7 @@ func (check *Checker) checkFiles(files []*syntax.File) (err error) { check.pkgPathMap = nil check.seenPkgMap = nil check.recvTParamMap = nil + check.brokenAliases = nil check.unionTypeSets = nil check.defTypes = nil check.ctxt = nil diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index 710ae5f9c8..d9e926b856 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -314,8 +314,13 @@ func (check *Checker) cycleError(cycle []Object) { // cycle? That would be more consistent with other error messages. i := firstInSrc(cycle) obj := cycle[i] + // If obj is a type alias, mark it as valid (not broken) in order to avoid follow-on errors. + tname, _ := obj.(*TypeName) + if tname != nil && tname.IsAlias() { + check.validAlias(tname, Typ[Invalid]) + } var err error_ - if check.conf.CompilerErrorMessages { + if tname != nil && check.conf.CompilerErrorMessages { err.errorf(obj, "invalid recursive type %s", obj.Name()) } else { err.errorf(obj, "illegal cycle in declaration of %s", obj.Name()) @@ -502,9 +507,9 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *syntax.TypeDecl, def *Named check.versionErrorf(tdecl, "go1.9", "type aliases") } - obj.typ = Typ[Invalid] + check.brokenAlias(obj) rhs = check.varType(tdecl.Type) - obj.typ = rhs + check.validAlias(obj, rhs) return } diff --git a/src/cmd/compile/internal/types2/testdata/check/cycles5.src b/src/cmd/compile/internal/types2/testdata/check/cycles5.src index 397adcce01..c932ef92d0 100644 --- a/src/cmd/compile/internal/types2/testdata/check/cycles5.src +++ b/src/cmd/compile/internal/types2/testdata/check/cycles5.src @@ -135,7 +135,7 @@ type ( type ( a struct{ *b } b = c - c struct{ *b } + c struct{ *b /* ERROR invalid use of type alias */ } ) // issue #24939 @@ -145,7 +145,7 @@ type ( } M interface { - F() P + F() P // ERROR invalid use of type alias } P = interface { diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50259.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50259.go2 new file mode 100644 index 0000000000..a2e65c4c15 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50259.go2 @@ -0,0 +1,18 @@ +// Copyright 2022 The Go 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 x T[B] + +type T[_ any] struct{} +type A T[B /* ERROR invalid use of type alias */ ] +type B = T[A] + +// test case from issue + +var v Box[Step] +type Box[T any] struct{} +type Step = Box[StepBox] +type StepBox Box[Step /* ERROR invalid use of type alias */ ] diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50276.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50276.go2 new file mode 100644 index 0000000000..38a419d361 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50276.go2 @@ -0,0 +1,39 @@ +// Copyright 2022 The Go 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 + +// simplified test case + +type transform[T any] struct{} +type pair[S any] struct {} + +var _ transform[step] + +type box transform[step /* ERROR invalid use of type alias */ ] +type step = pair[box] + +// test case from issue + +type Transform[T any] struct{ hold T } +type Pair[S, T any] struct { + First S + Second T +} + +var first Transform[Step] + +// This line doesn't use the Step alias, and it compiles fine if you uncomment it. +var second Transform[Pair[Box, interface{}]] + +type Box *Transform[Step /* ERROR invalid use of type alias */ ] + +// This line is the same as the `first` line, but it comes after the Box declaration and +// does not break the compile. +var third Transform[Step] + +type Step = Pair[Box, interface{}] + +// This line also does not break the compile +var fourth Transform[Step] diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50779.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50779.go2 new file mode 100644 index 0000000000..fe68c28bba --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50779.go2 @@ -0,0 +1,23 @@ +// Copyright 2022 The Go 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 AC interface { + C +} + +type ST []int + +type R[S any, P any] struct{} + +type SR = R[SS, ST] + +type SS interface { + NSR(any) *SR // ERROR invalid use of type alias SR in recursive type +} + +type C interface { + NSR(any) *SR +} diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go index 991df9a082..92c3e642fe 100644 --- a/src/cmd/compile/internal/types2/typexpr.go +++ b/src/cmd/compile/internal/types2/typexpr.go @@ -99,6 +99,10 @@ func (check *Checker) ident(x *operand, e *syntax.Name, def *Named, wantType boo x.mode = constant_ case *TypeName: + if check.isBrokenAlias(obj) { + check.errorf(e, "invalid use of type alias %s in recursive type (see issue #50729)", obj.name) + return + } x.mode = typexpr case *Var: diff --git a/src/go/types/check.go b/src/go/types/check.go index 90b46b8075..a0c3700254 100644 --- a/src/go/types/check.go +++ b/src/go/types/check.go @@ -137,6 +137,7 @@ type Checker struct { imports []*PkgName // list of imported packages dotImportMap map[dotImportKey]*PkgName // maps dot-imported objects to the package they were dot-imported through recvTParamMap map[*ast.Ident]*TypeParam // maps blank receiver type parameters to their type + brokenAliases map[*TypeName]bool // set of aliases with broken (not yet determined) types unionTypeSets map[*Union]*_TypeSet // computed type sets for union types mono monoGraph // graph for detecting non-monomorphizable instantiation loops @@ -167,6 +168,27 @@ func (check *Checker) addDeclDep(to Object) { from.addDep(to) } +// brokenAlias records that alias doesn't have a determined type yet. +// It also sets alias.typ to Typ[Invalid]. +func (check *Checker) brokenAlias(alias *TypeName) { + if check.brokenAliases == nil { + check.brokenAliases = make(map[*TypeName]bool) + } + check.brokenAliases[alias] = true + alias.typ = Typ[Invalid] +} + +// validAlias records that alias has the valid type typ (possibly Typ[Invalid]). +func (check *Checker) validAlias(alias *TypeName, typ Type) { + delete(check.brokenAliases, alias) + alias.typ = typ +} + +// isBrokenAlias reports whether alias doesn't have a determined type yet. +func (check *Checker) isBrokenAlias(alias *TypeName) bool { + return alias.typ == Typ[Invalid] && check.brokenAliases[alias] +} + func (check *Checker) rememberUntyped(e ast.Expr, lhs bool, mode operandMode, typ *Basic, val constant.Value) { m := check.untyped if m == nil { @@ -326,6 +348,7 @@ func (check *Checker) checkFiles(files []*ast.File) (err error) { check.pkgPathMap = nil check.seenPkgMap = nil check.recvTParamMap = nil + check.brokenAliases = nil check.unionTypeSets = nil check.defTypes = nil check.ctxt = nil diff --git a/src/go/types/decl.go b/src/go/types/decl.go index 279220bec0..3fc4487309 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -313,7 +313,16 @@ func (check *Checker) cycleError(cycle []Object) { // cycle? That would be more consistent with other error messages. i := firstInSrc(cycle) obj := cycle[i] - check.errorf(obj, _InvalidDeclCycle, "illegal cycle in declaration of %s", obj.Name()) + // If obj is a type alias, mark it as valid (not broken) in order to avoid follow-on errors. + tname, _ := obj.(*TypeName) + if tname != nil && tname.IsAlias() { + check.validAlias(tname, Typ[Invalid]) + } + if tname != nil && compilerErrorMessages { + check.errorf(obj, _InvalidDeclCycle, "invalid recursive type %s", obj.Name()) + } else { + check.errorf(obj, _InvalidDeclCycle, "illegal cycle in declaration of %s", obj.Name()) + } for range cycle { check.errorf(obj, _InvalidDeclCycle, "\t%s refers to", obj.Name()) // secondary error, \t indented i++ @@ -555,9 +564,9 @@ func (check *Checker) typeDecl(obj *TypeName, tdecl *ast.TypeSpec, def *Named) { check.errorf(atPos(tdecl.Assign), _BadDecl, "type aliases requires go1.9 or later") } - obj.typ = Typ[Invalid] + check.brokenAlias(obj) rhs = check.varType(tdecl.Type) - obj.typ = rhs + check.validAlias(obj, rhs) return } diff --git a/src/go/types/testdata/check/cycles5.src b/src/go/types/testdata/check/cycles5.src index 397adcce01..c932ef92d0 100644 --- a/src/go/types/testdata/check/cycles5.src +++ b/src/go/types/testdata/check/cycles5.src @@ -135,7 +135,7 @@ type ( type ( a struct{ *b } b = c - c struct{ *b } + c struct{ *b /* ERROR invalid use of type alias */ } ) // issue #24939 @@ -145,7 +145,7 @@ type ( } M interface { - F() P + F() P // ERROR invalid use of type alias } P = interface { diff --git a/src/go/types/testdata/fixedbugs/issue50259.go2 b/src/go/types/testdata/fixedbugs/issue50259.go2 new file mode 100644 index 0000000000..a2e65c4c15 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50259.go2 @@ -0,0 +1,18 @@ +// Copyright 2022 The Go 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 x T[B] + +type T[_ any] struct{} +type A T[B /* ERROR invalid use of type alias */ ] +type B = T[A] + +// test case from issue + +var v Box[Step] +type Box[T any] struct{} +type Step = Box[StepBox] +type StepBox Box[Step /* ERROR invalid use of type alias */ ] diff --git a/src/go/types/testdata/fixedbugs/issue50276.go2 b/src/go/types/testdata/fixedbugs/issue50276.go2 new file mode 100644 index 0000000000..38a419d361 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50276.go2 @@ -0,0 +1,39 @@ +// Copyright 2022 The Go 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 + +// simplified test case + +type transform[T any] struct{} +type pair[S any] struct {} + +var _ transform[step] + +type box transform[step /* ERROR invalid use of type alias */ ] +type step = pair[box] + +// test case from issue + +type Transform[T any] struct{ hold T } +type Pair[S, T any] struct { + First S + Second T +} + +var first Transform[Step] + +// This line doesn't use the Step alias, and it compiles fine if you uncomment it. +var second Transform[Pair[Box, interface{}]] + +type Box *Transform[Step /* ERROR invalid use of type alias */ ] + +// This line is the same as the `first` line, but it comes after the Box declaration and +// does not break the compile. +var third Transform[Step] + +type Step = Pair[Box, interface{}] + +// This line also does not break the compile +var fourth Transform[Step] diff --git a/src/go/types/testdata/fixedbugs/issue50779.go2 b/src/go/types/testdata/fixedbugs/issue50779.go2 new file mode 100644 index 0000000000..fe68c28bba --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50779.go2 @@ -0,0 +1,23 @@ +// Copyright 2022 The Go 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 AC interface { + C +} + +type ST []int + +type R[S any, P any] struct{} + +type SR = R[SS, ST] + +type SS interface { + NSR(any) *SR // ERROR invalid use of type alias SR in recursive type +} + +type C interface { + NSR(any) *SR +} diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go index 451662e598..52966bb047 100644 --- a/src/go/types/typexpr.go +++ b/src/go/types/typexpr.go @@ -96,6 +96,10 @@ func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, wantType bool) x.mode = constant_ case *TypeName: + if check.isBrokenAlias(obj) { + check.errorf(e, _InvalidDeclCycle, "invalid use of type alias %s in recursive type (see issue #50729)", obj.name) + return + } x.mode = typexpr case *Var: diff --git a/test/typeparam/issue50259.go b/test/typeparam/issue50259.go new file mode 100644 index 0000000000..6987ebf790 --- /dev/null +++ b/test/typeparam/issue50259.go @@ -0,0 +1,13 @@ +// errorcheck -G=3 + +// Copyright 2022 The Go 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 x T[B] + +type T[_ any] struct{} +type A T[B] // ERROR "invalid use of type alias B in recursive type" +type B = T[A] From 671e1150c680eb5f21833662362954cc1b155d2b Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 21 Jan 2022 09:05:51 -0800 Subject: [PATCH 693/752] go/types, types2: reorder object processing to avoid broken aliases By processing non-alias type declarations before alias type declaration, and those before everything else we can avoid some of the remaining errors which are due to alias types not being available. For #25838. For #50259. For #50276. For #50729. Change-Id: I233da2899a6d4954c239638624dfa8c08662e6b9 Reviewed-on: https://go-review.googlesource.com/c/go/+/380056 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/resolver.go | 34 +++++++++++-------- .../types2/testdata/fixedbugs/issue25838.go | 26 ++++++++++++++ .../types2/testdata/fixedbugs/issue50259.go2 | 4 +-- .../types2/testdata/fixedbugs/issue50276.go2 | 4 +-- src/go/types/resolver.go | 34 +++++++++++-------- src/go/types/testdata/fixedbugs/issue25838.go | 26 ++++++++++++++ .../types/testdata/fixedbugs/issue50259.go2 | 4 +-- .../types/testdata/fixedbugs/issue50276.go2 | 4 +-- test/typeparam/issue50259.go | 4 +-- 9 files changed, 102 insertions(+), 38 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue25838.go create mode 100644 src/go/types/testdata/fixedbugs/issue25838.go diff --git a/src/cmd/compile/internal/types2/resolver.go b/src/cmd/compile/internal/types2/resolver.go index a0cad40429..05755f8cfd 100644 --- a/src/cmd/compile/internal/types2/resolver.go +++ b/src/cmd/compile/internal/types2/resolver.go @@ -656,25 +656,31 @@ func (check *Checker) packageObjects() { } } - // We process non-alias declarations first, in order to avoid situations where - // the type of an alias declaration is needed before it is available. In general - // this is still not enough, as it is possible to create sufficiently convoluted - // recursive type definitions that will cause a type alias to be needed before it - // is available (see issue #25838 for examples). - // As an aside, the cmd/compiler suffers from the same problem (#25838). + // We process non-alias type declarations first, followed by alias declarations, + // and then everything else. This appears to avoid most situations where the type + // of an alias is needed before it is available. + // There may still be cases where this is not good enough (see also issue #25838). + // In those cases Checker.ident will report an error ("invalid use of type alias"). var aliasList []*TypeName - // phase 1 + var othersList []Object // everything that's not a type + // phase 1: non-alias type declarations 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].tdecl.Alias { - aliasList = append(aliasList, tname) - continue + if tname, _ := obj.(*TypeName); tname != nil { + if check.objMap[tname].tdecl.Alias { + aliasList = append(aliasList, tname) + } else { + check.objDecl(obj, nil) + } + } else { + othersList = append(othersList, obj) } - + } + // phase 2: alias type declarations + for _, obj := range aliasList { check.objDecl(obj, nil) } - // phase 2 - for _, obj := range aliasList { + // phase 3: all other declarations + for _, obj := range othersList { check.objDecl(obj, nil) } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue25838.go b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue25838.go new file mode 100644 index 0000000000..adbd138f16 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue25838.go @@ -0,0 +1,26 @@ +// Copyright 2022 The Go 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 + +// examples from the issue + +type ( + e = f + f = g + g = []h + h i + i = j + j = e +) + +type ( + e1 = []h1 + h1 e1 +) + +type ( + P = *T + T P +) diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50259.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50259.go2 index a2e65c4c15..6df8c64524 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50259.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50259.go2 @@ -7,7 +7,7 @@ package p var x T[B] type T[_ any] struct{} -type A T[B /* ERROR invalid use of type alias */ ] +type A T[B] type B = T[A] // test case from issue @@ -15,4 +15,4 @@ type B = T[A] var v Box[Step] type Box[T any] struct{} type Step = Box[StepBox] -type StepBox Box[Step /* ERROR invalid use of type alias */ ] +type StepBox Box[Step] diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50276.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50276.go2 index 38a419d361..97e477e6fa 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50276.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50276.go2 @@ -11,7 +11,7 @@ type pair[S any] struct {} var _ transform[step] -type box transform[step /* ERROR invalid use of type alias */ ] +type box transform[step] type step = pair[box] // test case from issue @@ -27,7 +27,7 @@ var first Transform[Step] // This line doesn't use the Step alias, and it compiles fine if you uncomment it. var second Transform[Pair[Box, interface{}]] -type Box *Transform[Step /* ERROR invalid use of type alias */ ] +type Box *Transform[Step] // This line is the same as the `first` line, but it comes after the Box declaration and // does not break the compile. diff --git a/src/go/types/resolver.go b/src/go/types/resolver.go index 7a2dcbffbb..9edf41bf3c 100644 --- a/src/go/types/resolver.go +++ b/src/go/types/resolver.go @@ -629,25 +629,31 @@ func (check *Checker) packageObjects() { } } - // We process non-alias declarations first, in order to avoid situations where - // the type of an alias declaration is needed before it is available. In general - // this is still not enough, as it is possible to create sufficiently convoluted - // recursive type definitions that will cause a type alias to be needed before it - // is available (see issue #25838 for examples). - // As an aside, the cmd/compiler suffers from the same problem (#25838). + // We process non-alias type declarations first, followed by alias declarations, + // and then everything else. This appears to avoid most situations where the type + // of an alias is needed before it is available. + // There may still be cases where this is not good enough (see also issue #25838). + // In those cases Checker.ident will report an error ("invalid use of type alias"). var aliasList []*TypeName - // phase 1 + var othersList []Object // everything that's not a type + // phase 1: non-alias type declarations 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].tdecl.Assign.IsValid() { - aliasList = append(aliasList, tname) - continue + if tname, _ := obj.(*TypeName); tname != nil { + if check.objMap[tname].tdecl.Assign.IsValid() { + aliasList = append(aliasList, tname) + } else { + check.objDecl(obj, nil) + } + } else { + othersList = append(othersList, obj) } - + } + // phase 2: alias type declarations + for _, obj := range aliasList { check.objDecl(obj, nil) } - // phase 2 - for _, obj := range aliasList { + // phase 3: all other declarations + for _, obj := range othersList { check.objDecl(obj, nil) } diff --git a/src/go/types/testdata/fixedbugs/issue25838.go b/src/go/types/testdata/fixedbugs/issue25838.go new file mode 100644 index 0000000000..adbd138f16 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue25838.go @@ -0,0 +1,26 @@ +// Copyright 2022 The Go 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 + +// examples from the issue + +type ( + e = f + f = g + g = []h + h i + i = j + j = e +) + +type ( + e1 = []h1 + h1 e1 +) + +type ( + P = *T + T P +) diff --git a/src/go/types/testdata/fixedbugs/issue50259.go2 b/src/go/types/testdata/fixedbugs/issue50259.go2 index a2e65c4c15..6df8c64524 100644 --- a/src/go/types/testdata/fixedbugs/issue50259.go2 +++ b/src/go/types/testdata/fixedbugs/issue50259.go2 @@ -7,7 +7,7 @@ package p var x T[B] type T[_ any] struct{} -type A T[B /* ERROR invalid use of type alias */ ] +type A T[B] type B = T[A] // test case from issue @@ -15,4 +15,4 @@ type B = T[A] var v Box[Step] type Box[T any] struct{} type Step = Box[StepBox] -type StepBox Box[Step /* ERROR invalid use of type alias */ ] +type StepBox Box[Step] diff --git a/src/go/types/testdata/fixedbugs/issue50276.go2 b/src/go/types/testdata/fixedbugs/issue50276.go2 index 38a419d361..97e477e6fa 100644 --- a/src/go/types/testdata/fixedbugs/issue50276.go2 +++ b/src/go/types/testdata/fixedbugs/issue50276.go2 @@ -11,7 +11,7 @@ type pair[S any] struct {} var _ transform[step] -type box transform[step /* ERROR invalid use of type alias */ ] +type box transform[step] type step = pair[box] // test case from issue @@ -27,7 +27,7 @@ var first Transform[Step] // This line doesn't use the Step alias, and it compiles fine if you uncomment it. var second Transform[Pair[Box, interface{}]] -type Box *Transform[Step /* ERROR invalid use of type alias */ ] +type Box *Transform[Step] // This line is the same as the `first` line, but it comes after the Box declaration and // does not break the compile. diff --git a/test/typeparam/issue50259.go b/test/typeparam/issue50259.go index 6987ebf790..59611ef3ab 100644 --- a/test/typeparam/issue50259.go +++ b/test/typeparam/issue50259.go @@ -1,4 +1,4 @@ -// errorcheck -G=3 +// compile -G=3 // Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style @@ -9,5 +9,5 @@ package p var x T[B] type T[_ any] struct{} -type A T[B] // ERROR "invalid use of type alias B in recursive type" +type A T[B] type B = T[A] From 84eefdc933410907495e42aac872036403851ffa Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Mon, 24 Jan 2022 15:42:52 -0500 Subject: [PATCH 694/752] go/types, types2: pass the seen map through _TypeSet.IsComparable While checking comparability of type parameters, we recurse through _TypeSet.IsComparable, but do not pass the cycle-tracking seen map, resulting in infinite recursion in some cases. Refactor to pass the seen map through this recursion. Fixes #50782 Change-Id: I2c2bcfed3398c11eb9aa0c871da59e348bfba5f7 Reviewed-on: https://go-review.googlesource.com/c/go/+/380504 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/interface.go | 2 +- src/cmd/compile/internal/types2/predicates.go | 2 +- .../types2/testdata/fixedbugs/issue50782.go2 | 40 +++++++++++++++++++ src/cmd/compile/internal/types2/typeset.go | 4 +- src/go/types/interface.go | 2 +- src/go/types/predicates.go | 2 +- .../types/testdata/fixedbugs/issue50782.go2 | 40 +++++++++++++++++++ src/go/types/typeset.go | 4 +- 8 files changed, 88 insertions(+), 8 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50782.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50782.go2 diff --git a/src/cmd/compile/internal/types2/interface.go b/src/cmd/compile/internal/types2/interface.go index 4ce75c476c..ca5140d092 100644 --- a/src/cmd/compile/internal/types2/interface.go +++ b/src/cmd/compile/internal/types2/interface.go @@ -86,7 +86,7 @@ func (t *Interface) Method(i int) *Func { return t.typeSet().Method(i) } func (t *Interface) Empty() bool { return t.typeSet().IsAll() } // IsComparable reports whether each type in interface t's type set is comparable. -func (t *Interface) IsComparable() bool { return t.typeSet().IsComparable() } +func (t *Interface) IsComparable() bool { return t.typeSet().IsComparable(nil) } // IsMethodSet reports whether the interface t is fully described by its method set. func (t *Interface) IsMethodSet() bool { return t.typeSet().IsMethodSet() } diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go index d982866f8e..cc3c76e695 100644 --- a/src/cmd/compile/internal/types2/predicates.go +++ b/src/cmd/compile/internal/types2/predicates.go @@ -131,7 +131,7 @@ func comparable(T Type, seen map[Type]bool) bool { case *Array: return comparable(t.elem, seen) case *Interface: - return !isTypeParam(T) || t.IsComparable() + return !isTypeParam(T) || t.typeSet().IsComparable(seen) } return false } diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50782.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50782.go2 new file mode 100644 index 0000000000..8f41b84163 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50782.go2 @@ -0,0 +1,40 @@ +// Copyright 2022 The Go 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 first example from the issue. +type Numeric interface { + ~int | ~int8 | ~int16 | ~int32 | ~int64 +} + +// numericAbs matches numeric types with an Abs method. +type numericAbs[T Numeric] interface { + ~struct{ Value T } + Abs() T +} + +// AbsDifference computes the absolute value of the difference of +// a and b, where the absolute value is determined by the Abs method. +func absDifference[T numericAbs[T /* ERROR T does not implement Numeric */]](a, b T) T { + // TODO: the error below should probably be positioned on the '-'. + d := a /* ERROR "invalid operation: operator - not defined" */ .Value - b.Value + return d.Abs() +} + +// The second example from the issue. +type T[P int] struct{ f P } + +func _[P T[P /* ERROR "P does not implement int" */ ]]() {} + +// Additional tests +func _[P T[T /* ERROR "T\[P\] does not implement int" */ [P /* ERROR "P does not implement int" */ ]]]() {} +func _[P T[Q /* ERROR "Q does not implement int" */ ], Q T[P /* ERROR "P does not implement int" */ ]]() {} +func _[P T[Q], Q int]() {} + +type C[P comparable] struct{ f P } +func _[P C[C[P]]]() {} +func _[P C[C /* ERROR "C\[Q\] does not implement comparable" */ [Q /* ERROR "Q does not implement comparable" */]], Q func()]() {} +func _[P [10]C[P]]() {} +func _[P struct{ f C[C[P]]}]() {} diff --git a/src/cmd/compile/internal/types2/typeset.go b/src/cmd/compile/internal/types2/typeset.go index 8670c17861..348b8150d3 100644 --- a/src/cmd/compile/internal/types2/typeset.go +++ b/src/cmd/compile/internal/types2/typeset.go @@ -34,12 +34,12 @@ func (s *_TypeSet) IsAll() bool { func (s *_TypeSet) IsMethodSet() bool { return !s.comparable && s.terms.isAll() } // IsComparable reports whether each type in the set is comparable. -func (s *_TypeSet) IsComparable() bool { +func (s *_TypeSet) IsComparable(seen map[Type]bool) bool { if s.terms.isAll() { return s.comparable } return s.is(func(t *term) bool { - return t != nil && Comparable(t.typ) + return t != nil && comparable(t.typ, seen) }) } diff --git a/src/go/types/interface.go b/src/go/types/interface.go index 1ff9015780..b9d4660eb4 100644 --- a/src/go/types/interface.go +++ b/src/go/types/interface.go @@ -111,7 +111,7 @@ func (t *Interface) Method(i int) *Func { return t.typeSet().Method(i) } func (t *Interface) Empty() bool { return t.typeSet().IsAll() } // IsComparable reports whether each type in interface t's type set is comparable. -func (t *Interface) IsComparable() bool { return t.typeSet().IsComparable() } +func (t *Interface) IsComparable() bool { return t.typeSet().IsComparable(nil) } // IsMethodSet reports whether the interface t is fully described by its method // set. diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go index 1202db4049..1ba0043327 100644 --- a/src/go/types/predicates.go +++ b/src/go/types/predicates.go @@ -133,7 +133,7 @@ func comparable(T Type, seen map[Type]bool) bool { case *Array: return comparable(t.elem, seen) case *Interface: - return !isTypeParam(T) || t.IsComparable() + return !isTypeParam(T) || t.typeSet().IsComparable(seen) } return false } diff --git a/src/go/types/testdata/fixedbugs/issue50782.go2 b/src/go/types/testdata/fixedbugs/issue50782.go2 new file mode 100644 index 0000000000..8f41b84163 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50782.go2 @@ -0,0 +1,40 @@ +// Copyright 2022 The Go 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 first example from the issue. +type Numeric interface { + ~int | ~int8 | ~int16 | ~int32 | ~int64 +} + +// numericAbs matches numeric types with an Abs method. +type numericAbs[T Numeric] interface { + ~struct{ Value T } + Abs() T +} + +// AbsDifference computes the absolute value of the difference of +// a and b, where the absolute value is determined by the Abs method. +func absDifference[T numericAbs[T /* ERROR T does not implement Numeric */]](a, b T) T { + // TODO: the error below should probably be positioned on the '-'. + d := a /* ERROR "invalid operation: operator - not defined" */ .Value - b.Value + return d.Abs() +} + +// The second example from the issue. +type T[P int] struct{ f P } + +func _[P T[P /* ERROR "P does not implement int" */ ]]() {} + +// Additional tests +func _[P T[T /* ERROR "T\[P\] does not implement int" */ [P /* ERROR "P does not implement int" */ ]]]() {} +func _[P T[Q /* ERROR "Q does not implement int" */ ], Q T[P /* ERROR "P does not implement int" */ ]]() {} +func _[P T[Q], Q int]() {} + +type C[P comparable] struct{ f P } +func _[P C[C[P]]]() {} +func _[P C[C /* ERROR "C\[Q\] does not implement comparable" */ [Q /* ERROR "Q does not implement comparable" */]], Q func()]() {} +func _[P [10]C[P]]() {} +func _[P struct{ f C[C[P]]}]() {} diff --git a/src/go/types/typeset.go b/src/go/types/typeset.go index 3739cd83d6..2317177f03 100644 --- a/src/go/types/typeset.go +++ b/src/go/types/typeset.go @@ -32,12 +32,12 @@ func (s *_TypeSet) IsAll() bool { return !s.comparable && len(s.methods) == 0 && func (s *_TypeSet) IsMethodSet() bool { return !s.comparable && s.terms.isAll() } // IsComparable reports whether each type in the set is comparable. -func (s *_TypeSet) IsComparable() bool { +func (s *_TypeSet) IsComparable(seen map[Type]bool) bool { if s.terms.isAll() { return s.comparable } return s.is(func(t *term) bool { - return t != nil && Comparable(t.typ) + return t != nil && comparable(t.typ, seen) }) } From 16d6a5233a183be7264295c66167d35c689f9372 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Mon, 24 Jan 2022 14:38:01 -0800 Subject: [PATCH 695/752] cmd/compile: new absdiff.go test, fix problem with g.curDecl Added a new absdiff2.go test case, which works fully without using a typeparam on the right-hand-side of a type declaration (which is disallowed). Fixed an issue that the test revealed, which is that we need to set g.curDecl properly for the "later" functions which are deferred until after all declarations are initially processed. Also, g.curDecl may be non-nil in typeDecl for local type declaration. So, we adjust the associate assertion, and save/restore g.curDecl appropriately. Fixes #50790 Change-Id: Ieed76a7ad0a83bccb99cbad4bf98a7bfafbcbbd3 Reviewed-on: https://go-review.googlesource.com/c/go/+/380594 Reviewed-by: Keith Randall Trust: Dan Scales --- src/cmd/compile/internal/noder/decl.go | 19 +++-- test/run.go | 2 + test/typeparam/absdiff2.go | 102 +++++++++++++++++++++++++ test/typeparam/absdiffimp2.dir/a.go | 80 +++++++++++++++++++ test/typeparam/absdiffimp2.dir/main.go | 29 +++++++ test/typeparam/absdiffimp2.go | 7 ++ 6 files changed, 234 insertions(+), 5 deletions(-) create mode 100644 test/typeparam/absdiff2.go create mode 100644 test/typeparam/absdiffimp2.dir/a.go create mode 100644 test/typeparam/absdiffimp2.dir/main.go create mode 100644 test/typeparam/absdiffimp2.go diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go index df1ca1c505..a9522d09af 100644 --- a/src/cmd/compile/internal/noder/decl.go +++ b/src/cmd/compile/internal/noder/decl.go @@ -133,12 +133,20 @@ func (g *irgen) funcDecl(out *ir.Nodes, decl *syntax.FuncDecl) { g.target.Inits = append(g.target.Inits, fn) } - haveEmbed := g.haveEmbed + saveHaveEmbed := g.haveEmbed + saveCurDecl := g.curDecl g.curDecl = "" g.later(func() { - defer func(b bool) { g.haveEmbed = b }(g.haveEmbed) + defer func(b bool, s string) { + // Revert haveEmbed and curDecl back to what they were before + // the "later" function. + g.haveEmbed = b + g.curDecl = s + }(g.haveEmbed, g.curDecl) - g.haveEmbed = haveEmbed + // Set haveEmbed and curDecl to what they were for this funcDecl. + g.haveEmbed = saveHaveEmbed + g.curDecl = saveCurDecl if fn.Type().HasTParam() { g.topFuncIsGeneric = true } @@ -162,9 +170,10 @@ func (g *irgen) funcDecl(out *ir.Nodes, decl *syntax.FuncDecl) { func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) { // Set the position for any error messages we might print (e.g. too large types). base.Pos = g.pos(decl) - assert(g.curDecl == "") + assert(ir.CurFunc != nil || g.curDecl == "") // Set g.curDecl to the type name, as context for the type params declared // during types2-to-types1 translation if this is a generic type. + saveCurDecl := g.curDecl g.curDecl = decl.Name.Value if decl.Alias { name, _ := g.def(decl.Name) @@ -225,7 +234,7 @@ func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) { } types.ResumeCheckSize() - g.curDecl = "" + g.curDecl = saveCurDecl if otyp, ok := otyp.(*types2.Named); ok && otyp.NumMethods() != 0 { methods := make([]*types.Field, otyp.NumMethods()) for i := range methods { diff --git a/test/run.go b/test/run.go index 2a7f080f9d..0e35ed2c0f 100644 --- a/test/run.go +++ b/test/run.go @@ -2180,6 +2180,8 @@ var unifiedFailures = setOf( "typeparam/typeswitch4.go", // duplicate case failure due to stenciling "typeparam/issue50417b.go", // Need to handle field access on a type param "typeparam/issue50552.go", // gives missing method for instantiated type + "typeparam/absdiff2.go", // wrong assertion about closure variables + "typeparam/absdiffimp2.go", // wrong assertion about closure variables ) func setOf(keys ...string) map[string]bool { diff --git a/test/typeparam/absdiff2.go b/test/typeparam/absdiff2.go new file mode 100644 index 0000000000..8f13bad2b6 --- /dev/null +++ b/test/typeparam/absdiff2.go @@ -0,0 +1,102 @@ +// run -gcflags=-G=3 + +// Copyright 2022 The Go 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" +) + +type Numeric interface { + ~int | ~int8 | ~int16 | ~int32 | ~int64 | + ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | + ~float32 | ~float64 | + ~complex64 | ~complex128 +} + +// numericAbs matches a struct containing a numeric type that has an Abs method. +type numericAbs[T Numeric] interface { + ~struct{ Value T } + Abs() T +} + +// AbsDifference computes the absolute value of the difference of +// a and b, where the absolute value is determined by the Abs method. +func absDifference[T Numeric, U numericAbs[T]](a, b U) T { + d := a.Value - b.Value + dt := U{Value: d} + return dt.Abs() +} + +// orderedNumeric matches numeric types that support the < operator. +type orderedNumeric interface { + ~int | ~int8 | ~int16 | ~int32 | ~int64 | + ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | + ~float32 | ~float64 +} + +// Complex matches the two complex types, which do not have a < operator. +type Complex interface { + ~complex64 | ~complex128 +} + +// orderedAbs is a helper type that defines an Abs method for +// a struct containing an ordered numeric type. +type orderedAbs[T orderedNumeric] struct { + Value T +} + +func (a orderedAbs[T]) Abs() T { + if a.Value < 0 { + return -a.Value + } + return a.Value +} + +// complexAbs is a helper type that defines an Abs method for +// a struct containing a complex type. +type complexAbs[T Complex] struct { + Value T +} + +func (a complexAbs[T]) Abs() T { + r := float64(real(a.Value)) + i := float64(imag(a.Value)) + d := math.Sqrt(r*r + i*i) + return T(complex(d, 0)) +} + +// OrderedAbsDifference returns the absolute value of the difference +// between a and b, where a and b are of an ordered type. +func OrderedAbsDifference[T orderedNumeric](a, b T) T { + return absDifference(orderedAbs[T]{a}, orderedAbs[T]{b}) +} + +// ComplexAbsDifference returns the absolute value of the difference +// between a and b, where a and b are of a complex type. +func ComplexAbsDifference[T Complex](a, b T) T { + return absDifference(complexAbs[T]{a}, complexAbs[T]{b}) +} + +func main() { + if got, want := OrderedAbsDifference(1.0, -2.0), 3.0; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + if got, want := OrderedAbsDifference(-1.0, 2.0), 3.0; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + if got, want := OrderedAbsDifference(-20, 15), 35; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + + if got, want := ComplexAbsDifference(5.0+2.0i, 2.0-2.0i), 5+0i; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + if got, want := ComplexAbsDifference(2.0-2.0i, 5.0+2.0i), 5+0i; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } +} diff --git a/test/typeparam/absdiffimp2.dir/a.go b/test/typeparam/absdiffimp2.dir/a.go new file mode 100644 index 0000000000..782e000da9 --- /dev/null +++ b/test/typeparam/absdiffimp2.dir/a.go @@ -0,0 +1,80 @@ +// Copyright 2022 The Go 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 + +import ( + "math" +) + +type Numeric interface { + ~int | ~int8 | ~int16 | ~int32 | ~int64 | + ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | + ~float32 | ~float64 | + ~complex64 | ~complex128 +} + +// numericAbs matches a struct containing a numeric type that has an Abs method. +type numericAbs[T Numeric] interface { + ~struct{ Value T } + Abs() T +} + +// AbsDifference computes the absolute value of the difference of +// a and b, where the absolute value is determined by the Abs method. +func absDifference[T Numeric, U numericAbs[T]](a, b U) T { + d := a.Value - b.Value + dt := U{Value: d} + return dt.Abs() +} + +// orderedNumeric matches numeric types that support the < operator. +type orderedNumeric interface { + ~int | ~int8 | ~int16 | ~int32 | ~int64 | + ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | + ~float32 | ~float64 +} + +// Complex matches the two complex types, which do not have a < operator. +type Complex interface { + ~complex64 | ~complex128 +} + +// orderedAbs is a helper type that defines an Abs method for +// a struct containing an ordered numeric type. +type orderedAbs[T orderedNumeric] struct { + Value T +} + +func (a orderedAbs[T]) Abs() T { + if a.Value < 0 { + return -a.Value + } + return a.Value +} + +// complexAbs is a helper type that defines an Abs method for +// a struct containing a complex type. +type complexAbs[T Complex] struct { + Value T +} + +func (a complexAbs[T]) Abs() T { + r := float64(real(a.Value)) + i := float64(imag(a.Value)) + d := math.Sqrt(r*r + i*i) + return T(complex(d, 0)) +} + +// OrderedAbsDifference returns the absolute value of the difference +// between a and b, where a and b are of an ordered type. +func OrderedAbsDifference[T orderedNumeric](a, b T) T { + return absDifference(orderedAbs[T]{a}, orderedAbs[T]{b}) +} + +// ComplexAbsDifference returns the absolute value of the difference +// between a and b, where a and b are of a complex type. +func ComplexAbsDifference[T Complex](a, b T) T { + return absDifference(complexAbs[T]{a}, complexAbs[T]{b}) +} diff --git a/test/typeparam/absdiffimp2.dir/main.go b/test/typeparam/absdiffimp2.dir/main.go new file mode 100644 index 0000000000..8eefdbdf38 --- /dev/null +++ b/test/typeparam/absdiffimp2.dir/main.go @@ -0,0 +1,29 @@ +// 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" + "fmt" +) + +func main() { + if got, want := a.OrderedAbsDifference(1.0, -2.0), 3.0; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + if got, want := a.OrderedAbsDifference(-1.0, 2.0), 3.0; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + if got, want := a.OrderedAbsDifference(-20, 15), 35; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + + if got, want := a.ComplexAbsDifference(5.0+2.0i, 2.0-2.0i), 5+0i; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + if got, want := a.ComplexAbsDifference(2.0-2.0i, 5.0+2.0i), 5+0i; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } +} diff --git a/test/typeparam/absdiffimp2.go b/test/typeparam/absdiffimp2.go new file mode 100644 index 0000000000..76930e5e4f --- /dev/null +++ b/test/typeparam/absdiffimp2.go @@ -0,0 +1,7 @@ +// rundir -G=3 + +// 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 From 078ddecc327a20cec4751e66911197409e01f6d9 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Tue, 25 Jan 2022 09:50:03 -0800 Subject: [PATCH 696/752] test: add a new test absdiff3.go which uses function callback We have disallowed having a typeparam on the right-hand-side of a type declaration. So, we disabled much of the test absdiff.go. I recently wrote a new test absdiff2.go to use a structure containing the type param type, so I could attach a method properly and run the full test. As a contrast, I thought I would create absdiff3.go, where the Abs functionality is passed in as a function callback (but derived from a generic function). This is simpler, and more inline with some of the guidelines that Ian has been proposing (use passed-in functions rather than requiring methods, when possible, for greater ease-of-use). Only adds a new test absdiff3.go. (And fixes a comment in absdiff2.go.) Change-Id: I6dd185b50a3baeec31f689a892319963468a7201 Reviewed-on: https://go-review.googlesource.com/c/go/+/380774 Reviewed-by: Robert Griesemer Trust: Dan Scales --- test/typeparam/absdiff2.go | 5 +- test/typeparam/absdiff3.go | 82 +++++++++++++++++++++++++++++ test/typeparam/absdiffimp2.dir/a.go | 2 +- 3 files changed, 87 insertions(+), 2 deletions(-) create mode 100644 test/typeparam/absdiff3.go diff --git a/test/typeparam/absdiff2.go b/test/typeparam/absdiff2.go index 8f13bad2b6..2d82c4721c 100644 --- a/test/typeparam/absdiff2.go +++ b/test/typeparam/absdiff2.go @@ -4,6 +4,9 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// absdiff example in which an Abs method is attached to a generic type, which is a +// structure with a single field that may be a list of possible basic types. + package main import ( @@ -24,7 +27,7 @@ type numericAbs[T Numeric] interface { Abs() T } -// AbsDifference computes the absolute value of the difference of +// absDifference computes the absolute value of the difference of // a and b, where the absolute value is determined by the Abs method. func absDifference[T Numeric, U numericAbs[T]](a, b U) T { d := a.Value - b.Value diff --git a/test/typeparam/absdiff3.go b/test/typeparam/absdiff3.go new file mode 100644 index 0000000000..3ca03fe26f --- /dev/null +++ b/test/typeparam/absdiff3.go @@ -0,0 +1,82 @@ +// run -gcflags=-G=3 + +// Copyright 2022 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// absdiff example using a function argument rather than attaching an +// Abs method to a structure containing base types. + +package main + +import ( + "fmt" + "math" +) + +type Numeric interface { + OrderedNumeric | Complex +} + +// absDifference computes the absolute value of the difference of +// a and b, where the absolute value is determined by the abs function. +func absDifference[T Numeric](a, b T, abs func(a T) T) T { + return abs(a - b) +} + +// OrderedNumeric matches numeric types that support the < operator. +type OrderedNumeric interface { + ~int | ~int8 | ~int16 | ~int32 | ~int64 | + ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr | + ~float32 | ~float64 +} + +func Abs[T OrderedNumeric](a T) T { + if a < 0 { + return -a + } + return a +} + +// Complex matches the two complex types, which do not have a < operator. +type Complex interface { + ~complex64 | ~complex128 +} + +func ComplexAbs[T Complex](a T) T { + r := float64(real(a)) + i := float64(imag(a)) + d := math.Sqrt(r*r + i*i) + return T(complex(d, 0)) +} + +// OrderedAbsDifference returns the absolute value of the difference +// between a and b, where a and b are of an ordered type. +func OrderedAbsDifference[T OrderedNumeric](a, b T) T { + return absDifference(a, b, Abs[T]) +} + +// ComplexAbsDifference returns the absolute value of the difference +// between a and b, where a and b are of a complex type. +func ComplexAbsDifference[T Complex](a, b T) T { + return absDifference(a, b, ComplexAbs[T]) +} + +func main() { + if got, want := OrderedAbsDifference(1.0, -2.0), 3.0; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + if got, want := OrderedAbsDifference(-1.0, 2.0), 3.0; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + if got, want := OrderedAbsDifference(-20, 15), 35; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + + if got, want := ComplexAbsDifference(5.0+2.0i, 2.0-2.0i), 5+0i; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } + if got, want := ComplexAbsDifference(2.0-2.0i, 5.0+2.0i), 5+0i; got != want { + panic(fmt.Sprintf("got = %v, want = %v", got, want)) + } +} diff --git a/test/typeparam/absdiffimp2.dir/a.go b/test/typeparam/absdiffimp2.dir/a.go index 782e000da9..302b69b976 100644 --- a/test/typeparam/absdiffimp2.dir/a.go +++ b/test/typeparam/absdiffimp2.dir/a.go @@ -21,7 +21,7 @@ type numericAbs[T Numeric] interface { Abs() T } -// AbsDifference computes the absolute value of the difference of +// absDifference computes the absolute value of the difference of // a and b, where the absolute value is determined by the Abs method. func absDifference[T Numeric, U numericAbs[T]](a, b U) T { d := a.Value - b.Value From b66bc0a9d5eba193f7d7f4977ca64a77527f4b3b Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Mon, 24 Jan 2022 10:37:59 -0500 Subject: [PATCH 697/752] go/types, types2: make each method instantiation independently lazy Method signatures can introduce a significant number of edges into the type graph. One can imagine a generic type with many methods, each of which may use other instantiated types, etc. For performance, when type checking generic code, we should avoid unnecessary instantiation of methods wherever possible. This CL achieves this by making method instantiation lazy at the individual method level. It abstracts method access into a methodList type, which may be either eager or lazy. In the lazy case, methods are only instantiated when they are accessed via the Named.Method, MethodSet, or LookupFieldOrMethod APIs. Factoring out a methodList type makes it easier to verify that we're not leaking the methods slice anywhere, and as a side benefit reduces the size of *Named types in the case where there are no methods. The effective memory footprint of Named types with methods increases by a pointer (to hold the slice of guards), and the footprint of instantiated named types increases additionally by a sync.Once per method. We estimate that this memory increase is more than offset by the reduction in the number of instantiated methods. This also simplifies the code. Previously we had to work around the fact that named type expansion could occur before all signatures were set-up, by stashing the instantiated receiver into a partially filled-out *Func. With fully lazy methods, we can rely on the invariant that any use of methods in valid code can only occur after all signatures can be type checked. This means that we can fully instantiate the *Func, and don't need to deal with partially instantiated stubs. Finally, this CL fixes a bug (issue #50619), where traversing Method->Receiver Type->Method did not get us back where we started. This is fixed by not instantiating a new method if t is already the receiver base of the original method. A test is added to explicitly verify the invariant above, and more test cases are added for the behavior of Info with respect to generic code. Fixes #50619 Change-Id: I5b6d2bdc4404c9f5dcb583a29cb64e8af9794c54 Reviewed-on: https://go-review.googlesource.com/c/go/+/380499 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/api_test.go | 113 ++++++++++++ src/cmd/compile/internal/types2/decl.go | 12 +- .../compile/internal/types2/instantiate.go | 2 +- src/cmd/compile/internal/types2/lookup.go | 2 +- src/cmd/compile/internal/types2/methodlist.go | 79 ++++++++ .../internal/types2/methodlist_test.go | 40 ++++ src/cmd/compile/internal/types2/named.go | 171 ++++++++++-------- src/cmd/compile/internal/types2/object.go | 9 +- .../compile/internal/types2/sizeof_test.go | 4 +- src/cmd/compile/internal/types2/typexpr.go | 2 +- src/go/types/api_test.go | 114 ++++++++++++ src/go/types/decl.go | 12 +- src/go/types/instantiate.go | 2 +- src/go/types/lookup.go | 2 +- src/go/types/methodlist.go | 78 ++++++++ src/go/types/methodlist_test.go | 41 +++++ src/go/types/methodset.go | 41 +++-- src/go/types/named.go | 171 ++++++++++-------- src/go/types/object.go | 9 +- src/go/types/sizeof_test.go | 4 +- src/go/types/typexpr.go | 2 +- 21 files changed, 701 insertions(+), 209 deletions(-) create mode 100644 src/cmd/compile/internal/types2/methodlist.go create mode 100644 src/cmd/compile/internal/types2/methodlist_test.go create mode 100644 src/go/types/methodlist.go create mode 100644 src/go/types/methodlist_test.go diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go index 3b75818d56..b54f84dde0 100644 --- a/src/cmd/compile/internal/types2/api_test.go +++ b/src/cmd/compile/internal/types2/api_test.go @@ -640,6 +640,11 @@ func TestDefsInfo(t *testing.T) { {`package p3; type x int`, `x`, `type p3.x int`}, {`package p4; func f()`, `f`, `func p4.f()`}, {`package p5; func f() int { x, _ := 1, 2; return x }`, `_`, `var _ int`}, + + // Tests using generics. + {`package g0; type x[T any] int`, `x`, `type g0.x[T any] int`}, + {`package g1; func f[T any]() {}`, `f`, `func g1.f[T any]()`}, + {`package g2; type x[T any] int; func (*x[_]) m() {}`, `m`, `func (*g2.x[_]).m()`}, } for _, test := range tests { @@ -678,6 +683,20 @@ func TestUsesInfo(t *testing.T) { {`package p2; func _() { _ = x }; var x int`, `x`, `var p2.x int`}, {`package p3; func _() { type _ x }; type x int`, `x`, `type p3.x int`}, {`package p4; func _() { _ = f }; func f()`, `f`, `func p4.f()`}, + + // Tests using generics. + {`package g0; func _[T any]() { _ = x }; const x = 42`, `x`, `const g0.x untyped int`}, + {`package g1; func _[T any](x T) { }`, `T`, `type parameter T any`}, + {`package g2; type N[A any] int; var _ N[int]`, `N`, `type g2.N[A any] int`}, + {`package g3; type N[A any] int; func (N[_]) m() {}`, `N`, `type g3.N[A any] int`}, + + // Uses of fields are instantiated. + {`package s1; type N[A any] struct{ a A }; var f = N[int]{}.a`, `a`, `field a int`}, + {`package s1; type N[A any] struct{ a A }; func (r N[B]) m(b B) { r.a = b }`, `a`, `field a B`}, + + // Uses of methods are uses of the instantiated method. + {`package m0; type N[A any] int; func (r N[B]) m() { r.n() }; func (N[C]) n() {}`, `n`, `func (m0.N[B]).n()`}, + {`package m1; type N[A any] int; func (r N[B]) m() { }; var f = N[int].m`, `m`, `func (m1.N[int]).m()`}, } for _, test := range tests { @@ -705,6 +724,89 @@ func TestUsesInfo(t *testing.T) { } } +func TestGenericMethodInfo(t *testing.T) { + src := `package p + +type N[A any] int + +func (r N[B]) m() { r.m(); r.n() } + +func (r *N[C]) n() { } +` + f, err := parseSrc("p.go", src) + if err != nil { + t.Fatal(err) + } + info := Info{ + Defs: make(map[*syntax.Name]Object), + Uses: make(map[*syntax.Name]Object), + Selections: make(map[*syntax.SelectorExpr]*Selection), + } + var conf Config + pkg, err := conf.Check("p", []*syntax.File{f}, &info) + if err != nil { + t.Fatal(err) + } + + N := pkg.Scope().Lookup("N").Type().(*Named) + + // Find the generic methods stored on N. + gm, gn := N.Method(0), N.Method(1) + if gm.Name() == "n" { + gm, gn = gn, gm + } + + // Collect objects from info. + var dm, dn *Func // the declared methods + var dmm, dmn *Func // the methods used in the body of m + for _, decl := range f.DeclList { + fdecl, ok := decl.(*syntax.FuncDecl) + if !ok { + continue + } + def := info.Defs[fdecl.Name].(*Func) + switch fdecl.Name.Value { + case "m": + dm = def + syntax.Inspect(fdecl.Body, func(n syntax.Node) bool { + if call, ok := n.(*syntax.CallExpr); ok { + sel := call.Fun.(*syntax.SelectorExpr) + use := info.Uses[sel.Sel].(*Func) + selection := info.Selections[sel] + if selection.Kind() != MethodVal { + t.Errorf("Selection kind = %v, want %v", selection.Kind(), MethodVal) + } + if selection.Obj() != use { + t.Errorf("info.Selections contains %v, want %v", selection.Obj(), use) + } + switch sel.Sel.Value { + case "m": + dmm = use + case "n": + dmn = use + } + } + return true + }) + case "n": + dn = def + } + } + + if gm != dm { + t.Errorf(`N.Method(...) returns %v for "m", but Info.Defs has %v`, gm, dm) + } + if gn != dn { + t.Errorf(`N.Method(...) returns %v for "m", but Info.Defs has %v`, gm, dm) + } + if dmm != dm { + t.Errorf(`Inside "m", r.m uses %v, want the defined func %v`, dmm, dm) + } + if dmn == dn { + t.Errorf(`Inside "m", r.n uses %v, want a func distinct from %v`, dmm, dm) + } +} + func TestImplicitsInfo(t *testing.T) { testenv.MustHaveGoBuild(t) @@ -725,6 +827,17 @@ func TestImplicitsInfo(t *testing.T) { {`package p8; func f(int) {}`, "field: var int"}, {`package p9; func f() (complex64) { return 0 }`, "field: var complex64"}, {`package p10; type T struct{}; func (*T) f() {}`, "field: var *p10.T"}, + + // Tests using generics. + {`package f0; func f[T any](x int) {}`, ""}, // no Implicits entry + {`package f1; func f[T any](int) {}`, "field: var int"}, + {`package f2; func f[T any](T) {}`, "field: var T"}, + {`package f3; func f[T any]() (complex64) { return 0 }`, "field: var complex64"}, + {`package f4; func f[T any](t T) (T) { return t }`, "field: var T"}, + {`package t0; type T[A any] struct{}; func (*T[_]) f() {}`, "field: var *t0.T[_]"}, + {`package t1; type T[A any] struct{}; func _(x interface{}) { switch t := x.(type) { case T[int]: _ = t } }`, "caseClause: var t t1.T[int]"}, + {`package t2; type T[A any] struct{}; func _[P any](x interface{}) { switch t := x.(type) { case T[P]: _ = t } }`, "caseClause: var t t2.T[P]"}, + {`package t3; func _[P any](x interface{}) { switch t := x.(type) { case P: _ = t } }`, "caseClause: var t P"}, } for _, test := range tests { diff --git a/src/cmd/compile/internal/types2/decl.go b/src/cmd/compile/internal/types2/decl.go index d9e926b856..0e8f5085ba 100644 --- a/src/cmd/compile/internal/types2/decl.go +++ b/src/cmd/compile/internal/types2/decl.go @@ -66,12 +66,6 @@ func (check *Checker) objDecl(obj Object, def *Named) { }() } - // Funcs with m.instRecv set have not yet be completed. Complete them now - // so that they have a type when objDecl exits. - if m, _ := obj.(*Func); m != nil && m.instRecv != nil { - check.completeMethod(nil, m) - } - // Checking the declaration of obj means inferring its type // (and possibly its value, for constants). // An object's type (and thus the object) may be in one of @@ -643,6 +637,7 @@ func (check *Checker) collectMethods(obj *TypeName) { // and field names must be distinct." base, _ := obj.typ.(*Named) // shouldn't fail but be conservative if base != nil { + assert(base.targs.Len() == 0) // collectMethods should not be called on an instantiated type u := base.under() if t, _ := u.(*Struct); t != nil { for _, fld := range t.fields { @@ -655,7 +650,8 @@ func (check *Checker) collectMethods(obj *TypeName) { // Checker.Files may be called multiple times; additional package files // may add methods to already type-checked types. Add pre-existing methods // so that we can detect redeclarations. - for _, m := range base.methods { + for i := 0; i < base.methods.Len(); i++ { + m := base.methods.At(i, nil) assert(m.name != "_") assert(mset.insert(m) == nil) } @@ -687,7 +683,7 @@ func (check *Checker) collectMethods(obj *TypeName) { if base != nil { base.resolve(nil) // TODO(mdempsky): Probably unnecessary. - base.methods = append(base.methods, m) + base.AddMethod(m) } } } diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go index 5d5a660419..e520d0ffa3 100644 --- a/src/cmd/compile/internal/types2/instantiate.go +++ b/src/cmd/compile/internal/types2/instantiate.go @@ -78,7 +78,7 @@ func (check *Checker) instance(pos syntax.Pos, orig Type, targs []Type, ctxt *Co tname := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil) named := check.newNamed(tname, orig, nil, nil, nil) // underlying, tparams, and methods are set when named is resolved named.targs = newTypeList(targs) - named.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) { + named.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, *methodList) { return expandNamed(ctxt, n, pos) } res = named diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index 3e55c07b67..408832846d 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -144,7 +144,7 @@ func lookupFieldOrMethod(T Type, addressable, checkFold bool, pkg *Package, name // look for a matching attached method named.resolve(nil) - if i, m := lookupMethodFold(named.methods, pkg, name, checkFold); m != nil { + if i, m := named.lookupMethodFold(pkg, name, checkFold); m != nil { // potential match // caution: method may not have a proper signature yet index = concat(e.index, i) diff --git a/src/cmd/compile/internal/types2/methodlist.go b/src/cmd/compile/internal/types2/methodlist.go new file mode 100644 index 0000000000..ba10159ea2 --- /dev/null +++ b/src/cmd/compile/internal/types2/methodlist.go @@ -0,0 +1,79 @@ +// Copyright 2022 The Go 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 types2 + +import "sync" + +// methodList holds a list of methods that may be lazily resolved by a provided +// resolution method. +type methodList struct { + methods []*Func + + // guards synchronizes the instantiation of lazy methods. For lazy method + // lists, guards is non-nil and of the length passed to newLazyMethodList. + // For non-lazy method lists, guards is nil. + guards *[]sync.Once +} + +// newMethodList creates a non-lazy method list holding the given methods. +func newMethodList(methods []*Func) *methodList { + return &methodList{methods: methods} +} + +// newLazyMethodList creates a lazy method list of the given length. Methods +// may be resolved lazily for a given index by providing a resolver function. +func newLazyMethodList(length int) *methodList { + guards := make([]sync.Once, length) + return &methodList{ + methods: make([]*Func, length), + guards: &guards, + } +} + +// isLazy reports whether the receiver is a lazy method list. +func (l *methodList) isLazy() bool { + return l != nil && l.guards != nil +} + +// Add appends a method to the method list if not not already present. Add +// panics if the receiver is lazy. +func (l *methodList) Add(m *Func) { + assert(!l.isLazy()) + if i, _ := lookupMethod(l.methods, m.pkg, m.name); i < 0 { + l.methods = append(l.methods, m) + } +} + +// LookupFold looks up the method identified by pkg and name in the receiver. +// LookupFold panics if the receiver is lazy. If checkFold is true, it matches +// a method name if the names are equal with case folding. +func (l *methodList) LookupFold(pkg *Package, name string, checkFold bool) (int, *Func) { + assert(!l.isLazy()) + if l == nil { + return -1, nil + } + return lookupMethodFold(l.methods, pkg, name, checkFold) +} + +// Len returns the length of the method list. +func (l *methodList) Len() int { + if l == nil { + return 0 + } + return len(l.methods) +} + +// At returns the i'th method of the method list. At panics if i is out of +// bounds, or if the receiver is lazy and resolve is nil. +func (l *methodList) At(i int, resolve func() *Func) *Func { + if !l.isLazy() { + return l.methods[i] + } + assert(resolve != nil) + (*l.guards)[i].Do(func() { + l.methods[i] = resolve() + }) + return l.methods[i] +} diff --git a/src/cmd/compile/internal/types2/methodlist_test.go b/src/cmd/compile/internal/types2/methodlist_test.go new file mode 100644 index 0000000000..7a183ac7f9 --- /dev/null +++ b/src/cmd/compile/internal/types2/methodlist_test.go @@ -0,0 +1,40 @@ +// Copyright 2022 The Go 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 types2 + +import ( + "testing" +) + +func TestLazyMethodList(t *testing.T) { + l := newLazyMethodList(2) + + if got := l.Len(); got != 2 { + t.Fatalf("Len() = %d, want 2", got) + } + + f0 := NewFunc(nopos, nil, "f0", nil) + f1 := NewFunc(nopos, nil, "f1", nil) + + // Verify that methodList.At is idempotent, by calling it repeatedly with a + // resolve func that returns different pointer values (f0 or f1). + steps := []struct { + index int + resolve *Func // the *Func returned by the resolver + want *Func // the actual *Func returned by methodList.At + }{ + {0, f0, f0}, + {0, f1, f0}, + {1, f1, f1}, + {1, f0, f1}, + } + + for i, step := range steps { + got := l.At(step.index, func() *Func { return step.resolve }) + if got != step.want { + t.Errorf("step %d: At(%d, ...) = %s, want %s", i, step.index, got.Name(), step.want.Name()) + } + } +} diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go index 3ba53052d7..ed33a9ddf7 100644 --- a/src/cmd/compile/internal/types2/named.go +++ b/src/cmd/compile/internal/types2/named.go @@ -18,10 +18,16 @@ type Named struct { underlying Type // possibly a *Named during setup; never a *Named once set up completely tparams *TypeParamList // type parameters, or nil targs *TypeList // type arguments (after instantiation), or nil - methods []*Func // methods declared for this type (not the method set of this type); signatures are type-checked lazily + + // methods declared for this type (not the method set of this type). + // Signatures are type-checked lazily. + // For non-instantiated types, this is a fully populated list of methods. For + // instantiated types, this is a 'lazy' list, and methods are instantiated + // when they are first accessed. + methods *methodList // resolver may be provided to lazily resolve type parameters, underlying, and methods. - resolver func(*Context, *Named) (tparams *TypeParamList, underlying Type, methods []*Func) + resolver func(*Context, *Named) (tparams *TypeParamList, underlying Type, methods *methodList) once sync.Once // ensures that tparams, underlying, and methods are resolved before accessing } @@ -32,7 +38,7 @@ func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named { if _, ok := underlying.(*Named); ok { panic("underlying type must not be *Named") } - return (*Checker)(nil).newNamed(obj, nil, underlying, nil, methods) + return (*Checker)(nil).newNamed(obj, nil, underlying, nil, newMethodList(methods)) } func (t *Named) resolve(ctxt *Context) *Named { @@ -56,7 +62,7 @@ func (t *Named) resolve(ctxt *Context) *Named { } // newNamed is like NewNamed but with a *Checker receiver and additional orig argument. -func (check *Checker) newNamed(obj *TypeName, orig *Named, underlying Type, tparams *TypeParamList, methods []*Func) *Named { +func (check *Checker) newNamed(obj *TypeName, orig *Named, underlying Type, tparams *TypeParamList, methods *methodList) *Named { typ := &Named{check: check, obj: obj, orig: orig, fromRHS: underlying, underlying: underlying, tparams: tparams, methods: methods} if typ.orig == nil { typ.orig = typ @@ -97,10 +103,72 @@ func (t *Named) SetTypeParams(tparams []*TypeParam) { func (t *Named) TypeArgs() *TypeList { return t.targs } // NumMethods returns the number of explicit methods whose receiver is named type t. -func (t *Named) NumMethods() int { return len(t.resolve(nil).methods) } +func (t *Named) NumMethods() int { return t.resolve(nil).methods.Len() } // Method returns the i'th method of named type t for 0 <= i < t.NumMethods(). -func (t *Named) Method(i int) *Func { return t.resolve(nil).methods[i] } +func (t *Named) Method(i int) *Func { + t.resolve(nil) + return t.methods.At(i, func() *Func { + return t.instantiateMethod(i) + }) +} + +// instiateMethod instantiates the i'th method for an instantiated receiver. +func (t *Named) instantiateMethod(i int) *Func { + assert(t.TypeArgs().Len() > 0) // t must be an instance + + // t.orig.methods is not lazy. origm is the method instantiated with its + // receiver type parameters (the "origin" method). + origm := t.orig.Method(i) + assert(origm != nil) + + check := t.check + // Ensure that the original method is type-checked. + if check != nil { + check.objDecl(origm, nil) + } + + origSig := origm.typ.(*Signature) + rbase, _ := deref(origSig.Recv().Type()) + + // If rbase is t, then origm is already the instantiated method we're looking + // for. In this case, we return origm to preserve the invariant that + // traversing Method->Receiver Type->Method should get back to the same + // method. + // + // This occurs if t is instantiated with the receiver type parameters, as in + // the use of m in func (r T[_]) m() { r.m() }. + if rbase == t { + return origm + } + + sig := origSig + // We can only substitute if we have a correspondence between type arguments + // and type parameters. This check is necessary in the presence of invalid + // code. + if origSig.RecvTypeParams().Len() == t.targs.Len() { + ctxt := check.bestContext(nil) + smap := makeSubstMap(origSig.RecvTypeParams().list(), t.targs.list()) + sig = check.subst(origm.pos, origSig, smap, ctxt).(*Signature) + } + + if sig == origSig { + // No substitution occurred, but we still need to create a new signature to + // hold the instantiated receiver. + copy := *origSig + sig = © + } + + var rtyp Type + if origm.hasPtrRecv() { + rtyp = NewPointer(t) + } else { + rtyp = t + } + + sig.recv = NewParam(origSig.recv.pos, origSig.recv.pkg, origSig.recv.name, rtyp) + return NewFunc(origm.pos, origm.pkg, origm.name, sig) +} // SetUnderlying sets the underlying type and marks t as complete. // t must not have type arguments. @@ -123,9 +191,10 @@ func (t *Named) SetUnderlying(underlying Type) { func (t *Named) AddMethod(m *Func) { assert(t.targs.Len() == 0) t.resolve(nil) - if i, _ := lookupMethod(t.methods, m.pkg, m.name); i < 0 { - t.methods = append(t.methods, m) + if t.methods == nil { + t.methods = newMethodList(nil) } + t.methods.Add(m) } func (t *Named) Underlying() Type { return t.resolve(nil).underlying } @@ -228,6 +297,19 @@ func (n *Named) setUnderlying(typ Type) { } } +func (n *Named) lookupMethodFold(pkg *Package, name string, checkFold bool) (int, *Func) { + n.resolve(nil) + // If n is an instance, we may not have yet instantiated all of its methods. + // Look up the method index in orig, and only instantiate method at the + // matching index (if any). + i, _ := n.orig.methods.LookupFold(pkg, name, checkFold) + if i < 0 { + return -1, nil + } + // For instances, m.Method(i) will be different from the orig method. + return i, n.Method(i) +} + // bestContext returns the best available context. In order of preference: // - the given ctxt, if non-nil // - check.ctxt, if check is non-nil @@ -247,7 +329,7 @@ func (check *Checker) bestContext(ctxt *Context) *Context { // expandNamed ensures that the underlying type of n is instantiated. // The underlying type will be Typ[Invalid] if there was an error. -func expandNamed(ctxt *Context, n *Named, instPos syntax.Pos) (tparams *TypeParamList, underlying Type, methods []*Func) { +func expandNamed(ctxt *Context, n *Named, instPos syntax.Pos) (tparams *TypeParamList, underlying Type, methods *methodList) { n.orig.resolve(ctxt) assert(n.orig.underlying != nil) @@ -269,80 +351,13 @@ func expandNamed(ctxt *Context, n *Named, instPos syntax.Pos) (tparams *TypePara smap := makeSubstMap(n.orig.tparams.list(), n.targs.list()) underlying = n.check.subst(instPos, n.orig.underlying, smap, ctxt) - - for i := 0; i < n.orig.NumMethods(); i++ { - origm := n.orig.Method(i) - - // During type checking origm may not have a fully set up type, so defer - // instantiation of its signature until later. - m := NewFunc(origm.pos, origm.pkg, origm.name, nil) - m.hasPtrRecv_ = origm.hasPtrRecv() - // Setting instRecv here allows us to complete later (we need the - // instRecv to get targs and the original method). - m.instRecv = n - - methods = append(methods, m) - } } else { underlying = Typ[Invalid] } - // Methods should not escape the type checker API without being completed. If - // we're in the context of a type checking pass, we need to defer this until - // later (not all methods may have types). - completeMethods := func() { - for _, m := range methods { - if m.instRecv != nil { - check.completeMethod(ctxt, m) - } - } - } - if check != nil { - check.later(completeMethods) - } else { - completeMethods() - } + mlist := newLazyMethodList(n.orig.methods.Len()) - return n.orig.tparams, underlying, methods -} - -func (check *Checker) completeMethod(ctxt *Context, m *Func) { - assert(m.instRecv != nil) - rbase := m.instRecv - m.instRecv = nil - m.setColor(black) - - assert(rbase.TypeArgs().Len() > 0) - - // Look up the original method. - _, orig := lookupMethod(rbase.orig.methods, rbase.obj.pkg, m.name) - assert(orig != nil) - if check != nil { - check.objDecl(orig, nil) - } - origSig := orig.typ.(*Signature) - if origSig.RecvTypeParams().Len() != rbase.targs.Len() { - m.typ = origSig // or new(Signature), but we can't use Typ[Invalid]: Funcs must have Signature type - return // error reported elsewhere - } - - smap := makeSubstMap(origSig.RecvTypeParams().list(), rbase.targs.list()) - sig := check.subst(orig.pos, origSig, smap, ctxt).(*Signature) - if sig == origSig { - // No substitution occurred, but we still need to create a new signature to - // hold the instantiated receiver. - copy := *origSig - sig = © - } - var rtyp Type - if m.hasPtrRecv() { - rtyp = NewPointer(rbase) - } else { - rtyp = rbase - } - sig.recv = NewParam(origSig.recv.pos, origSig.recv.pkg, origSig.recv.name, rtyp) - - m.typ = sig + return n.orig.tparams, underlying, mlist } // safeUnderlying returns the underlying of typ without expanding instances, to diff --git a/src/cmd/compile/internal/types2/object.go b/src/cmd/compile/internal/types2/object.go index c7c64ca9d5..08d37cb256 100644 --- a/src/cmd/compile/internal/types2/object.go +++ b/src/cmd/compile/internal/types2/object.go @@ -281,7 +281,7 @@ func NewTypeName(pos syntax.Pos, pkg *Package, name string, typ Type) *TypeName func NewTypeNameLazy(pos syntax.Pos, pkg *Package, name string, load func(named *Named) (tparams []*TypeParam, underlying Type, methods []*Func)) *TypeName { obj := NewTypeName(pos, pkg, name, nil) - resolve := func(_ *Context, t *Named) (*TypeParamList, Type, []*Func) { + resolve := func(_ *Context, t *Named) (*TypeParamList, Type, *methodList) { tparams, underlying, methods := load(t) switch underlying.(type) { @@ -289,7 +289,7 @@ func NewTypeNameLazy(pos syntax.Pos, pkg *Package, name string, load func(named panic(fmt.Sprintf("invalid underlying type %T", t.underlying)) } - return bindTParams(tparams), underlying, methods + return bindTParams(tparams), underlying, newMethodList(methods) } NewNamed(obj, nil, nil).resolver = resolve @@ -365,8 +365,7 @@ func (*Var) isDependency() {} // a variable may be a dependency of an initializa // An abstract method may belong to many interfaces due to embedding. type Func struct { object - instRecv *Named // if non-nil, the receiver type for an incomplete instance method - hasPtrRecv_ bool // only valid for methods that don't have a type yet; use hasPtrRecv() to read + hasPtrRecv_ bool // only valid for methods that don't have a type yet; use hasPtrRecv() to read } // NewFunc returns a new function with the given signature, representing @@ -377,7 +376,7 @@ func NewFunc(pos syntax.Pos, pkg *Package, name string, sig *Signature) *Func { if sig != nil { typ = sig } - return &Func{object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}, nil, false} + return &Func{object{nil, pos, pkg, name, typ, 0, colorFor(typ), nopos}, false} } // FullName returns the package- or receiver-type-qualified name of diff --git a/src/cmd/compile/internal/types2/sizeof_test.go b/src/cmd/compile/internal/types2/sizeof_test.go index 52a1df1aa4..14020050a9 100644 --- a/src/cmd/compile/internal/types2/sizeof_test.go +++ b/src/cmd/compile/internal/types2/sizeof_test.go @@ -31,7 +31,7 @@ func TestSizeof(t *testing.T) { {Interface{}, 44, 88}, {Map{}, 16, 32}, {Chan{}, 12, 24}, - {Named{}, 64, 120}, + {Named{}, 56, 104}, {TypeParam{}, 28, 48}, {term{}, 12, 24}, @@ -40,7 +40,7 @@ func TestSizeof(t *testing.T) { {Const{}, 64, 104}, {TypeName{}, 56, 88}, {Var{}, 60, 96}, - {Func{}, 64, 104}, + {Func{}, 60, 96}, {Label{}, 60, 96}, {Builtin{}, 60, 96}, {Nil{}, 56, 88}, diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go index 92c3e642fe..de778fb010 100644 --- a/src/cmd/compile/internal/types2/typexpr.go +++ b/src/cmd/compile/internal/types2/typexpr.go @@ -452,7 +452,7 @@ func (check *Checker) instantiatedType(x syntax.Expr, xlist []syntax.Expr, def * } def.setUnderlying(inst) - inst.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) { + inst.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, *methodList) { tparams := orig.TypeParams().list() inferred := targs diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go index 7986534e78..5c61e54360 100644 --- a/src/go/types/api_test.go +++ b/src/go/types/api_test.go @@ -632,6 +632,11 @@ func TestDefsInfo(t *testing.T) { {`package p3; type x int`, `x`, `type p3.x int`}, {`package p4; func f()`, `f`, `func p4.f()`}, {`package p5; func f() int { x, _ := 1, 2; return x }`, `_`, `var _ int`}, + + // Tests using generics. + {`package generic_g0; type x[T any] int`, `x`, `type generic_g0.x[T any] int`}, + {`package generic_g1; func f[T any]() {}`, `f`, `func generic_g1.f[T any]()`}, + {`package generic_g2; type x[T any] int; func (*x[_]) m() {}`, `m`, `func (*generic_g2.x[_]).m()`}, } for _, test := range tests { @@ -670,6 +675,20 @@ func TestUsesInfo(t *testing.T) { {`package p2; func _() { _ = x }; var x int`, `x`, `var p2.x int`}, {`package p3; func _() { type _ x }; type x int`, `x`, `type p3.x int`}, {`package p4; func _() { _ = f }; func f()`, `f`, `func p4.f()`}, + + // Tests using generics. + {`package generic_g0; func _[T any]() { _ = x }; const x = 42`, `x`, `const generic_g0.x untyped int`}, + {`package generic_g1; func _[T any](x T) { }`, `T`, `type parameter T any`}, + {`package generic_g2; type N[A any] int; var _ N[int]`, `N`, `type generic_g2.N[A any] int`}, + {`package generic_g3; type N[A any] int; func (N[_]) m() {}`, `N`, `type generic_g3.N[A any] int`}, + + // Uses of fields are instantiated. + {`package generic_s1; type N[A any] struct{ a A }; var f = N[int]{}.a`, `a`, `field a int`}, + {`package generic_s1; type N[A any] struct{ a A }; func (r N[B]) m(b B) { r.a = b }`, `a`, `field a B`}, + + // Uses of methods are uses of the instantiated method. + {`package generic_m0; type N[A any] int; func (r N[B]) m() { r.n() }; func (N[C]) n() {}`, `n`, `func (generic_m0.N[B]).n()`}, + {`package generic_m1; type N[A any] int; func (r N[B]) m() { }; var f = N[int].m`, `m`, `func (generic_m1.N[int]).m()`}, } for _, test := range tests { @@ -697,6 +716,90 @@ func TestUsesInfo(t *testing.T) { } } +func TestGenericMethodInfo(t *testing.T) { + src := `package p + +type N[A any] int + +func (r N[B]) m() { r.m(); r.n() } + +func (r *N[C]) n() { } +` + fset := token.NewFileSet() + f, err := parser.ParseFile(fset, "p.go", src, 0) + if err != nil { + t.Fatal(err) + } + info := Info{ + Defs: make(map[*ast.Ident]Object), + Uses: make(map[*ast.Ident]Object), + Selections: make(map[*ast.SelectorExpr]*Selection), + } + var conf Config + pkg, err := conf.Check("p", fset, []*ast.File{f}, &info) + if err != nil { + t.Fatal(err) + } + + N := pkg.Scope().Lookup("N").Type().(*Named) + + // Find the generic methods stored on N. + gm, gn := N.Method(0), N.Method(1) + if gm.Name() == "n" { + gm, gn = gn, gm + } + + // Collect objects from info. + var dm, dn *Func // the declared methods + var dmm, dmn *Func // the methods used in the body of m + for _, decl := range f.Decls { + fdecl, ok := decl.(*ast.FuncDecl) + if !ok { + continue + } + def := info.Defs[fdecl.Name].(*Func) + switch fdecl.Name.Name { + case "m": + dm = def + ast.Inspect(fdecl.Body, func(n ast.Node) bool { + if call, ok := n.(*ast.CallExpr); ok { + sel := call.Fun.(*ast.SelectorExpr) + use := info.Uses[sel.Sel].(*Func) + selection := info.Selections[sel] + if selection.Kind() != MethodVal { + t.Errorf("Selection kind = %v, want %v", selection.Kind(), MethodVal) + } + if selection.Obj() != use { + t.Errorf("info.Selections contains %v, want %v", selection.Obj(), use) + } + switch sel.Sel.Name { + case "m": + dmm = use + case "n": + dmn = use + } + } + return true + }) + case "n": + dn = def + } + } + + if gm != dm { + t.Errorf(`N.Method(...) returns %v for "m", but Info.Defs has %v`, gm, dm) + } + if gn != dn { + t.Errorf(`N.Method(...) returns %v for "m", but Info.Defs has %v`, gm, dm) + } + if dmm != dm { + t.Errorf(`Inside "m", r.m uses %v, want the defined func %v`, dmm, dm) + } + if dmn == dn { + t.Errorf(`Inside "m", r.n uses %v, want a func distinct from %v`, dmm, dm) + } +} + func TestImplicitsInfo(t *testing.T) { testenv.MustHaveGoBuild(t) @@ -717,6 +820,17 @@ func TestImplicitsInfo(t *testing.T) { {`package p8; func f(int) {}`, "field: var int"}, {`package p9; func f() (complex64) { return 0 }`, "field: var complex64"}, {`package p10; type T struct{}; func (*T) f() {}`, "field: var *p10.T"}, + + // Tests using generics. + {`package generic_f0; func f[T any](x int) {}`, ""}, // no Implicits entry + {`package generic_f1; func f[T any](int) {}`, "field: var int"}, + {`package generic_f2; func f[T any](T) {}`, "field: var T"}, + {`package generic_f3; func f[T any]() (complex64) { return 0 }`, "field: var complex64"}, + {`package generic_f4; func f[T any](t T) (T) { return t }`, "field: var T"}, + {`package generic_t0; type T[A any] struct{}; func (*T[_]) f() {}`, "field: var *generic_t0.T[_]"}, + {`package generic_t1; type T[A any] struct{}; func _(x interface{}) { switch t := x.(type) { case T[int]: _ = t } }`, "caseClause: var t generic_t1.T[int]"}, + {`package generic_t2; type T[A any] struct{}; func _[P any](x interface{}) { switch t := x.(type) { case T[P]: _ = t } }`, "caseClause: var t generic_t2.T[P]"}, + {`package generic_t3; func _[P any](x interface{}) { switch t := x.(type) { case P: _ = t } }`, "caseClause: var t P"}, } for _, test := range tests { diff --git a/src/go/types/decl.go b/src/go/types/decl.go index 3fc4487309..cd6f709a56 100644 --- a/src/go/types/decl.go +++ b/src/go/types/decl.go @@ -65,12 +65,6 @@ func (check *Checker) objDecl(obj Object, def *Named) { }() } - // Funcs with m.instRecv set have not yet be completed. Complete them now - // so that they have a type when objDecl exits. - if m, _ := obj.(*Func); m != nil && m.instRecv != nil { - check.completeMethod(nil, m) - } - // Checking the declaration of obj means inferring its type // (and possibly its value, for constants). // An object's type (and thus the object) may be in one of @@ -719,6 +713,7 @@ func (check *Checker) collectMethods(obj *TypeName) { // and field names must be distinct." base, _ := obj.typ.(*Named) // shouldn't fail but be conservative if base != nil { + assert(base.targs.Len() == 0) // collectMethods should not be called on an instantiated type u := base.under() if t, _ := u.(*Struct); t != nil { for _, fld := range t.fields { @@ -731,7 +726,8 @@ func (check *Checker) collectMethods(obj *TypeName) { // Checker.Files may be called multiple times; additional package files // may add methods to already type-checked types. Add pre-existing methods // so that we can detect redeclarations. - for _, m := range base.methods { + for i := 0; i < base.methods.Len(); i++ { + m := base.methods.At(i, nil) assert(m.name != "_") assert(mset.insert(m) == nil) } @@ -757,7 +753,7 @@ func (check *Checker) collectMethods(obj *TypeName) { if base != nil { base.resolve(nil) // TODO(mdempsky): Probably unnecessary. - base.methods = append(base.methods, m) + base.AddMethod(m) } } } diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go index 1a0823575b..dc1c2029bc 100644 --- a/src/go/types/instantiate.go +++ b/src/go/types/instantiate.go @@ -78,7 +78,7 @@ func (check *Checker) instance(pos token.Pos, orig Type, targs []Type, ctxt *Con tname := NewTypeName(pos, orig.obj.pkg, orig.obj.name, nil) named := check.newNamed(tname, orig, nil, nil, nil) // underlying, tparams, and methods are set when named is resolved named.targs = newTypeList(targs) - named.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) { + named.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, *methodList) { return expandNamed(ctxt, n, pos) } res = named diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go index cc6be7493c..8198b058bd 100644 --- a/src/go/types/lookup.go +++ b/src/go/types/lookup.go @@ -142,7 +142,7 @@ func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (o // look for a matching attached method named.resolve(nil) - if i, m := lookupMethod(named.methods, pkg, name); m != nil { + if i, m := named.lookupMethod(pkg, name); m != nil { // potential match // caution: method may not have a proper signature yet index = concat(e.index, i) diff --git a/src/go/types/methodlist.go b/src/go/types/methodlist.go new file mode 100644 index 0000000000..10a2a323a8 --- /dev/null +++ b/src/go/types/methodlist.go @@ -0,0 +1,78 @@ +// Copyright 2022 The Go 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 "sync" + +// methodList holds a list of methods that may be lazily resolved by a provided +// resolution method. +type methodList struct { + methods []*Func + + // guards synchronizes the instantiation of lazy methods. For lazy method + // lists, guards is non-nil and of the length passed to newLazyMethodList. + // For non-lazy method lists, guards is nil. + guards *[]sync.Once +} + +// newMethodList creates a non-lazy method list holding the given methods. +func newMethodList(methods []*Func) *methodList { + return &methodList{methods: methods} +} + +// newLazyMethodList creates a lazy method list of the given length. Methods +// may be resolved lazily for a given index by providing a resolver function. +func newLazyMethodList(length int) *methodList { + guards := make([]sync.Once, length) + return &methodList{ + methods: make([]*Func, length), + guards: &guards, + } +} + +// isLazy reports whether the receiver is a lazy method list. +func (l *methodList) isLazy() bool { + return l != nil && l.guards != nil +} + +// Add appends a method to the method list if not not already present. Add +// panics if the receiver is lazy. +func (l *methodList) Add(m *Func) { + assert(!l.isLazy()) + if i, _ := lookupMethod(l.methods, m.pkg, m.name); i < 0 { + l.methods = append(l.methods, m) + } +} + +// Lookup looks up the method identified by pkg and name in the receiver. +// Lookup panics if the receiver is lazy. +func (l *methodList) Lookup(pkg *Package, name string) (int, *Func) { + assert(!l.isLazy()) + if l == nil { + return -1, nil + } + return lookupMethod(l.methods, pkg, name) +} + +// Len returns the length of the method list. +func (l *methodList) Len() int { + if l == nil { + return 0 + } + return len(l.methods) +} + +// At returns the i'th method of the method list. At panics if i is out of +// bounds, or if the receiver is lazy and resolve is nil. +func (l *methodList) At(i int, resolve func() *Func) *Func { + if !l.isLazy() { + return l.methods[i] + } + assert(resolve != nil) + (*l.guards)[i].Do(func() { + l.methods[i] = resolve() + }) + return l.methods[i] +} diff --git a/src/go/types/methodlist_test.go b/src/go/types/methodlist_test.go new file mode 100644 index 0000000000..e628bce767 --- /dev/null +++ b/src/go/types/methodlist_test.go @@ -0,0 +1,41 @@ +// Copyright 2022 The Go 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 ( + "go/token" + "testing" +) + +func TestLazyMethodList(t *testing.T) { + l := newLazyMethodList(2) + + if got := l.Len(); got != 2 { + t.Fatalf("Len() = %d, want 2", got) + } + + f0 := NewFunc(token.NoPos, nil, "f0", nil) + f1 := NewFunc(token.NoPos, nil, "f1", nil) + + // Verify that methodList.At is idempotent, by calling it repeatedly with a + // resolve func that returns different pointer values (f0 or f1). + steps := []struct { + index int + resolve *Func // the *Func returned by the resolver + want *Func // the actual *Func returned by methodList.At + }{ + {0, f0, f0}, + {0, f1, f0}, + {1, f1, f1}, + {1, f0, f1}, + } + + for i, step := range steps { + got := l.At(step.index, func() *Func { return step.resolve }) + if got != step.want { + t.Errorf("step %d: At(%d, ...) = %s, want %s", i, step.index, got.Name(), step.want.Name()) + } + } +} diff --git a/src/go/types/methodset.go b/src/go/types/methodset.go index 5c3bc39271..c1d1e93e59 100644 --- a/src/go/types/methodset.go +++ b/src/go/types/methodset.go @@ -125,7 +125,9 @@ func NewMethodSet(T Type) *MethodSet { } seen[named] = true - mset = mset.add(named.methods, e.index, e.indirect, e.multiples) + for i := 0; i < named.NumMethods(); i++ { + mset = mset.addOne(named.Method(i), concat(e.index, i), e.indirect, e.multiples) + } } switch t := under(typ).(type) { @@ -214,23 +216,28 @@ func (s methodSet) add(list []*Func, index []int, indirect bool, multiples bool) if len(list) == 0 { return s } - if s == nil { - s = make(methodSet) - } for i, f := range list { - key := f.Id() - // if f is not in the set, add it - if !multiples { - // TODO(gri) A found method may not be added because it's not in the method set - // (!indirect && f.hasPtrRecv()). A 2nd method on the same level may be in the method - // set and may not collide with the first one, thus leading to a false positive. - // Is that possible? Investigate. - if _, found := s[key]; !found && (indirect || !f.hasPtrRecv()) { - s[key] = &Selection{MethodVal, nil, f, concat(index, i), indirect} - continue - } - } - s[key] = nil // collision + s = s.addOne(f, concat(index, i), indirect, multiples) } return s } + +func (s methodSet) addOne(f *Func, index []int, indirect bool, multiples bool) methodSet { + if s == nil { + s = make(methodSet) + } + key := f.Id() + // if f is not in the set, add it + if !multiples { + // TODO(gri) A found method may not be added because it's not in the method set + // (!indirect && f.hasPtrRecv()). A 2nd method on the same level may be in the method + // set and may not collide with the first one, thus leading to a false positive. + // Is that possible? Investigate. + if _, found := s[key]; !found && (indirect || !f.hasPtrRecv()) { + s[key] = &Selection{MethodVal, nil, f, index, indirect} + return s + } + } + s[key] = nil // collision + return s +} diff --git a/src/go/types/named.go b/src/go/types/named.go index f0c22d29e3..a9d1eab24b 100644 --- a/src/go/types/named.go +++ b/src/go/types/named.go @@ -18,10 +18,16 @@ type Named struct { underlying Type // possibly a *Named during setup; never a *Named once set up completely tparams *TypeParamList // type parameters, or nil targs *TypeList // type arguments (after instantiation), or nil - methods []*Func // methods declared for this type (not the method set of this type); signatures are type-checked lazily + + // methods declared for this type (not the method set of this type). + // Signatures are type-checked lazily. + // For non-instantiated types, this is a fully populated list of methods. For + // instantiated types, this is a 'lazy' list, and methods are instantiated + // when they are first accessed. + methods *methodList // resolver may be provided to lazily resolve type parameters, underlying, and methods. - resolver func(*Context, *Named) (tparams *TypeParamList, underlying Type, methods []*Func) + resolver func(*Context, *Named) (tparams *TypeParamList, underlying Type, methods *methodList) once sync.Once // ensures that tparams, underlying, and methods are resolved before accessing } @@ -32,7 +38,7 @@ func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named { if _, ok := underlying.(*Named); ok { panic("underlying type must not be *Named") } - return (*Checker)(nil).newNamed(obj, nil, underlying, nil, methods) + return (*Checker)(nil).newNamed(obj, nil, underlying, nil, newMethodList(methods)) } func (t *Named) resolve(ctxt *Context) *Named { @@ -56,7 +62,7 @@ func (t *Named) resolve(ctxt *Context) *Named { } // newNamed is like NewNamed but with a *Checker receiver and additional orig argument. -func (check *Checker) newNamed(obj *TypeName, orig *Named, underlying Type, tparams *TypeParamList, methods []*Func) *Named { +func (check *Checker) newNamed(obj *TypeName, orig *Named, underlying Type, tparams *TypeParamList, methods *methodList) *Named { typ := &Named{check: check, obj: obj, orig: orig, fromRHS: underlying, underlying: underlying, tparams: tparams, methods: methods} if typ.orig == nil { typ.orig = typ @@ -99,10 +105,72 @@ func (t *Named) SetTypeParams(tparams []*TypeParam) { func (t *Named) TypeArgs() *TypeList { return t.targs } // NumMethods returns the number of explicit methods whose receiver is named type t. -func (t *Named) NumMethods() int { return len(t.resolve(nil).methods) } +func (t *Named) NumMethods() int { return t.resolve(nil).methods.Len() } // Method returns the i'th method of named type t for 0 <= i < t.NumMethods(). -func (t *Named) Method(i int) *Func { return t.resolve(nil).methods[i] } +func (t *Named) Method(i int) *Func { + t.resolve(nil) + return t.methods.At(i, func() *Func { + return t.instantiateMethod(i) + }) +} + +// instiateMethod instantiates the i'th method for an instantiated receiver. +func (t *Named) instantiateMethod(i int) *Func { + assert(t.TypeArgs().Len() > 0) // t must be an instance + + // t.orig.methods is not lazy. origm is the method instantiated with its + // receiver type parameters (the "origin" method). + origm := t.orig.Method(i) + assert(origm != nil) + + check := t.check + // Ensure that the original method is type-checked. + if check != nil { + check.objDecl(origm, nil) + } + + origSig := origm.typ.(*Signature) + rbase, _ := deref(origSig.Recv().Type()) + + // If rbase is t, then origm is already the instantiated method we're looking + // for. In this case, we return origm to preserve the invariant that + // traversing Method->Receiver Type->Method should get back to the same + // method. + // + // This occurs if t is instantiated with the receiver type parameters, as in + // the use of m in func (r T[_]) m() { r.m() }. + if rbase == t { + return origm + } + + sig := origSig + // We can only substitute if we have a correspondence between type arguments + // and type parameters. This check is necessary in the presence of invalid + // code. + if origSig.RecvTypeParams().Len() == t.targs.Len() { + ctxt := check.bestContext(nil) + smap := makeSubstMap(origSig.RecvTypeParams().list(), t.targs.list()) + sig = check.subst(origm.pos, origSig, smap, ctxt).(*Signature) + } + + if sig == origSig { + // No substitution occurred, but we still need to create a new signature to + // hold the instantiated receiver. + copy := *origSig + sig = © + } + + var rtyp Type + if origm.hasPtrRecv() { + rtyp = NewPointer(t) + } else { + rtyp = t + } + + sig.recv = NewParam(origSig.recv.pos, origSig.recv.pkg, origSig.recv.name, rtyp) + return NewFunc(origm.pos, origm.pkg, origm.name, sig) +} // SetUnderlying sets the underlying type and marks t as complete. // t must not have type arguments. @@ -125,9 +193,10 @@ func (t *Named) SetUnderlying(underlying Type) { func (t *Named) AddMethod(m *Func) { assert(t.targs.Len() == 0) t.resolve(nil) - if i, _ := lookupMethod(t.methods, m.pkg, m.name); i < 0 { - t.methods = append(t.methods, m) + if t.methods == nil { + t.methods = newMethodList(nil) } + t.methods.Add(m) } func (t *Named) Underlying() Type { return t.resolve(nil).underlying } @@ -230,6 +299,19 @@ func (n *Named) setUnderlying(typ Type) { } } +func (n *Named) lookupMethod(pkg *Package, name string) (int, *Func) { + n.resolve(nil) + // If n is an instance, we may not have yet instantiated all of its methods. + // Look up the method index in orig, and only instantiate method at the + // matching index (if any). + i, _ := n.orig.methods.Lookup(pkg, name) + if i < 0 { + return -1, nil + } + // For instances, m.Method(i) will be different from the orig method. + return i, n.Method(i) +} + // bestContext returns the best available context. In order of preference: // - the given ctxt, if non-nil // - check.ctxt, if check is non-nil @@ -249,7 +331,7 @@ func (check *Checker) bestContext(ctxt *Context) *Context { // expandNamed ensures that the underlying type of n is instantiated. // The underlying type will be Typ[Invalid] if there was an error. -func expandNamed(ctxt *Context, n *Named, instPos token.Pos) (tparams *TypeParamList, underlying Type, methods []*Func) { +func expandNamed(ctxt *Context, n *Named, instPos token.Pos) (tparams *TypeParamList, underlying Type, methods *methodList) { n.orig.resolve(ctxt) assert(n.orig.underlying != nil) @@ -271,80 +353,13 @@ func expandNamed(ctxt *Context, n *Named, instPos token.Pos) (tparams *TypeParam smap := makeSubstMap(n.orig.tparams.list(), n.targs.list()) underlying = n.check.subst(instPos, n.orig.underlying, smap, ctxt) - - for i := 0; i < n.orig.NumMethods(); i++ { - origm := n.orig.Method(i) - - // During type checking origm may not have a fully set up type, so defer - // instantiation of its signature until later. - m := NewFunc(origm.pos, origm.pkg, origm.name, nil) - m.hasPtrRecv_ = origm.hasPtrRecv() - // Setting instRecv here allows us to complete later (we need the - // instRecv to get targs and the original method). - m.instRecv = n - - methods = append(methods, m) - } } else { underlying = Typ[Invalid] } - // Methods should not escape the type checker API without being completed. If - // we're in the context of a type checking pass, we need to defer this until - // later (not all methods may have types). - completeMethods := func() { - for _, m := range methods { - if m.instRecv != nil { - check.completeMethod(ctxt, m) - } - } - } - if check != nil { - check.later(completeMethods) - } else { - completeMethods() - } + mlist := newLazyMethodList(n.orig.methods.Len()) - return n.orig.tparams, underlying, methods -} - -func (check *Checker) completeMethod(ctxt *Context, m *Func) { - assert(m.instRecv != nil) - rbase := m.instRecv - m.instRecv = nil - m.setColor(black) - - assert(rbase.TypeArgs().Len() > 0) - - // Look up the original method. - _, orig := lookupMethod(rbase.orig.methods, rbase.obj.pkg, m.name) - assert(orig != nil) - if check != nil { - check.objDecl(orig, nil) - } - origSig := orig.typ.(*Signature) - if origSig.RecvTypeParams().Len() != rbase.targs.Len() { - m.typ = origSig // or new(Signature), but we can't use Typ[Invalid]: Funcs must have Signature type - return // error reported elsewhere - } - - smap := makeSubstMap(origSig.RecvTypeParams().list(), rbase.targs.list()) - sig := check.subst(orig.pos, origSig, smap, ctxt).(*Signature) - if sig == origSig { - // No substitution occurred, but we still need to create a new signature to - // hold the instantiated receiver. - copy := *origSig - sig = © - } - var rtyp Type - if m.hasPtrRecv() { - rtyp = NewPointer(rbase) - } else { - rtyp = rbase - } - sig.recv = NewParam(origSig.recv.pos, origSig.recv.pkg, origSig.recv.name, rtyp) - - m.typ = sig + return n.orig.tparams, underlying, mlist } // safeUnderlying returns the underlying of typ without expanding instances, to diff --git a/src/go/types/object.go b/src/go/types/object.go index cf05384a87..fb377002aa 100644 --- a/src/go/types/object.go +++ b/src/go/types/object.go @@ -235,7 +235,7 @@ func NewTypeName(pos token.Pos, pkg *Package, name string, typ Type) *TypeName { func _NewTypeNameLazy(pos token.Pos, pkg *Package, name string, load func(named *Named) (tparams []*TypeParam, underlying Type, methods []*Func)) *TypeName { obj := NewTypeName(pos, pkg, name, nil) - resolve := func(_ *Context, t *Named) (*TypeParamList, Type, []*Func) { + resolve := func(_ *Context, t *Named) (*TypeParamList, Type, *methodList) { tparams, underlying, methods := load(t) switch underlying.(type) { @@ -243,7 +243,7 @@ func _NewTypeNameLazy(pos token.Pos, pkg *Package, name string, load func(named panic(fmt.Sprintf("invalid underlying type %T", t.underlying)) } - return bindTParams(tparams), underlying, methods + return bindTParams(tparams), underlying, newMethodList(methods) } NewNamed(obj, nil, nil).resolver = resolve @@ -319,8 +319,7 @@ func (*Var) isDependency() {} // a variable may be a dependency of an initializa // An abstract method may belong to many interfaces due to embedding. type Func struct { object - instRecv *Named // if non-nil, the receiver type for an incomplete instance method - hasPtrRecv_ bool // only valid for methods that don't have a type yet; use hasPtrRecv() to read + hasPtrRecv_ bool // only valid for methods that don't have a type yet; use hasPtrRecv() to read } // NewFunc returns a new function with the given signature, representing @@ -331,7 +330,7 @@ func NewFunc(pos token.Pos, pkg *Package, name string, sig *Signature) *Func { if sig != nil { typ = sig } - return &Func{object{nil, pos, pkg, name, typ, 0, colorFor(typ), token.NoPos}, nil, false} + return &Func{object{nil, pos, pkg, name, typ, 0, colorFor(typ), token.NoPos}, false} } // FullName returns the package- or receiver-type-qualified name of diff --git a/src/go/types/sizeof_test.go b/src/go/types/sizeof_test.go index b78099d0d0..bfd14a8109 100644 --- a/src/go/types/sizeof_test.go +++ b/src/go/types/sizeof_test.go @@ -30,7 +30,7 @@ func TestSizeof(t *testing.T) { {Interface{}, 44, 88}, {Map{}, 16, 32}, {Chan{}, 12, 24}, - {Named{}, 64, 120}, + {Named{}, 56, 104}, {TypeParam{}, 28, 48}, {term{}, 12, 24}, @@ -39,7 +39,7 @@ func TestSizeof(t *testing.T) { {Const{}, 48, 88}, {TypeName{}, 40, 72}, {Var{}, 44, 80}, - {Func{}, 48, 88}, + {Func{}, 44, 80}, {Label{}, 44, 80}, {Builtin{}, 44, 80}, {Nil{}, 40, 72}, diff --git a/src/go/types/typexpr.go b/src/go/types/typexpr.go index 52966bb047..00c250b5b6 100644 --- a/src/go/types/typexpr.go +++ b/src/go/types/typexpr.go @@ -437,7 +437,7 @@ func (check *Checker) instantiatedType(ix *typeparams.IndexExpr, def *Named) (re } def.setUnderlying(inst) - inst.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, []*Func) { + inst.resolver = func(ctxt *Context, n *Named) (*TypeParamList, Type, *methodList) { tparams := orig.TypeParams().list() inferred := targs From 38729cff96ad38b2d5b530c1009ff0403ebff903 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 24 Jan 2022 17:49:11 -0800 Subject: [PATCH 698/752] go/types, types2: all interfaces implement comparable (add tests) For #50646. Change-Id: I7420545556e0df2659836364a62ce2c32ad7a8b1 Reviewed-on: https://go-review.googlesource.com/c/go/+/380654 Trust: Robert Griesemer Reviewed-by: Robert Findley --- .../compile/internal/types2/issues_test.go | 27 +++++++++++++ .../types2/testdata/fixedbugs/issue50646.go2 | 29 ++++++++++++++ src/go/types/issues_test.go | 27 +++++++++++++ .../types/testdata/fixedbugs/issue50646.go2 | 29 ++++++++++++++ test/typeparam/issue50646.go | 39 +++++++++++++++++++ 5 files changed, 151 insertions(+) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50646.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50646.go2 create mode 100644 test/typeparam/issue50646.go diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go index 9890b79323..6b64251118 100644 --- a/src/cmd/compile/internal/types2/issues_test.go +++ b/src/cmd/compile/internal/types2/issues_test.go @@ -611,3 +611,30 @@ func TestIssue43124(t *testing.T) { t.Errorf("type checking error for c does not disambiguate package template: %q", err) } } + +func TestIssue50646(t *testing.T) { + anyType := Universe.Lookup("any").Type() + comparableType := Universe.Lookup("comparable").Type() + + if !Comparable(anyType) { + t.Errorf("any is not a comparable type") + } + if !Comparable(comparableType) { + t.Errorf("comparable is not a comparable type") + } + + // TODO(gri) should comparable be an alias, like any? (see #50791) + if !Implements(anyType, comparableType.Underlying().(*Interface)) { + t.Errorf("any does not implement comparable") + } + if !Implements(comparableType, anyType.(*Interface)) { + t.Errorf("comparable does not implement any") + } + + if !AssignableTo(anyType, comparableType) { + t.Errorf("any not assignable to comparable") + } + if !AssignableTo(comparableType, anyType) { + t.Errorf("comparable not assignable to any") + } +} diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50646.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50646.go2 new file mode 100644 index 0000000000..6e8419f247 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50646.go2 @@ -0,0 +1,29 @@ +// Copyright 2022 The Go 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 + +// Because we can use == and != with values of arbitrary +// interfaces, all interfaces implement comparable. + +func f1[_ comparable]() {} +func f2[_ interface{ comparable }]() {} + +type T interface{ m() } + +func _[P comparable, Q ~int, R any]() { + _ = f1[int] + _ = f1[T] + _ = f1[any] + _ = f1[P] + _ = f1[Q] + _ = f1[R /* ERROR R does not implement comparable */] + + _ = f2[int] + _ = f2[T] + _ = f2[any] + _ = f2[P] + _ = f2[Q] + _ = f2[R /* ERROR R does not implement comparable */] +} diff --git a/src/go/types/issues_test.go b/src/go/types/issues_test.go index 51995af30a..613ced92ed 100644 --- a/src/go/types/issues_test.go +++ b/src/go/types/issues_test.go @@ -638,3 +638,30 @@ var _ T = template /* ERROR cannot use.*text/template.* as T value */.Template{} testFiles(t, nil, []string{"c.go"}, [][]byte{[]byte(csrc)}, false, imp) testFiles(t, nil, []string{"t.go"}, [][]byte{[]byte(tsrc)}, false, imp) } + +func TestIssue50646(t *testing.T) { + anyType := Universe.Lookup("any").Type() + comparableType := Universe.Lookup("comparable").Type() + + if !Comparable(anyType) { + t.Errorf("any is not a comparable type") + } + if !Comparable(comparableType) { + t.Errorf("comparable is not a comparable type") + } + + // TODO(gri) should comparable be an alias, like any? (see #50791) + if !Implements(anyType, comparableType.Underlying().(*Interface)) { + t.Errorf("any does not implement comparable") + } + if !Implements(comparableType, anyType.(*Interface)) { + t.Errorf("comparable does not implement any") + } + + if !AssignableTo(anyType, comparableType) { + t.Errorf("any not assignable to comparable") + } + if !AssignableTo(comparableType, anyType) { + t.Errorf("comparable not assignable to any") + } +} diff --git a/src/go/types/testdata/fixedbugs/issue50646.go2 b/src/go/types/testdata/fixedbugs/issue50646.go2 new file mode 100644 index 0000000000..6e8419f247 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50646.go2 @@ -0,0 +1,29 @@ +// Copyright 2022 The Go 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 + +// Because we can use == and != with values of arbitrary +// interfaces, all interfaces implement comparable. + +func f1[_ comparable]() {} +func f2[_ interface{ comparable }]() {} + +type T interface{ m() } + +func _[P comparable, Q ~int, R any]() { + _ = f1[int] + _ = f1[T] + _ = f1[any] + _ = f1[P] + _ = f1[Q] + _ = f1[R /* ERROR R does not implement comparable */] + + _ = f2[int] + _ = f2[T] + _ = f2[any] + _ = f2[P] + _ = f2[Q] + _ = f2[R /* ERROR R does not implement comparable */] +} diff --git a/test/typeparam/issue50646.go b/test/typeparam/issue50646.go new file mode 100644 index 0000000000..44bbe2ae6f --- /dev/null +++ b/test/typeparam/issue50646.go @@ -0,0 +1,39 @@ +// run -gcflags=-G=3 + +// Copyright 2022 The Go 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 eql[P comparable](x, y P) { + if x != y { + panic("not equal") + } +} + +func expectPanic(f func()) { + defer func() { + if recover() == nil { + panic("function succeeded unexpectedly") + } + }() + f() +} + +func main() { + eql[int](1, 1) + eql(1, 1) + + // all interfaces implement comparable + var x, y any = 2, 2 + eql[any](x, y) + eql(x, y) + + // but we may get runtime panics + x, y = 1, 2 // x != y + expectPanic(func() { eql(x, y) }) + + x, y = main, main // functions are not comparable + expectPanic(func() { eql(x, y) }) +} From 6eb58cdffa1ab334493776a25ccccfa89c2ca7ac Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Tue, 25 Jan 2022 17:31:52 -0500 Subject: [PATCH 699/752] all: update vendored golang.org/x/tools Update the vendored x/tools to pick up CL 380014, which updates the ifaceassert vet analyzer to remove spurious errors for assertions involving interfaces with type parameters. This also picks up some superficial changes related to refactoring of the x/tools/internal/typeparams API. The following commands were used: go get -d golang.org/x/tools@master go mod tidy go mod vendor Fixes #50658 Change-Id: I2f612fd186a1a260cab21860b192c9f6dc3f560f Reviewed-on: https://go-review.googlesource.com/c/go/+/380777 Trust: Robert Findley Run-TryBot: Dmitri Shuralyov Reviewed-by: Dmitri Shuralyov TryBot-Result: Gopher Robot Reviewed-by: Tim King --- src/cmd/go.mod | 2 +- src/cmd/go.sum | 4 +- .../passes/ifaceassert/ifaceassert.go | 6 + .../passes/ifaceassert/parameterized.go | 112 ++++++++++++++++++ .../go/analysis/passes/nilfunc/nilfunc.go | 3 +- .../testinggoroutine/testinggoroutine.go | 7 +- .../passes/unusedresult/unusedresult.go | 6 +- .../x/tools/go/types/typeutil/callee.go | 3 +- .../x/tools/internal/lsp/fuzzy/symbol.go | 26 ++-- .../x/tools/internal/typeparams/common.go | 71 +++++++++-- .../internal/typeparams/typeparams_go117.go | 32 ----- .../internal/typeparams/typeparams_go118.go | 50 -------- src/cmd/vendor/modules.txt | 2 +- 13 files changed, 208 insertions(+), 116 deletions(-) create mode 100644 src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ifaceassert/parameterized.go diff --git a/src/cmd/go.mod b/src/cmd/go.mod index 6684fbf95d..48fc888f94 100644 --- a/src/cmd/go.mod +++ b/src/cmd/go.mod @@ -8,7 +8,7 @@ require ( golang.org/x/mod v0.6.0-dev.0.20211102181907-3a5865c02020 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 - golang.org/x/tools v0.1.9-0.20211207220608-fd2bfb79a16a + golang.org/x/tools v0.1.9-0.20220124164225-97de9ec46646 ) require ( diff --git a/src/cmd/go.sum b/src/cmd/go.sum index 9e20235497..4a5479f881 100644 --- a/src/cmd/go.sum +++ b/src/cmd/go.sum @@ -18,7 +18,7 @@ golang.org/x/sys v0.0.0-20211205182925-97ca703d548d h1:FjkYO/PPp4Wi0EAUOVLxePm7q golang.org/x/sys v0.0.0-20211205182925-97ca703d548d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/tools v0.1.9-0.20211207220608-fd2bfb79a16a h1:G+TZ7v63o8mn+LBWOdnHaiypIhcgFZ6BDDnyX+RXDYg= -golang.org/x/tools v0.1.9-0.20211207220608-fd2bfb79a16a/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= +golang.org/x/tools v0.1.9-0.20220124164225-97de9ec46646 h1:f8aekWvlQQ8ZhD8SL7lOu18dtWslZYl029PN2F0VnS4= +golang.org/x/tools v0.1.9-0.20220124164225-97de9ec46646/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ifaceassert/ifaceassert.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ifaceassert/ifaceassert.go index fd2285332c..30130f63ea 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ifaceassert/ifaceassert.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ifaceassert/ifaceassert.go @@ -51,6 +51,12 @@ func assertableTo(v, t types.Type) *types.Func { if V == nil || T == nil { return nil } + + // Mitigations for interface comparisons and generics. + // TODO(https://github.com/golang/go/issues/50658): Support more precise conclusion. + if isParameterized(V) || isParameterized(T) { + return nil + } if f, wrongType := types.MissingMethod(V, T, false); wrongType { return f } diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ifaceassert/parameterized.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ifaceassert/parameterized.go new file mode 100644 index 0000000000..1285ecf136 --- /dev/null +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/ifaceassert/parameterized.go @@ -0,0 +1,112 @@ +// Copyright 2022 The Go 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 ifaceassert + +import ( + "go/types" + + "golang.org/x/tools/internal/typeparams" +) + +// isParameterized reports whether typ contains any of the type parameters of tparams. +// +// NOTE: Adapted from go/types/infer.go. If that is exported in a future release remove this copy. +func isParameterized(typ types.Type) bool { + w := tpWalker{ + seen: make(map[types.Type]bool), + } + return w.isParameterized(typ) +} + +type tpWalker struct { + seen map[types.Type]bool +} + +func (w *tpWalker) isParameterized(typ types.Type) (res bool) { + // detect cycles + if x, ok := w.seen[typ]; ok { + return x + } + w.seen[typ] = false + defer func() { + w.seen[typ] = res + }() + + switch t := typ.(type) { + case nil, *types.Basic: // TODO(gri) should nil be handled here? + break + + case *types.Array: + return w.isParameterized(t.Elem()) + + case *types.Slice: + return w.isParameterized(t.Elem()) + + case *types.Struct: + for i, n := 0, t.NumFields(); i < n; i++ { + if w.isParameterized(t.Field(i).Type()) { + return true + } + } + + case *types.Pointer: + return w.isParameterized(t.Elem()) + + case *types.Tuple: + n := t.Len() + for i := 0; i < n; i++ { + if w.isParameterized(t.At(i).Type()) { + return true + } + } + + case *types.Signature: + // t.tparams may not be nil if we are looking at a signature + // of a generic function type (or an interface method) that is + // part of the type we're testing. We don't care about these type + // parameters. + // Similarly, the receiver of a method may declare (rather then + // use) type parameters, we don't care about those either. + // Thus, we only need to look at the input and result parameters. + return w.isParameterized(t.Params()) || w.isParameterized(t.Results()) + + case *types.Interface: + for i, n := 0, t.NumMethods(); i < n; i++ { + if w.isParameterized(t.Method(i).Type()) { + return true + } + } + terms, err := typeparams.InterfaceTermSet(t) + if err != nil { + panic(err) + } + for _, term := range terms { + if w.isParameterized(term.Type()) { + return true + } + } + + case *types.Map: + return w.isParameterized(t.Key()) || w.isParameterized(t.Elem()) + + case *types.Chan: + return w.isParameterized(t.Elem()) + + case *types.Named: + list := typeparams.NamedTypeArgs(t) + for i, n := 0, list.Len(); i < n; i++ { + if w.isParameterized(list.At(i)) { + return true + } + } + + case *typeparams.TypeParam: + return true + + default: + panic(t) // unreachable + } + + return false +} diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/nilfunc/nilfunc.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/nilfunc/nilfunc.go index 850f6f8fae..e4c66df6d6 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/nilfunc/nilfunc.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/nilfunc/nilfunc.go @@ -62,7 +62,8 @@ func run(pass *analysis.Pass) (interface{}, error) { obj = pass.TypesInfo.Uses[v.Sel] case *ast.IndexExpr, *typeparams.IndexListExpr: // Check generic functions such as "f[T1,T2]". - if id, ok := typeparams.GetIndexExprData(v).X.(*ast.Ident); ok { + x, _, _, _ := typeparams.UnpackIndexExpr(v) + if id, ok := x.(*ast.Ident); ok { obj = pass.TypesInfo.Uses[id] } default: diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go index 3d4bd49085..7ea8f77e33 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/testinggoroutine/testinggoroutine.go @@ -127,11 +127,8 @@ func typeIsTestingDotTOrB(expr ast.Expr) (string, bool) { func goStmtFun(goStmt *ast.GoStmt) ast.Node { switch fun := goStmt.Call.Fun.(type) { case *ast.IndexExpr, *typeparams.IndexListExpr: - ix := typeparams.GetIndexExprData(fun) - if ix == nil { - break - } - id, _ := ix.X.(*ast.Ident) + x, _, _, _ := typeparams.UnpackIndexExpr(fun) + id, _ := x.(*ast.Ident) if id == nil { break } diff --git a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go index fd94508f88..06747ba72b 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go +++ b/src/cmd/vendor/golang.org/x/tools/go/analysis/passes/unusedresult/unusedresult.go @@ -71,9 +71,9 @@ func run(pass *analysis.Pass) (interface{}, error) { return // a conversion, not a call } - index := typeparams.GetIndexExprData(fun) - if index != nil { - fun = index.X // If this is generic function or method call, skip the instantiation arguments + x, _, _, _ := typeparams.UnpackIndexExpr(fun) + if x != nil { + fun = x // If this is generic function or method call, skip the instantiation arguments } selector, ok := fun.(*ast.SelectorExpr) diff --git a/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/callee.go b/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/callee.go index 2b8960332d..90b3ab0e21 100644 --- a/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/callee.go +++ b/src/cmd/vendor/golang.org/x/tools/go/types/typeutil/callee.go @@ -27,8 +27,7 @@ func Callee(info *types.Info, call *ast.CallExpr) types.Object { // it is a *types.Func and not a *types.Var. // Example: Don't match a slice m within the expression `m[0]()`. isInstance = true - ix := typeparams.GetIndexExprData(fun) - fun = ix.X + fun, _, _, _ = typeparams.UnpackIndexExpr(fun) } var obj types.Object diff --git a/src/cmd/vendor/golang.org/x/tools/internal/lsp/fuzzy/symbol.go b/src/cmd/vendor/golang.org/x/tools/internal/lsp/fuzzy/symbol.go index 062f491fb5..df9fbd5141 100644 --- a/src/cmd/vendor/golang.org/x/tools/internal/lsp/fuzzy/symbol.go +++ b/src/cmd/vendor/golang.org/x/tools/internal/lsp/fuzzy/symbol.go @@ -49,11 +49,6 @@ const ( // // Currently this matcher only accepts case-insensitive fuzzy patterns. // -// TODO(rfindley): -// - implement smart-casing -// - implement space-separated groups -// - implement ', ^, and $ modifiers -// // An empty pattern matches no input. func NewSymbolMatcher(pattern string) *SymbolMatcher { m := &SymbolMatcher{} @@ -176,7 +171,12 @@ input: // 1. 1.0 if the character starts a segment, .8 if the character start a // mid-segment word, otherwise 0.6. This carries over to immediately // following characters. - // 2. 1.0 if the character is part of the last segment, otherwise + // 2. For the final character match, the multiplier from (1) is reduced to + // .8 if the next character in the input is a mid-segment word, or 0.6 if + // the next character in the input is not a word or segment start. This + // ensures that we favor whole-word or whole-segment matches over prefix + // matches. + // 3. 1.0 if the character is part of the last segment, otherwise // 1.0-.2*, with a max segment count of 3. // // This is a very naive algorithm, but it is fast. There's lots of prior art @@ -211,8 +211,20 @@ input: case m.roles[ii]&wordStart != 0 && wordStreak > streakBonus: streakBonus = wordStreak } + finalChar := pi >= m.patternLen + // finalCost := 1.0 + if finalChar && streakBonus > noStreak { + switch { + case ii == inputLen-1 || m.roles[ii+1]&segmentStart != 0: + // Full segment: no reduction + case m.roles[ii+1]&wordStart != 0: + streakBonus = wordStreak + default: + streakBonus = noStreak + } + } totScore += streakBonus * (1.0 - float64(m.segments[ii])*perSegment) - if pi >= m.patternLen { + if finalChar { break } } else { diff --git a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/common.go b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/common.go index 961d036fdb..1222764b6a 100644 --- a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/common.go +++ b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/common.go @@ -2,12 +2,25 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// Package typeparams provides functions to work indirectly with type parameter -// data stored in go/ast and go/types objects, while these API are guarded by a -// build constraint. +// Package typeparams contains common utilities for writing tools that interact +// with generic Go code, as introduced with Go 1.18. // -// This package exists to make it easier for tools to work with generic code, -// while also compiling against older Go versions. +// Many of the types and functions in this package are proxies for the new APIs +// introduced in the standard library with Go 1.18. For example, the +// typeparams.Union type is an alias for go/types.Union, and the ForTypeSpec +// function returns the value of the go/ast.TypeSpec.TypeParams field. At Go +// versions older than 1.18 these helpers are implemented as stubs, allowing +// users of this package to write code that handles generic constructs inline, +// even if the Go version being used to compile does not support generics. +// +// Additionally, this package contains common utilities for working with the +// new generic constructs, to supplement the standard library APIs. Notably, +// the StructuralTerms API computes a minimal representation of the structural +// restrictions on a type parameter. In the future, this API may be available +// from go/types. +// +// See the example/README.md for a more detailed guide on how to update tools +// to support generics. package typeparams import ( @@ -16,13 +29,47 @@ import ( "go/types" ) -// A IndexExprData holds data from both ast.IndexExpr and the new -// ast.MultiIndexExpr, which was introduced in Go 1.18. -type IndexExprData struct { - X ast.Expr // expression - Lbrack token.Pos // position of "[" - Indices []ast.Expr // index expressions - Rbrack token.Pos // position of "]" +// UnpackIndexExpr extracts data from AST nodes that represent index +// expressions. +// +// For an ast.IndexExpr, the resulting indices slice will contain exactly one +// index expression. For an ast.IndexListExpr (go1.18+), it may have a variable +// number of index expressions. +// +// For nodes that don't represent index expressions, the first return value of +// UnpackIndexExpr will be nil. +func UnpackIndexExpr(n ast.Node) (x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack token.Pos) { + switch e := n.(type) { + case *ast.IndexExpr: + return e.X, e.Lbrack, []ast.Expr{e.Index}, e.Rbrack + case *IndexListExpr: + return e.X, e.Lbrack, e.Indices, e.Rbrack + } + return nil, token.NoPos, nil, token.NoPos +} + +// PackIndexExpr returns an *ast.IndexExpr or *ast.IndexListExpr, depending on +// the cardinality of indices. Calling PackIndexExpr with len(indices) == 0 +// will panic. +func PackIndexExpr(x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack token.Pos) ast.Expr { + switch len(indices) { + case 0: + panic("empty indices") + case 1: + return &ast.IndexExpr{ + X: x, + Lbrack: lbrack, + Index: indices[0], + Rbrack: rbrack, + } + default: + return &IndexListExpr{ + X: x, + Lbrack: lbrack, + Indices: indices, + Rbrack: rbrack, + } + } } // IsTypeParam reports whether t is a type parameter. diff --git a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go117.go b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go117.go index e509daf7be..5fd3fc3515 100644 --- a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go117.go +++ b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go117.go @@ -17,38 +17,6 @@ func unsupported() { panic("type parameters are unsupported at this go version") } -// GetIndexExprData extracts data from *ast.IndexExpr nodes. -// For other nodes, GetIndexExprData returns nil. -func GetIndexExprData(n ast.Node) *IndexExprData { - if e, _ := n.(*ast.IndexExpr); e != nil { - return &IndexExprData{ - X: e.X, - Lbrack: e.Lbrack, - Indices: []ast.Expr{e.Index}, - Rbrack: e.Rbrack, - } - } - return nil -} - -// PackIndexExpr returns an *ast.IndexExpr with the given index. -// Calling PackIndexExpr with len(indices) != 1 will panic. -func PackIndexExpr(x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack token.Pos) ast.Expr { - switch len(indices) { - case 0: - panic("empty indices") - case 1: - return &ast.IndexExpr{ - X: x, - Lbrack: lbrack, - Index: indices[0], - Rbrack: rbrack, - } - default: - panic("cannot pack multiple indices at this go version") - } -} - // IndexListExpr is a placeholder type, as type parameters are not supported at // this Go version. Its methods panic on use. type IndexListExpr struct { diff --git a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go118.go b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go118.go index e45896fb02..7470aed8c9 100644 --- a/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go118.go +++ b/src/cmd/vendor/golang.org/x/tools/internal/typeparams/typeparams_go118.go @@ -9,59 +9,9 @@ package typeparams import ( "go/ast" - "go/token" "go/types" ) -// GetIndexExprData extracts data from AST nodes that represent index -// expressions. -// -// For an ast.IndexExpr, the resulting IndexExprData will have exactly one -// index expression. For an ast.IndexListExpr (go1.18+), it may have a -// variable number of index expressions. -// -// For nodes that don't represent index expressions, GetIndexExprData returns -// nil. -// TODO(rfindley): remove this function in favor of using the alias below. -func GetIndexExprData(n ast.Node) *IndexExprData { - switch e := n.(type) { - case *ast.IndexExpr: - return &IndexExprData{ - X: e.X, - Lbrack: e.Lbrack, - Indices: []ast.Expr{e.Index}, - Rbrack: e.Rbrack, - } - case *ast.IndexListExpr: - return (*IndexExprData)(e) - } - return nil -} - -// PackIndexExpr returns an *ast.IndexExpr or *ast.IndexListExpr, depending on -// the cardinality of indices. Calling PackIndexExpr with len(indices) == 0 -// will panic. -func PackIndexExpr(x ast.Expr, lbrack token.Pos, indices []ast.Expr, rbrack token.Pos) ast.Expr { - switch len(indices) { - case 0: - panic("empty indices") - case 1: - return &ast.IndexExpr{ - X: x, - Lbrack: lbrack, - Index: indices[0], - Rbrack: rbrack, - } - default: - return &ast.IndexListExpr{ - X: x, - Lbrack: lbrack, - Indices: indices, - Rbrack: rbrack, - } - } -} - // IndexListExpr is an alias for ast.IndexListExpr. type IndexListExpr = ast.IndexListExpr diff --git a/src/cmd/vendor/modules.txt b/src/cmd/vendor/modules.txt index 0762dee8f2..f2cd884b82 100644 --- a/src/cmd/vendor/modules.txt +++ b/src/cmd/vendor/modules.txt @@ -51,7 +51,7 @@ golang.org/x/sys/windows # golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 ## explicit; go 1.17 golang.org/x/term -# golang.org/x/tools v0.1.9-0.20211207220608-fd2bfb79a16a +# golang.org/x/tools v0.1.9-0.20220124164225-97de9ec46646 ## explicit; go 1.17 golang.org/x/tools/cover golang.org/x/tools/go/analysis From 827babf6aa602c76e45fabfdc2efe8d3f30edabd Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 26 Jan 2022 09:50:41 -0500 Subject: [PATCH 700/752] cmd/go: add mv and support "! cmp" in script tests For #50183 Change-Id: Ie384333fb7a69d0d2cfaba0cfc4eb7afba2fd745 Reviewed-on: https://go-review.googlesource.com/c/go/+/380916 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Russ Cox --- src/cmd/go/script_test.go | 57 ++++++++++++++++++++----------- src/cmd/go/testdata/script/README | 13 ++++--- 2 files changed, 47 insertions(+), 23 deletions(-) diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go index 7adbc71a89..0fc4b0f7ab 100644 --- a/src/cmd/go/script_test.go +++ b/src/cmd/go/script_test.go @@ -491,6 +491,7 @@ var scriptCmds = map[string]func(*testScript, simpleStatus, []string){ "go": (*testScript).cmdGo, "grep": (*testScript).cmdGrep, "mkdir": (*testScript).cmdMkdir, + "mv": (*testScript).cmdMv, "rm": (*testScript).cmdRm, "skip": (*testScript).cmdSkip, "stale": (*testScript).cmdStale, @@ -585,10 +586,6 @@ func (ts *testScript) cmdChmod(want simpleStatus, args []string) { // cmp compares two files. func (ts *testScript) cmdCmp(want simpleStatus, args []string) { - if want != success { - // It would be strange to say "this file can have any content except this precise byte sequence". - ts.fatalf("unsupported: %v cmp", want) - } quiet := false if len(args) > 0 && args[0] == "-q" { quiet = true @@ -597,14 +594,11 @@ func (ts *testScript) cmdCmp(want simpleStatus, args []string) { if len(args) != 2 { ts.fatalf("usage: cmp file1 file2") } - ts.doCmdCmp(args, false, quiet) + ts.doCmdCmp(want, args, false, quiet) } // cmpenv compares two files with environment variable substitution. func (ts *testScript) cmdCmpenv(want simpleStatus, args []string) { - if want != success { - ts.fatalf("unsupported: %v cmpenv", want) - } quiet := false if len(args) > 0 && args[0] == "-q" { quiet = true @@ -613,17 +607,18 @@ func (ts *testScript) cmdCmpenv(want simpleStatus, args []string) { if len(args) != 2 { ts.fatalf("usage: cmpenv file1 file2") } - ts.doCmdCmp(args, true, quiet) + ts.doCmdCmp(want, args, true, quiet) } -func (ts *testScript) doCmdCmp(args []string, env, quiet bool) { +func (ts *testScript) doCmdCmp(want simpleStatus, args []string, env, quiet bool) { name1, name2 := args[0], args[1] var text1, text2 string - if name1 == "stdout" { + switch name1 { + case "stdout": text1 = ts.stdout - } else if name1 == "stderr" { + case "stderr": text1 = ts.stderr - } else { + default: data, err := os.ReadFile(ts.mkabs(name1)) ts.check(err) text1 = string(data) @@ -638,14 +633,28 @@ func (ts *testScript) doCmdCmp(args []string, env, quiet bool) { text2 = ts.expand(text2, false) } - if text1 == text2 { - return - } - - if !quiet { + eq := text1 == text2 + if !eq && !quiet && want != failure { fmt.Fprintf(&ts.log, "[diff -%s +%s]\n%s\n", name1, name2, diff(text1, text2)) } - ts.fatalf("%s and %s differ", name1, name2) + switch want { + case failure: + if eq { + ts.fatalf("%s and %s do not differ", name1, name2) + } + case success: + if !eq { + ts.fatalf("%s and %s differ", name1, name2) + } + case successOrFailure: + if eq { + fmt.Fprintf(&ts.log, "%s and %s do not differ", name1, name2) + } else { + fmt.Fprintf(&ts.log, "%s and %s differ", name1, name2) + } + default: + ts.fatalf("unsupported: %v cmp", want) + } } // cp copies files, maybe eventually directories. @@ -840,6 +849,16 @@ func (ts *testScript) cmdMkdir(want simpleStatus, args []string) { } } +func (ts *testScript) cmdMv(want simpleStatus, args []string) { + if want != success { + ts.fatalf("unsupported: %v mv", want) + } + if len(args) != 2 { + ts.fatalf("usage: mv old new") + } + ts.check(os.Rename(ts.mkabs(args[0]), ts.mkabs(args[1]))) +} + // rm removes files or directories. func (ts *testScript) cmdRm(want simpleStatus, args []string) { if want != success { diff --git a/src/cmd/go/testdata/script/README b/src/cmd/go/testdata/script/README index 2b55fa8977..b2a7fd1915 100644 --- a/src/cmd/go/testdata/script/README +++ b/src/cmd/go/testdata/script/README @@ -110,14 +110,15 @@ The commands are: Change the permissions of the files or directories named by the path arguments to be equal to perm. Only numerical permissions are supported. -- cmp file1 file2 - Check that the named files have the same content. +- [! | ?] cmp file1 file2 + Check that the named files have (or do not have) the same content. By convention, file1 is the actual data and file2 the expected data. File1 can be "stdout" or "stderr" to use the standard output or standard error from the most recent exec or go command. - (If the files have differing content, the failure prints a diff.) + (If the file contents differ and the command is not negated, + the failure prints a diff.) -- cmpenv file1 file2 +- [! | ?] cmpenv file1 file2 Like cmp, but environment variables are substituted in the file contents before the comparison. For example, $GOOS is replaced by the target GOOS. @@ -163,6 +164,10 @@ The commands are: - mkdir path... Create the listed directories, if they do not already exists. +- mv path1 path2 + Rename path1 to path2. OS-specific restrictions may apply when path1 and path2 + are in different directories. + - rm file... Remove the listed files or directories. From 5b1b80beb1a2a9a353738e80777d1e25cfdfa095 Mon Sep 17 00:00:00 2001 From: Ethan Anderson Date: Tue, 14 Dec 2021 10:59:06 -0600 Subject: [PATCH 701/752] cmd/go: remove mercurial from bitbucket vcs options Mercurial was deprecated as of July 1, 2020 as per https://bitbucket.org/blog/sunsetting-mercurial-support-in-bitbucket Fixes #50810. Change-Id: I0d40f84aaa393905cae7c4bed8919b15de9a5f6d Reviewed-on: https://go-review.googlesource.com/c/go/+/371720 Trust: Russ Cox Reviewed-by: Bryan Mills Trust: Bryan Mills --- src/cmd/go/internal/vcs/vcs.go | 54 ++--------------------------- src/cmd/go/internal/vcs/vcs_test.go | 7 ++++ 2 files changed, 9 insertions(+), 52 deletions(-) diff --git a/src/cmd/go/internal/vcs/vcs.go b/src/cmd/go/internal/vcs/vcs.go index 36404533c5..3406ee0551 100644 --- a/src/cmd/go/internal/vcs/vcs.go +++ b/src/cmd/go/internal/vcs/vcs.go @@ -6,7 +6,6 @@ package vcs import ( "bytes" - "encoding/json" "errors" "fmt" exec "internal/execabs" @@ -1437,8 +1436,9 @@ var vcsPaths = []*vcsPath{ { pathPrefix: "bitbucket.org", regexp: lazyregexp.New(`^(?Pbitbucket\.org/(?P[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+))(/[A-Za-z0-9_.\-]+)*$`), + vcs: "git", repo: "https://{root}", - check: bitbucketVCS, + check: noVCSSuffix, }, // IBM DevOps Services (JazzHub) @@ -1510,56 +1510,6 @@ func noVCSSuffix(match map[string]string) error { return nil } -// bitbucketVCS determines the version control system for a -// Bitbucket repository, by using the Bitbucket API. -func bitbucketVCS(match map[string]string) error { - if err := noVCSSuffix(match); err != nil { - return err - } - - var resp struct { - SCM string `json:"scm"` - } - url := &urlpkg.URL{ - Scheme: "https", - Host: "api.bitbucket.org", - Path: expand(match, "/2.0/repositories/{bitname}"), - RawQuery: "fields=scm", - } - data, err := web.GetBytes(url) - if err != nil { - if httpErr, ok := err.(*web.HTTPError); ok && httpErr.StatusCode == 403 { - // this may be a private repository. If so, attempt to determine which - // VCS it uses. See issue 5375. - root := match["root"] - for _, vcs := range []string{"git", "hg"} { - if vcsByCmd(vcs).Ping("https", root) == nil { - resp.SCM = vcs - break - } - } - } - - if resp.SCM == "" { - return err - } - } else { - if err := json.Unmarshal(data, &resp); err != nil { - return fmt.Errorf("decoding %s: %v", url, err) - } - } - - if vcsByCmd(resp.SCM) != nil { - match["vcs"] = resp.SCM - if resp.SCM == "git" { - match["repo"] += ".git" - } - return nil - } - - return fmt.Errorf("unable to detect version control system for bitbucket.org/ path") -} - // launchpadVCS solves the ambiguity for "lp.net/project/foo". In this case, // "foo" could be a series name registered in Launchpad with its own branch, // and it could also be the name of a directory within the main project diff --git a/src/cmd/go/internal/vcs/vcs_test.go b/src/cmd/go/internal/vcs/vcs_test.go index c4e4f4d3c6..943d520d54 100644 --- a/src/cmd/go/internal/vcs/vcs_test.go +++ b/src/cmd/go/internal/vcs/vcs_test.go @@ -183,6 +183,13 @@ func TestRepoRootForImportPath(t *testing.T) { "chiselapp.com/user/kyle/fossilgg", nil, }, + { + "bitbucket.org/workspace/pkgname", + &RepoRoot{ + VCS: vcsGit, + Repo: "https://bitbucket.org/workspace/pkgname", + }, + }, } for _, test := range tests { From a9eedc0789085f55193bdbf0d777b8eaeccb1890 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 26 Jan 2022 09:24:25 -0500 Subject: [PATCH 702/752] cmd/go: refactor TestScript/build_issue48319 to check a more general property MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The test previously checked that the DWARF DW_AT_comp_dir attribute matched GOROOT_FINAL. However, on further consideration, we believe that DW_AT_comp_dir should not actually match GOROOT_FINAL: the DWARF spec says that DW_AT_comp_dir records “the current working directory of the compilation command that produced this compilation unit”, but the actual working directory of the compilation command proper is a throwaway directory in the build cache — it is neither stable nor meaningful. However, the test was getting at a real issue that we do care about: namely, that the binary produced by a 'go build' command with cgo enabled should not reuse a dependency that embeds a stale GOROOT_FINAL. This change refactors the test to verify the latter property instead of checking DW_AT_comp_dir specifically. For #50183 Updates #48319 Change-Id: I0b1151d9ba3d0ff903f72e27850306406e5cb518 Reviewed-on: https://go-review.googlesource.com/c/go/+/380914 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Russ Cox TryBot-Result: Gopher Robot --- .../go/testdata/script/build_issue48319.txt | 156 +++--------------- 1 file changed, 25 insertions(+), 131 deletions(-) diff --git a/src/cmd/go/testdata/script/build_issue48319.txt b/src/cmd/go/testdata/script/build_issue48319.txt index f58a5faa3f..3979247f2f 100644 --- a/src/cmd/go/testdata/script/build_issue48319.txt +++ b/src/cmd/go/testdata/script/build_issue48319.txt @@ -1,50 +1,33 @@ +# Regression test for https://go.dev/issue/48319: +# cgo builds should not include debug information from a stale GOROOT_FINAL. + [short] skip [!cgo] skip +[windows] skip # The Go Windows builders have an extremely out-of-date gcc that does not support reproducible builds; see https://go.dev/issue/50824. -# Set up fresh GOCACHE +# This test is sensitive to cache invalidation, +# so use a separate build cache that we can control. env GOCACHE=$WORK/gocache mkdir $GOCACHE -# 1. unset GOROOT_FINAL, Build a simple binary with cgo by origin go. -# The DW_AT_comp_dir of runtime/cgo should have a prefix with origin goroot. -env GOROOT_FINAL= -# If using "go run", it is no debuginfo in binary. So use "go build". -# And we can check the stderr to judge if the cache of "runtime/cgo" -# was used or not. -go build -o binary.exe -exec ./binary.exe $TESTGO_GOROOT -stdout 'cgo DW_AT_comp_dir is right in binary' +# Build a binary using a specific value of GOROOT_FINAL. +env GOROOT_FINAL=$WORK${/}goroot1 +go build -o main.exe +mv main.exe main1.exe +# Now clean the cache and build using a different GOROOT_FINAL. +# The resulting binaries should differ in their debug metadata. +go clean -cache +env GOROOT_FINAL=$WORK${/}goroot2 +go build -o main.exe +mv main.exe main2.exe +! cmp main2.exe main1.exe -# 2. GOROOT_FINAL will be changed, the runtime/cgo will be rebuild. -env GOROOT_FINAL=$WORK/gorootfinal -go build -x -o binary.exe -stderr '(clang|gcc)( |\.exe).*gcc_.*\.c' -exec ./binary.exe $GOROOT_FINAL -stdout 'cgo DW_AT_comp_dir is right in binary' - - -[!symlink] skip - -# Symlink the compiler to another path -env GOROOT=$WORK/goroot -symlink $GOROOT -> $TESTGO_GOROOT - -# 3. GOROOT_FINAL is same with 2, build with the other go -# the runtime/cgo will not be rebuild. -go build -x -o binary.exe -! stderr '(clang|gcc)( |\.exe).*gcc_.*\.c' -exec ./binary.exe $GOROOT_FINAL -stdout 'cgo DW_AT_comp_dir is right in binary' - - -# 4. unset GOROOT_FINAL, build with the other go -# the runtime/cgo will be rebuild. -env GOROOT_FINAL= -go build -x -o binary.exe -stderr '(clang|gcc)( |\.exe).*gcc_.*\.c' -exec ./binary.exe $GOROOT -stdout 'cgo DW_AT_comp_dir is right in binary' +# Set GOROOT_FINAL back to the first value. +# If the build is properly reproducible, the two binaries should match. +env GOROOT_FINAL=$WORK${/}goroot1 +go build -o main.exe +cmp -q main.exe main1.exe -- go.mod -- module main @@ -54,100 +37,11 @@ go 1.18 package main import "C" -import ( - "debug/dwarf" - "fmt" - "log" - "os" - "path/filepath" - "strings" -) + +import "runtime" var _ C.int func main() { - dwarfData, err := readDWARF(os.Args[0]) - if err != nil { - log.Fatal(err) - } - goroot := filepath.Join(os.Args[1], "src") - dwarfReader := dwarfData.Reader() - cgopackage := filepath.Join("runtime", "cgo") - var hascgo bool - for { - e, err := dwarfReader.Next() - if err != nil { - log.Fatal(err) - } - if e == nil { - break - } - field := e.AttrField(dwarf.AttrCompDir) - if field == nil { - continue - } - compdir := field.Val.(string) - if strings.HasSuffix(compdir, cgopackage) { - hascgo = true - if !strings.HasPrefix(compdir, goroot) { - fmt.Printf("cgo DW_AT_comp_dir %s contains incorrect path in binary.\n", compdir) - return - } - } - } - if hascgo { - fmt.Println("cgo DW_AT_comp_dir is right in binary") - } else { - fmt.Println("binary does not contain cgo") - } -} --- read_darwin.go -- -package main - -import ( - "debug/dwarf" - "debug/macho" -) - -func readDWARF(exePath string) (*dwarf.Data, error) { - machoFile, err := macho.Open(exePath) - if err != nil { - return nil, err - } - defer machoFile.Close() - return machoFile.DWARF() -} --- read_elf.go -- -// +build android dragonfly freebsd illumos linux netbsd openbsd solaris - -package main - -import ( - "debug/dwarf" - "debug/elf" -) - -func readDWARF(exePath string) (*dwarf.Data, error) { - elfFile, err := elf.Open(exePath) - if err != nil { - return nil, err - } - defer elfFile.Close() - return elfFile.DWARF() -} --- read_windows.go -- -package main - -import ( - "debug/dwarf" - "debug/pe" -) - -func readDWARF(exePath string) (*dwarf.Data, error) { - peFile, err := pe.Open(exePath) - if err != nil { - return nil, err - } - defer peFile.Close() - return peFile.DWARF() + println(runtime.GOROOT()) } From 0f4bd92c4d9a16efe05e397354dec87737338d2c Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 26 Jan 2022 09:18:14 -0500 Subject: [PATCH 703/752] cmd/go: avoid recording GOROOT_FINAL in precompiled C archives C archives for packages in GOROOT are shipped along with binary releases of the Go toolchain. Although we build the toolchain with GOROOT_FINAL set, we don't know actually know where the release will be installed: the user's real GOROOT can differ arbitrarily from our GOROOT_FINAL. (In the specific case of toolchains installed through golang.org/dl wrappers, the release's GOROOT_FINAL is /usr/local/go but the actual GOROOT to which the release is installed is $HOME/sdk/$(go env GOVERSION).) Fixes #50183 Updates #48319 Change-Id: If10a42f90c725300bbcb89c3b5b01a2d93ab6ef7 Reviewed-on: https://go-review.googlesource.com/c/go/+/380915 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Russ Cox TryBot-Result: Gopher Robot --- src/cmd/go/internal/work/exec.go | 16 ++++++++-------- .../testdata/script/cgo_stale_precompiled.txt | 17 +++++++++++++++++ 2 files changed, 25 insertions(+), 8 deletions(-) create mode 100644 src/cmd/go/testdata/script/cgo_stale_precompiled.txt diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go index ccd5aee221..48a74458bd 100644 --- a/src/cmd/go/internal/work/exec.go +++ b/src/cmd/go/internal/work/exec.go @@ -236,11 +236,13 @@ func (b *Builder) buildActionID(a *Action) cache.ActionID { } } else if p.Goroot { // The Go compiler always hides the exact value of $GOROOT - // when building things in GOROOT, but the C compiler - // merely rewrites GOROOT to GOROOT_FINAL. - if len(p.CFiles) > 0 { - fmt.Fprintf(h, "goroot %s\n", cfg.GOROOT_FINAL) - } + // when building things in GOROOT. + // + // The C compiler does not, but for packages in GOROOT we rewrite the path + // as though -trimpath were set, so that we don't invalidate the build cache + // (and especially any precompiled C archive files) when changing + // GOROOT_FINAL. (See https://go.dev/issue/50183.) + // // b.WorkDir is always either trimmed or rewritten to // the literal string "/tmp/go-build". } else if !strings.HasPrefix(p.Dir, b.WorkDir) { @@ -2337,7 +2339,7 @@ func (b *Builder) ccompile(a *Action, p *load.Package, outfile string, flags []s // directives pointing to the source directory. It should not generate those // when -trimpath is enabled. if b.gccSupportsFlag(compiler, "-fdebug-prefix-map=a=b") { - if cfg.BuildTrimpath { + if cfg.BuildTrimpath || p.Goroot { // Keep in sync with Action.trimpath. // The trimmed paths are a little different, but we need to trim in the // same situations. @@ -2359,8 +2361,6 @@ func (b *Builder) ccompile(a *Action, p *load.Package, outfile string, flags []s to = filepath.Join("/_", toPath) } flags = append(flags[:len(flags):len(flags)], "-fdebug-prefix-map="+from+"="+to) - } else if p.Goroot && cfg.GOROOT_FINAL != cfg.GOROOT { - flags = append(flags[:len(flags):len(flags)], "-fdebug-prefix-map="+cfg.GOROOT+"="+cfg.GOROOT_FINAL) } } diff --git a/src/cmd/go/testdata/script/cgo_stale_precompiled.txt b/src/cmd/go/testdata/script/cgo_stale_precompiled.txt new file mode 100644 index 0000000000..cda804070a --- /dev/null +++ b/src/cmd/go/testdata/script/cgo_stale_precompiled.txt @@ -0,0 +1,17 @@ +# Regression test for https://go.dev/issue/47215 and https://go.dev/issue/50183: +# A mismatched $GOROOT_FINAL or missing $CC caused the C dependencies of the net +# package to appear stale, and it could not be rebuilt due to a missing $CC. + +[!cgo] skip + +# Control case: net must not already be stale. +! stale net + +# https://go.dev/issue/47215: a missing $(go env CC) caused the precompiled net to be stale. +[!plan9] env PATH='' # Guaranteed not to include $(go env CC)! +[plan9] env path='' +! stale net # issue #47215 + +# https://go.dev/issue/50183: a mismatched GOROOT_FINAL caused net to be stale. +env GOROOT_FINAL=$WORK${/}goroot +! stale net From 55589e7531c7e576a26f5610241a278caf6e4a4e Mon Sep 17 00:00:00 2001 From: Mark Pulford Date: Sat, 22 Jan 2022 16:03:28 +1030 Subject: [PATCH 704/752] cmd/go: fix retrieving Mercurial commit timestamp under Windows Use "hgdate" since the strftime filter is unsupported by Mercurial under Windows. Fixes #49841 Change-Id: I300898e51e324147aaf1bfe12ed17dea4bdd183d Reviewed-on: https://go-review.googlesource.com/c/go/+/380077 Reviewed-by: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Trust: Jeremy Faller Trust: Michael Knyszek --- src/cmd/go/internal/vcs/vcs.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/cmd/go/internal/vcs/vcs.go b/src/cmd/go/internal/vcs/vcs.go index 3406ee0551..fd521b2eb1 100644 --- a/src/cmd/go/internal/vcs/vcs.go +++ b/src/cmd/go/internal/vcs/vcs.go @@ -164,7 +164,7 @@ func hgRemoteRepo(vcsHg *Cmd, rootDir string) (remoteRepo string, err error) { func hgStatus(vcsHg *Cmd, rootDir string) (Status, error) { // Output changeset ID and seconds since epoch. - out, err := vcsHg.runOutputVerboseOnly(rootDir, `log -l1 -T {node}:{date(date,"%s")}`) + out, err := vcsHg.runOutputVerboseOnly(rootDir, `log -l1 -T {node}:{date|hgdate}`) if err != nil { return Status{}, err } @@ -173,6 +173,10 @@ func hgStatus(vcsHg *Cmd, rootDir string) (Status, error) { var rev string var commitTime time.Time if len(out) > 0 { + // Strip trailing timezone offset. + if i := bytes.IndexByte(out, ' '); i > 0 { + out = out[:i] + } rev, commitTime, err = parseRevTime(out) if err != nil { return Status{}, err From 719e9894f9a471cd74b8469d9231cd2798b33999 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 25 Jan 2022 19:12:35 -0800 Subject: [PATCH 705/752] spec: document the underlying type of comparable For #50791. Change-Id: I7f135bb6626128a3cee9fd71c57535c1fc83ac7f Reviewed-on: https://go-review.googlesource.com/c/go/+/380854 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index b25cf5fa6e..6f4aefcf4f 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -820,7 +820,8 @@ An alias denotes a named type if the type given in the alias declaration is a na

    Each type T has an underlying type: If T -is one of the predeclared boolean, numeric, or string types, or a type literal, +is one of the predeclared boolean, numeric, or string types, the predeclared +type comparable, or a type literal, the corresponding underlying type is T itself. Otherwise, T's underlying type is the underlying type of the type to which T refers in its type From 946a8669d92f18a0029abaed9cea36194562a957 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Wed, 26 Jan 2022 12:45:12 -0500 Subject: [PATCH 706/752] cmd/api: reduce parallel 'go list' invocations to a constant 'go list' has its own internal parallelism, so invoking in in parallel can produce up to quadratic peak memory usage. Running 'go list' is also very I/O-intensive, so the higher parallelism does substantially improve latency; unfortunately, we lack a good way to balance latency against memory footprint, so we need to sacrifice some latency for reliability. Fixes #49957. Change-Id: Ib53990b46acf4cc67a9141644d97282964d6442d Reviewed-on: https://go-review.googlesource.com/c/go/+/380994 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Dmitri Shuralyov --- src/cmd/api/goapi.go | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go index 036aefe4d8..5ae059e4ce 100644 --- a/src/cmd/api/goapi.go +++ b/src/cmd/api/goapi.go @@ -459,8 +459,11 @@ type listImports struct { var listCache sync.Map // map[string]listImports, keyed by contextName -// listSem is a semaphore restricting concurrent invocations of 'go list'. -var listSem = make(chan semToken, ((runtime.GOMAXPROCS(0)-1)/2)+1) +// listSem is a semaphore restricting concurrent invocations of 'go list'. 'go +// list' has its own internal concurrency, so we use a hard-coded constant (to +// allow the I/O-intensive phases of 'go list' to overlap) instead of scaling +// all the way up to GOMAXPROCS. +var listSem = make(chan semToken, 2) type semToken struct{} From 8cfbb58bc70b9f9126a3310ac564344cc08c604b Mon Sep 17 00:00:00 2001 From: Matthew Dempsky Date: Tue, 25 Jan 2022 16:49:59 -0800 Subject: [PATCH 707/752] cmd/compile/internal/types2: remove (*Signature).SetRecvTypeParams This method isn't available in go/types, and its use by unified IR is non-essential. This CL refactors reader2.go to avoid using it and then removes the method. Change-Id: I813c93a062c43292bb6760686ef91df5219534a6 Reviewed-on: https://go-review.googlesource.com/c/go/+/380834 Run-TryBot: Matthew Dempsky TryBot-Result: Gopher Robot Trust: Matthew Dempsky Reviewed-by: Robert Griesemer --- src/cmd/compile/internal/noder/reader2.go | 16 +++++++--------- src/cmd/compile/internal/types2/signature.go | 3 --- 2 files changed, 7 insertions(+), 12 deletions(-) diff --git a/src/cmd/compile/internal/noder/reader2.go b/src/cmd/compile/internal/noder/reader2.go index 9396c0c87c..c028d21c67 100644 --- a/src/cmd/compile/internal/noder/reader2.go +++ b/src/cmd/compile/internal/noder/reader2.go @@ -250,7 +250,7 @@ func (r *reader2) doTyp() (res types2.Type) { case typePointer: return types2.NewPointer(r.typ()) case typeSignature: - return r.signature(nil) + return r.signature(nil, nil, nil) case typeSlice: return types2.NewSlice(r.typ()) case typeStruct: @@ -298,7 +298,7 @@ func (r *reader2) interfaceType() *types2.Interface { for i := range methods { pos := r.pos() pkg, name := r.selector() - mtyp := r.signature(nil) + mtyp := r.signature(nil, nil, nil) methods[i] = types2.NewFunc(pos, pkg, name, mtyp) } @@ -309,14 +309,14 @@ func (r *reader2) interfaceType() *types2.Interface { return types2.NewInterfaceType(methods, embeddeds) } -func (r *reader2) signature(recv *types2.Var) *types2.Signature { +func (r *reader2) signature(recv *types2.Var, rtparams, tparams []*types2.TypeParam) *types2.Signature { r.sync(syncSignature) params := r.params() results := r.params() variadic := r.bool() - return types2.NewSignatureType(recv, nil, nil, params, results, variadic) + return types2.NewSignatureType(recv, rtparams, tparams, params, results, variadic) } func (r *reader2) params() *types2.Tuple { @@ -393,8 +393,7 @@ func (pr *pkgReader2) objIdx(idx int) (*types2.Package, string) { case objFunc: pos := r.pos() tparams := r.typeParamNames() - sig := r.signature(nil) - sig.SetTypeParams(tparams) + sig := r.signature(nil, nil, tparams) return types2.NewFunc(pos, objPkg, objName, sig) case objType: @@ -490,9 +489,8 @@ func (r *reader2) method() *types2.Func { pos := r.pos() pkg, name := r.selector() - rparams := r.typeParamNames() - sig := r.signature(r.param()) - sig.SetRecvTypeParams(rparams) + rtparams := r.typeParamNames() + sig := r.signature(r.param(), rtparams, nil) _ = r.pos() // TODO(mdempsky): Remove; this is a hacker for linker.go. return types2.NewFunc(pos, pkg, name, sig) diff --git a/src/cmd/compile/internal/types2/signature.go b/src/cmd/compile/internal/types2/signature.go index 39161fcdf5..c87fab749c 100644 --- a/src/cmd/compile/internal/types2/signature.go +++ b/src/cmd/compile/internal/types2/signature.go @@ -73,9 +73,6 @@ func (s *Signature) SetTypeParams(tparams []*TypeParam) { s.tparams = bindTParam // RecvTypeParams returns the receiver type parameters of signature s, or nil. func (s *Signature) RecvTypeParams() *TypeParamList { return s.rparams } -// SetRecvTypeParams sets the receiver type params of signature s. -func (s *Signature) SetRecvTypeParams(rparams []*TypeParam) { s.rparams = bindTParams(rparams) } - // Params returns the parameters of signature s, or nil. func (s *Signature) Params() *Tuple { return s.params } From c8b0dcea4a3e67289ccf985b10616200817cca86 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Thu, 20 Jan 2022 08:54:59 -0500 Subject: [PATCH 708/752] doc/go1.18: note short-circuit and/or in html/template It was already noted in text/template; copied from there. Change-Id: Ie749d04004af60f2333073ddf556ff7e16c81c45 Reviewed-on: https://go-review.googlesource.com/c/go/+/379794 Trust: Russ Cox Run-TryBot: Russ Cox TryBot-Result: Gopher Robot Reviewed-by: Emmanuel Odeke Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index 4d1b6520ee..fb9e685c69 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -571,7 +571,7 @@ Do not send CLs removing the interior tags from such phrases.

    Trim, TrimLeft, - and TrimRight are now allocation free and, especially for + and TrimRight are now allocation free and, especially for small ASCII cutsets, up to 10 times faster.

    @@ -759,6 +759,14 @@ Do not send CLs removing the interior tags from such phrases. new {{continue}} command will immediately start the next loop iteration.

    + +

    + The and function no longer always evaluates all arguments; it + stops evaluating arguments after the first argument that evaluates to + false. Similarly, the or function now stops evaluating + arguments after the first argument that evaluates to true. This makes a + difference if any of the arguments is a function call. +

    @@ -938,7 +946,7 @@ Do not send CLs removing the interior tags from such phrases.

    Trim, TrimLeft, - and TrimRight are now allocation free and, especially for + and TrimRight are now allocation free and, especially for small ASCII cutsets, up to 10 times faster.

    From ca6a5c0d518463b40c3e6e56655d45d9fd60e1f7 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 25 Jan 2022 09:21:39 -0800 Subject: [PATCH 709/752] go/types, types2: print underlying type of comparable as "interface{comparable}" For #50791. Change-Id: Ib12009d2895146e55ec3a51aa8ceafe58dfd82a5 Reviewed-on: https://go-review.googlesource.com/c/go/+/380754 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/typestring.go | 18 ++++++++++++------ .../compile/internal/types2/typestring_test.go | 4 ++++ src/go/types/typestring.go | 18 ++++++++++++------ src/go/types/typestring_test.go | 5 +++++ 4 files changed, 33 insertions(+), 12 deletions(-) diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go index 4d03eba657..ada0529929 100644 --- a/src/cmd/compile/internal/types2/typestring.go +++ b/src/cmd/compile/internal/types2/typestring.go @@ -201,12 +201,18 @@ func (w *typeWriter) typ(typ Type) { } case *Interface: - if t == universeAny.Type() && w.ctxt == nil { - // When not hashing, we can try to improve type strings by writing "any" - // for a type that is pointer-identical to universeAny. This logic should - // be deprecated by more robust handling for aliases. - w.string("any") - break + if w.ctxt == nil { + if t == universeAny.Type() { + // When not hashing, we can try to improve type strings by writing "any" + // for a type that is pointer-identical to universeAny. This logic should + // be deprecated by more robust handling for aliases. + w.string("any") + break + } + if t == universeComparable.Type().(*Named).underlying { + w.string("interface{comparable}") + break + } } if t.implicit { if len(t.methods) == 0 && len(t.embeddeds) == 1 { diff --git a/src/cmd/compile/internal/types2/typestring_test.go b/src/cmd/compile/internal/types2/typestring_test.go index eda6835588..c0689e866c 100644 --- a/src/cmd/compile/internal/types2/typestring_test.go +++ b/src/cmd/compile/internal/types2/typestring_test.go @@ -93,6 +93,10 @@ var independentTestTypes = []testEntry{ dup(`interface{String() string; m(int) float32}`), dup("interface{int|float32|complex128}"), dup("interface{int|~float32|~complex128}"), + dup("any"), + dup("interface{comparable}"), + {"comparable", "interface{comparable}"}, + {"error", "interface{Error() string}"}, // maps dup("map[string]int"), diff --git a/src/go/types/typestring.go b/src/go/types/typestring.go index cf86f9f720..80210a2f34 100644 --- a/src/go/types/typestring.go +++ b/src/go/types/typestring.go @@ -202,12 +202,18 @@ func (w *typeWriter) typ(typ Type) { } case *Interface: - if t == universeAny.Type() && w.ctxt == nil { - // When not hashing, we can try to improve type strings by writing "any" - // for a type that is pointer-identical to universeAny. This logic should - // be deprecated by more robust handling for aliases. - w.string("any") - break + if w.ctxt == nil { + if t == universeAny.Type() { + // When not hashing, we can try to improve type strings by writing "any" + // for a type that is pointer-identical to universeAny. This logic should + // be deprecated by more robust handling for aliases. + w.string("any") + break + } + if t == universeComparable.Type().(*Named).underlying { + w.string("interface{comparable}") + break + } } if t.implicit { if len(t.methods) == 0 && len(t.embeddeds) == 1 { diff --git a/src/go/types/typestring_test.go b/src/go/types/typestring_test.go index 14ab9b6002..b7b843516e 100644 --- a/src/go/types/typestring_test.go +++ b/src/go/types/typestring_test.go @@ -97,6 +97,11 @@ var independentTestTypes = []testEntry{ dup(`interface{String() string; m(int) float32}`), dup("interface{int|float32|complex128}"), dup("interface{int|~float32|~complex128}"), + dup("any"), + dup("interface{comparable}"), + // TODO(gri) adjust test for EvalCompositeTest + // {"comparable", "interface{comparable}"}, + // {"error", "interface{Error() string}"}, // maps dup("map[string]int"), From ef0b09c526d78de23186522d50ff93ad657014c0 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 26 Jan 2022 13:44:45 -0800 Subject: [PATCH 710/752] go/types, types2: clean up the set up of error, comparable Follow-up on CL 380754. For #50791. Change-Id: Ia2f8f9785c2f02647525e7ee4168991fd4066dd3 Reviewed-on: https://go-review.googlesource.com/c/go/+/381094 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/universe.go | 24 +++++++++++++++------ src/go/types/universe.go | 24 +++++++++++++++------ 2 files changed, 34 insertions(+), 14 deletions(-) diff --git a/src/cmd/compile/internal/types2/universe.go b/src/cmd/compile/internal/types2/universe.go index c16ae3f63e..6ee5dbdca3 100644 --- a/src/cmd/compile/internal/types2/universe.go +++ b/src/cmd/compile/internal/types2/universe.go @@ -88,22 +88,32 @@ func defPredeclaredTypes() { { obj := NewTypeName(nopos, nil, "error", nil) obj.setColor(black) + typ := NewNamed(obj, nil, nil) + + // error.Error() string + recv := NewVar(nopos, nil, "", typ) res := NewVar(nopos, nil, "", Typ[String]) - sig := NewSignatureType(nil, nil, nil, nil, NewTuple(res), false) + sig := NewSignatureType(recv, nil, nil, nil, NewTuple(res), false) err := NewFunc(nopos, nil, "Error", sig) - ityp := &Interface{nil, obj, []*Func{err}, nil, nil, false, true, nil} + + // interface{ Error() string } + ityp := &Interface{obj: obj, methods: []*Func{err}, complete: true} computeInterfaceTypeSet(nil, nopos, ityp) // prevent races due to lazy computation of tset - typ := NewNamed(obj, ityp, nil) - sig.recv = NewVar(nopos, nil, "", typ) + + typ.SetUnderlying(ityp) def(obj) } - // type comparable interface{ /* type set marked comparable */ } + // type comparable interface{} // marked as comparable { obj := NewTypeName(nopos, nil, "comparable", nil) obj.setColor(black) - ityp := &Interface{nil, obj, nil, nil, nil, false, true, &_TypeSet{true, nil, allTermlist}} - NewNamed(obj, ityp, nil) + typ := NewNamed(obj, nil, nil) + + // interface{} // marked as comparable + ityp := &Interface{obj: obj, complete: true, tset: &_TypeSet{true, nil, allTermlist}} + + typ.SetUnderlying(ityp) def(obj) } } diff --git a/src/go/types/universe.go b/src/go/types/universe.go index edda56fc0d..3421634678 100644 --- a/src/go/types/universe.go +++ b/src/go/types/universe.go @@ -89,22 +89,32 @@ func defPredeclaredTypes() { { obj := NewTypeName(token.NoPos, nil, "error", nil) obj.setColor(black) + typ := NewNamed(obj, nil, nil) + + // error.Error() string + recv := NewVar(token.NoPos, nil, "", typ) res := NewVar(token.NoPos, nil, "", Typ[String]) - sig := NewSignatureType(nil, nil, nil, nil, NewTuple(res), false) + sig := NewSignatureType(recv, nil, nil, nil, NewTuple(res), false) err := NewFunc(token.NoPos, nil, "Error", sig) - ityp := &Interface{nil, obj, []*Func{err}, nil, nil, false, true, nil} + + // interface{ Error() string } + ityp := &Interface{obj: obj, methods: []*Func{err}, complete: true} computeInterfaceTypeSet(nil, token.NoPos, ityp) // prevent races due to lazy computation of tset - typ := NewNamed(obj, ityp, nil) - sig.recv = NewVar(token.NoPos, nil, "", typ) + + typ.SetUnderlying(ityp) def(obj) } - // type comparable interface{ /* type set marked comparable */ } + // type comparable interface{} // marked as comparable { obj := NewTypeName(token.NoPos, nil, "comparable", nil) obj.setColor(black) - ityp := &Interface{nil, obj, nil, nil, nil, false, true, &_TypeSet{true, nil, allTermlist}} - NewNamed(obj, ityp, nil) + typ := NewNamed(obj, nil, nil) + + // interface{} // marked as comparable + ityp := &Interface{obj: obj, complete: true, tset: &_TypeSet{true, nil, allTermlist}} + + typ.SetUnderlying(ityp) def(obj) } } From db48840cfc5ea9f8067cd5238827965ea01cdde1 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 26 Jan 2022 14:01:52 -0800 Subject: [PATCH 711/752] Revert "spec: document the underlying type of comparable" This reverts CL 380854. Per the conluding discussions on #50791. A follow-up will document `comparable` more thoroughly. For #50791. Change-Id: I15db9051784a012f713e28d725c3b8bbfeb40569 Reviewed-on: https://go-review.googlesource.com/c/go/+/381076 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index 6f4aefcf4f..b25cf5fa6e 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -820,8 +820,7 @@ An alias denotes a named type if the type given in the alias declaration is a na

    Each type T has an underlying type: If T -is one of the predeclared boolean, numeric, or string types, the predeclared -type comparable, or a type literal, +is one of the predeclared boolean, numeric, or string types, or a type literal, the corresponding underlying type is T itself. Otherwise, T's underlying type is the underlying type of the type to which T refers in its type From f4aa021985e9ae4a9a395f8fbe32ad08d2bfda3b Mon Sep 17 00:00:00 2001 From: Matthew Dempsky Date: Wed, 26 Jan 2022 13:26:45 -0800 Subject: [PATCH 712/752] cmd/compile: support structural typing in unified IR This CL updates unified IR to look at the structural type of a composite literal type, rather than merely the underlying type, to determine if it's a structure. This fixes a number of currently failing regress test cases. Updates #50833. Change-Id: I11c040c77ec86c23e8ffefcf1ce1aed548687dc5 Reviewed-on: https://go-review.googlesource.com/c/go/+/381074 Run-TryBot: Matthew Dempsky TryBot-Result: Gopher Robot Trust: Matthew Dempsky Reviewed-by: Robert Griesemer --- src/cmd/compile/internal/noder/writer.go | 4 +++- test/run.go | 4 ---- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/src/cmd/compile/internal/noder/writer.go b/src/cmd/compile/internal/noder/writer.go index 2bb0b4d5d7..73f2df8e39 100644 --- a/src/cmd/compile/internal/noder/writer.go +++ b/src/cmd/compile/internal/noder/writer.go @@ -1218,6 +1218,7 @@ func (w *writer) expr(expr syntax.Expr) { } obj := obj.(*types2.Var) + assert(!obj.IsField()) assert(targs.Len() == 0) w.code(exprLocal) @@ -1337,10 +1338,11 @@ func (w *writer) compLit(lit *syntax.CompositeLit) { w.typ(tv.Type) typ := tv.Type + // TODO(mdempsky): Use types2.StructuralType here too? See #50833. if ptr, ok := typ.Underlying().(*types2.Pointer); ok { typ = ptr.Elem() } - str, isStruct := typ.Underlying().(*types2.Struct) + str, isStruct := types2.StructuralType(typ).(*types2.Struct) w.len(len(lit.ElemList)) for i, elem := range lit.ElemList { diff --git a/test/run.go b/test/run.go index 0e35ed2c0f..9ba421510c 100644 --- a/test/run.go +++ b/test/run.go @@ -2167,7 +2167,6 @@ var unifiedFailures = setOf( "fixedbugs/issue42284.go", // prints "T(0) does not escape", but test expects "a.I(a.T(0)) does not escape" "fixedbugs/issue7921.go", // prints "… escapes to heap", but test expects "string(…) escapes to heap" - "typeparam/issue48538.go", // assertion failure, interprets struct key as closure variable "typeparam/issue47631.go", // unified IR can handle local type declarations "fixedbugs/issue42058a.go", // unified IR doesn't report channel element too large "fixedbugs/issue42058b.go", // unified IR doesn't report channel element too large @@ -2178,10 +2177,7 @@ var unifiedFailures = setOf( "typeparam/typeswitch2.go", // duplicate case failure due to stenciling "typeparam/typeswitch3.go", // duplicate case failure due to stenciling "typeparam/typeswitch4.go", // duplicate case failure due to stenciling - "typeparam/issue50417b.go", // Need to handle field access on a type param "typeparam/issue50552.go", // gives missing method for instantiated type - "typeparam/absdiff2.go", // wrong assertion about closure variables - "typeparam/absdiffimp2.go", // wrong assertion about closure variables ) func setOf(keys ...string) map[string]bool { From a991d9dc27bda23018e23488806c8f8d027e4f7b Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Wed, 26 Jan 2022 17:58:08 -0800 Subject: [PATCH 713/752] cmd/compile: add missing shape check in (*Tsubster).tinter Add a missing shape check in (*Tsubster).tinter when substituting on a generic type which is an empty interface, analogous to same check in (*Tsubster).tstruct. Empty structs/interfaces that have rparams (i.e. are a generic type or a shape type) need to get a new type of their rparams - they will be different even though they don't have any fields/methods. Without this shape check, we were not correctly completing the Token[int] type during substitution in the example in the issue. This issue only happens for a generic type which is an empty interface (i.e. doesn't actually use the type param, hence quite unusual). Added the test case already created by Keith. Fixes #50841 Change-Id: Ia985b9f52c0e87ed0647b46373e44c51cb748ba4 Reviewed-on: https://go-review.googlesource.com/c/go/+/381175 Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot Reviewed-by: Keith Randall --- src/cmd/compile/internal/typecheck/subr.go | 14 +++++++------- test/typeparam/issue50841.dir/a.go | 22 ++++++++++++++++++++++ test/typeparam/issue50841.dir/b.go | 11 +++++++++++ test/typeparam/issue50841.go | 7 +++++++ 4 files changed, 47 insertions(+), 7 deletions(-) create mode 100644 test/typeparam/issue50841.dir/a.go create mode 100644 test/typeparam/issue50841.dir/b.go create mode 100644 test/typeparam/issue50841.go diff --git a/src/cmd/compile/internal/typecheck/subr.go b/src/cmd/compile/internal/typecheck/subr.go index ac90d87f26..93812ebda5 100644 --- a/src/cmd/compile/internal/typecheck/subr.go +++ b/src/cmd/compile/internal/typecheck/subr.go @@ -1326,9 +1326,9 @@ func (ts *Tsubster) typ1(t *types.Type) *types.Type { func (ts *Tsubster) tstruct(t *types.Type, force bool) *types.Type { if t.NumFields() == 0 { if t.HasTParam() || t.HasShape() { - // For an empty struct, we need to return a new type, - // since it may now be fully instantiated (HasTParam - // becomes false). + // For an empty struct, we need to return a new type, if + // substituting from a generic type or shape type, since it + // will change HasTParam/HasShape flags. return types.NewStruct(t.Pkg(), nil) } return t @@ -1387,10 +1387,10 @@ func (ts *Tsubster) tstruct(t *types.Type, force bool) *types.Type { // tinter substitutes type params in types of the methods of an interface type. func (ts *Tsubster) tinter(t *types.Type, force bool) *types.Type { if t.Methods().Len() == 0 { - if t.HasTParam() { - // For an empty interface, we need to return a new type, - // since it may now be fully instantiated (HasTParam - // becomes false). + if t.HasTParam() || t.HasShape() { + // For an empty interface, we need to return a new type, if + // substituting from a generic type or shape type, since + // since it will change HasTParam/HasShape flags. return types.NewInterface(t.Pkg(), nil, false) } return t diff --git a/test/typeparam/issue50841.dir/a.go b/test/typeparam/issue50841.dir/a.go new file mode 100644 index 0000000000..37e0233701 --- /dev/null +++ b/test/typeparam/issue50841.dir/a.go @@ -0,0 +1,22 @@ +// Copyright 2022 The Go 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 Marshal[foobar any]() { + _ = NewEncoder[foobar]() +} + +func NewEncoder[foobar any]() *Encoder[foobar] { + return nil +} + +type Encoder[foobar any] struct { +} + +func (e *Encoder[foobar]) EncodeToken(t Token[foobar]) { + +} + +type Token[foobar any] any diff --git a/test/typeparam/issue50841.dir/b.go b/test/typeparam/issue50841.dir/b.go new file mode 100644 index 0000000000..f2f70225ff --- /dev/null +++ b/test/typeparam/issue50841.dir/b.go @@ -0,0 +1,11 @@ +// Copyright 2022 The Go 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" + +func F() { + a.Marshal[int]() +} diff --git a/test/typeparam/issue50841.go b/test/typeparam/issue50841.go new file mode 100644 index 0000000000..060a1214cc --- /dev/null +++ b/test/typeparam/issue50841.go @@ -0,0 +1,7 @@ +// compiledir -G=3 + +// Copyright 2022 The Go 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 From b2dc66c64db933120c34d2223e670e8594543bd9 Mon Sep 17 00:00:00 2001 From: Roland Shoemaker Date: Mon, 1 Nov 2021 10:03:36 -0700 Subject: [PATCH 714/752] internal/fuzz: centralize corpus entry addition Adds an addCorpusEntry method to coordinator which manages checking for duplicate entries, writing entries to the cache directory, and adding entries to the corpus. Also moves readCache to be a method on the coordinator. Fixes #50606 Change-Id: Id6721384a2ad1cfb4c5471cf0cd0a7510d250a6c Reviewed-on: https://go-review.googlesource.com/c/go/+/360394 Trust: Katie Hockman Reviewed-by: Katie Hockman Trust: Roland Shoemaker Run-TryBot: Roland Shoemaker TryBot-Result: Gopher Robot --- src/internal/fuzz/fuzz.go | 81 +++++++++++++++++++++------------------ 1 file changed, 44 insertions(+), 37 deletions(-) diff --git a/src/internal/fuzz/fuzz.go b/src/internal/fuzz/fuzz.go index 37b6d2b391..73f32dd4c7 100644 --- a/src/internal/fuzz/fuzz.go +++ b/src/internal/fuzz/fuzz.go @@ -316,32 +316,15 @@ func CoordinateFuzzing(ctx context.Context, opts CoordinateFuzzingOpts) (err err } else { // Update the coordinator's coverage mask and save the value. inputSize := len(result.entry.Data) - if opts.CacheDir != "" { - // It is possible that the input that was discovered is already - // present in the corpus, but the worker produced a coverage map - // that still expanded our total coverage (this may happen due to - // flakiness in the coverage counters). In order to prevent adding - // duplicate entries to the corpus (and re-writing the file on - // disk), skip it if the on disk file already exists. - // TODO(roland): this check is limited in that it will only be - // applied if we are using the CacheDir. Another option would be - // to iterate through the corpus and check if it is already present, - // which would catch cases where we are not caching entries. - // A slightly faster approach would be to keep some kind of map of - // entry hashes, which would allow us to avoid iterating through - // all entries. - _, err = os.Stat(result.entry.Path) - if err == nil { - continue - } - err := writeToCorpus(&result.entry, opts.CacheDir) - if err != nil { - stop(err) - } - result.entry.Data = nil + duplicate, err := c.addCorpusEntries(true, result.entry) + if err != nil { + stop(err) + break + } + if duplicate { + continue } c.updateCoverage(keepCoverage) - c.corpus.entries = append(c.corpus.entries, result.entry) c.inputQueue.enqueue(result.entry) c.interestingCount++ if shouldPrintDebugInfo() { @@ -433,6 +416,28 @@ func (e *crashError) CrashPath() string { type corpus struct { entries []CorpusEntry + hashes map[[sha256.Size]byte]bool +} + +func (c *coordinator) addCorpusEntries(addToCache bool, entries ...CorpusEntry) (bool, error) { + for _, e := range entries { + h := sha256.Sum256(e.Data) + if c.corpus.hashes[h] { + return true, nil + } + if addToCache { + if err := writeToCorpus(&e, c.opts.CacheDir); err != nil { + return false, err + } + // For entries written to disk, we don't hold onto the bytes, + // since the corpus would consume a significant amount of + // memory. + e.Data = nil + } + c.corpus.hashes[h] = true + c.corpus.entries = append(c.corpus.entries, e) + } + return false, nil } // CorpusEntry represents an individual input for fuzzing. @@ -640,18 +645,17 @@ func newCoordinator(opts CoordinateFuzzingOpts) (*coordinator, error) { opts.Seed[i].Data = marshalCorpusFile(opts.Seed[i].Values...) } } - corpus, err := readCache(opts.Seed, opts.Types, opts.CacheDir) - if err != nil { - return nil, err - } c := &coordinator{ opts: opts, startTime: time.Now(), inputC: make(chan fuzzInput), minimizeC: make(chan fuzzMinimizeInput), resultC: make(chan fuzzResult), - corpus: corpus, timeLastLog: time.Now(), + corpus: corpus{hashes: make(map[[sha256.Size]byte]bool)}, + } + if err := c.readCache(); err != nil { + return nil, err } if opts.MinimizeLimit > 0 || opts.MinimizeTimeout > 0 { for _, t := range opts.Types { @@ -691,7 +695,7 @@ func newCoordinator(opts CoordinateFuzzingOpts) (*coordinator, error) { data := marshalCorpusFile(vals...) h := sha256.Sum256(data) name := fmt.Sprintf("%x", h[:4]) - c.corpus.entries = append(c.corpus.entries, CorpusEntry{Path: name, Data: data}) + c.addCorpusEntries(false, CorpusEntry{Path: name, Data: data}) } return c, nil @@ -908,22 +912,25 @@ func (c *coordinator) elapsed() time.Duration { // // TODO(fuzzing): need a mechanism that can remove values that // aren't useful anymore, for example, because they have the wrong type. -func readCache(seed []CorpusEntry, types []reflect.Type, cacheDir string) (corpus, error) { - var c corpus - c.entries = append(c.entries, seed...) - entries, err := ReadCorpus(cacheDir, types) +func (c *coordinator) readCache() error { + if _, err := c.addCorpusEntries(false, c.opts.Seed...); err != nil { + return err + } + entries, err := ReadCorpus(c.opts.CacheDir, c.opts.Types) if err != nil { if _, ok := err.(*MalformedCorpusError); !ok { // It's okay if some files in the cache directory are malformed and // are not included in the corpus, but fail if it's an I/O error. - return corpus{}, err + return err } // TODO(jayconrod,katiehockman): consider printing some kind of warning // indicating the number of files which were skipped because they are // malformed. } - c.entries = append(c.entries, entries...) - return c, nil + if _, err := c.addCorpusEntries(false, entries...); err != nil { + return err + } + return nil } // MalformedCorpusError is an error found while reading the corpus from the From b7b44b3173f151a2313da7072afd25de80511605 Mon Sep 17 00:00:00 2001 From: David Chase Date: Thu, 27 Jan 2022 11:26:59 -0500 Subject: [PATCH 715/752] cmd/compile: remove incorrect arm,arm64 CMP->CMN transformations These can go wrong when one of the operands is the minimum integer value. Fixes #50854. Change-Id: I238fe284f60c7ee5aeb9dc9a18e8b1578cdb77d0 Reviewed-on: https://go-review.googlesource.com/c/go/+/381318 Reviewed-by: Keith Randall Reviewed-by: Cherry Mui Trust: David Chase Run-TryBot: David Chase TryBot-Result: Gopher Robot --- src/cmd/compile/internal/ssa/gen/ARM.rules | 4 +- src/cmd/compile/internal/ssa/gen/ARM64.rules | 10 +- src/cmd/compile/internal/ssa/gen/ARM64Ops.go | 4 +- src/cmd/compile/internal/ssa/gen/ARMOps.go | 2 +- src/cmd/compile/internal/ssa/rewriteARM.go | 144 ----------------- src/cmd/compile/internal/ssa/rewriteARM64.go | 160 ------------------- test/fixedbugs/issue50854.go | 38 +++++ 7 files changed, 45 insertions(+), 317 deletions(-) create mode 100644 test/fixedbugs/issue50854.go diff --git a/src/cmd/compile/internal/ssa/gen/ARM.rules b/src/cmd/compile/internal/ssa/gen/ARM.rules index 2bc58a3c47..23f113285b 100644 --- a/src/cmd/compile/internal/ssa/gen/ARM.rules +++ b/src/cmd/compile/internal/ssa/gen/ARM.rules @@ -1270,8 +1270,8 @@ (SRLconst (SLLconst x [c]) [d]) && buildcfg.GOARM==7 && uint64(d)>=uint64(c) && uint64(d)<=31 => (BFXU [(d-c)|(32-d)<<8] x) // comparison simplification -((LT|LE|EQ|NE|GE|GT) (CMP x (RSBconst [0] y))) => ((LT|LE|EQ|NE|GE|GT) (CMN x y)) // sense of carry bit not preserved -((LT|LE|EQ|NE|GE|GT) (CMN x (RSBconst [0] y))) => ((LT|LE|EQ|NE|GE|GT) (CMP x y)) // sense of carry bit not preserved +((EQ|NE) (CMP x (RSBconst [0] y))) => ((EQ|NE) (CMN x y)) // sense of carry bit not preserved; see also #50854 +((EQ|NE) (CMN x (RSBconst [0] y))) => ((EQ|NE) (CMP x y)) // sense of carry bit not preserved; see also #50864 (EQ (CMPconst [0] l:(SUB x y)) yes no) && l.Uses==1 => (EQ (CMP x y) yes no) (EQ (CMPconst [0] l:(MULS x y a)) yes no) && l.Uses==1 => (EQ (CMP a (MUL x y)) yes no) (EQ (CMPconst [0] l:(SUBconst [c] x)) yes no) && l.Uses==1 => (EQ (CMPconst [c] x) yes no) diff --git a/src/cmd/compile/internal/ssa/gen/ARM64.rules b/src/cmd/compile/internal/ssa/gen/ARM64.rules index d34e1899db..be8be4ebe3 100644 --- a/src/cmd/compile/internal/ssa/gen/ARM64.rules +++ b/src/cmd/compile/internal/ssa/gen/ARM64.rules @@ -649,19 +649,13 @@ (GT (CMPWconst [0] z:(ADD x y)) yes no) && z.Uses == 1 => (GTnoov (CMNW x y) yes no) (GE (CMPWconst [0] z:(ADD x y)) yes no) && z.Uses == 1 => (GEnoov (CMNW x y) yes no) +// CMP(x,-y) -> CMN(x,y) is only valid for unordered comparison, if y can be -1<<63 (EQ (CMP x z:(NEG y)) yes no) && z.Uses == 1 => (EQ (CMN x y) yes no) (NE (CMP x z:(NEG y)) yes no) && z.Uses == 1 => (NE (CMN x y) yes no) -(LT (CMP x z:(NEG y)) yes no) && z.Uses == 1 => (LT (CMN x y) yes no) -(LE (CMP x z:(NEG y)) yes no) && z.Uses == 1 => (LE (CMN x y) yes no) -(GT (CMP x z:(NEG y)) yes no) && z.Uses == 1 => (GT (CMN x y) yes no) -(GE (CMP x z:(NEG y)) yes no) && z.Uses == 1 => (GE (CMN x y) yes no) +// CMPW(x,-y) -> CMNW(x,y) is only valid for unordered comparison, if y can be -1<<31 (EQ (CMPW x z:(NEG y)) yes no) && z.Uses == 1 => (EQ (CMNW x y) yes no) (NE (CMPW x z:(NEG y)) yes no) && z.Uses == 1 => (NE (CMNW x y) yes no) -(LT (CMPW x z:(NEG y)) yes no) && z.Uses == 1 => (LT (CMNW x y) yes no) -(LE (CMPW x z:(NEG y)) yes no) && z.Uses == 1 => (LE (CMNW x y) yes no) -(GT (CMPW x z:(NEG y)) yes no) && z.Uses == 1 => (GT (CMNW x y) yes no) -(GE (CMPW x z:(NEG y)) yes no) && z.Uses == 1 => (GE (CMNW x y) yes no) (EQ (CMPconst [0] x) yes no) => (Z x yes no) (NE (CMPconst [0] x) yes no) => (NZ x yes no) diff --git a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go index e052ce09f4..2d03c44988 100644 --- a/src/cmd/compile/internal/ssa/gen/ARM64Ops.go +++ b/src/cmd/compile/internal/ssa/gen/ARM64Ops.go @@ -285,9 +285,9 @@ func init() { {name: "CMPconst", argLength: 1, reg: gp1flags, asm: "CMP", aux: "Int64", typ: "Flags"}, // arg0 compare to auxInt {name: "CMPW", argLength: 2, reg: gp2flags, asm: "CMPW", typ: "Flags"}, // arg0 compare to arg1, 32 bit {name: "CMPWconst", argLength: 1, reg: gp1flags, asm: "CMPW", aux: "Int32", typ: "Flags"}, // arg0 compare to auxInt, 32 bit - {name: "CMN", argLength: 2, reg: gp2flags, asm: "CMN", typ: "Flags", commutative: true}, // arg0 compare to -arg1 + {name: "CMN", argLength: 2, reg: gp2flags, asm: "CMN", typ: "Flags", commutative: true}, // arg0 compare to -arg1, provided arg1 is not 1<<63 {name: "CMNconst", argLength: 1, reg: gp1flags, asm: "CMN", aux: "Int64", typ: "Flags"}, // arg0 compare to -auxInt - {name: "CMNW", argLength: 2, reg: gp2flags, asm: "CMNW", typ: "Flags", commutative: true}, // arg0 compare to -arg1, 32 bit + {name: "CMNW", argLength: 2, reg: gp2flags, asm: "CMNW", typ: "Flags", commutative: true}, // arg0 compare to -arg1, 32 bit, provided arg1 is not 1<<31 {name: "CMNWconst", argLength: 1, reg: gp1flags, asm: "CMNW", aux: "Int32", typ: "Flags"}, // arg0 compare to -auxInt, 32 bit {name: "TST", argLength: 2, reg: gp2flags, asm: "TST", typ: "Flags", commutative: true}, // arg0 & arg1 compare to 0 {name: "TSTconst", argLength: 1, reg: gp1flags, asm: "TST", aux: "Int64", typ: "Flags"}, // arg0 & auxInt compare to 0 diff --git a/src/cmd/compile/internal/ssa/gen/ARMOps.go b/src/cmd/compile/internal/ssa/gen/ARMOps.go index 2f004205a5..3803f273c1 100644 --- a/src/cmd/compile/internal/ssa/gen/ARMOps.go +++ b/src/cmd/compile/internal/ssa/gen/ARMOps.go @@ -331,7 +331,7 @@ func init() { // comparisons {name: "CMP", argLength: 2, reg: gp2flags, asm: "CMP", typ: "Flags"}, // arg0 compare to arg1 {name: "CMPconst", argLength: 1, reg: gp1flags, asm: "CMP", aux: "Int32", typ: "Flags"}, // arg0 compare to auxInt - {name: "CMN", argLength: 2, reg: gp2flags, asm: "CMN", typ: "Flags", commutative: true}, // arg0 compare to -arg1 + {name: "CMN", argLength: 2, reg: gp2flags, asm: "CMN", typ: "Flags", commutative: true}, // arg0 compare to -arg1, provided arg1 is not 1<<63 {name: "CMNconst", argLength: 1, reg: gp1flags, asm: "CMN", aux: "Int32", typ: "Flags"}, // arg0 compare to -auxInt {name: "TST", argLength: 2, reg: gp2flags, asm: "TST", typ: "Flags", commutative: true}, // arg0 & arg1 compare to 0 {name: "TSTconst", argLength: 1, reg: gp1flags, asm: "TST", aux: "Int32", typ: "Flags"}, // arg0 & auxInt compare to 0 diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go index 496f9b4ae2..1b50bf9aa6 100644 --- a/src/cmd/compile/internal/ssa/rewriteARM.go +++ b/src/cmd/compile/internal/ssa/rewriteARM.go @@ -17153,42 +17153,6 @@ func rewriteBlockARM(b *Block) bool { b.resetWithControl(BlockARMLE, cmp) return true } - // match: (GE (CMP x (RSBconst [0] y))) - // result: (GE (CMN x y)) - for b.Controls[0].Op == OpARMCMP { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - v_0_1 := v_0.Args[1] - if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 { - break - } - y := v_0_1.Args[0] - v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARMGE, v0) - return true - } - // match: (GE (CMN x (RSBconst [0] y))) - // result: (GE (CMP x y)) - for b.Controls[0].Op == OpARMCMN { - v_0 := b.Controls[0] - _ = v_0.Args[1] - v_0_0 := v_0.Args[0] - v_0_1 := v_0.Args[1] - for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { - x := v_0_0 - if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 { - continue - } - y := v_0_1.Args[0] - v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARMGE, v0) - return true - } - break - } // match: (GE (CMPconst [0] l:(SUB x y)) yes no) // cond: l.Uses==1 // result: (GEnoov (CMP x y) yes no) @@ -18069,42 +18033,6 @@ func rewriteBlockARM(b *Block) bool { b.resetWithControl(BlockARMLT, cmp) return true } - // match: (GT (CMP x (RSBconst [0] y))) - // result: (GT (CMN x y)) - for b.Controls[0].Op == OpARMCMP { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - v_0_1 := v_0.Args[1] - if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 { - break - } - y := v_0_1.Args[0] - v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARMGT, v0) - return true - } - // match: (GT (CMN x (RSBconst [0] y))) - // result: (GT (CMP x y)) - for b.Controls[0].Op == OpARMCMN { - v_0 := b.Controls[0] - _ = v_0.Args[1] - v_0_0 := v_0.Args[0] - v_0_1 := v_0.Args[1] - for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { - x := v_0_0 - if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 { - continue - } - y := v_0_1.Args[0] - v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARMGT, v0) - return true - } - break - } // match: (GT (CMPconst [0] l:(SUB x y)) yes no) // cond: l.Uses==1 // result: (GTnoov (CMP x y) yes no) @@ -19076,42 +19004,6 @@ func rewriteBlockARM(b *Block) bool { b.resetWithControl(BlockARMGE, cmp) return true } - // match: (LE (CMP x (RSBconst [0] y))) - // result: (LE (CMN x y)) - for b.Controls[0].Op == OpARMCMP { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - v_0_1 := v_0.Args[1] - if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 { - break - } - y := v_0_1.Args[0] - v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARMLE, v0) - return true - } - // match: (LE (CMN x (RSBconst [0] y))) - // result: (LE (CMP x y)) - for b.Controls[0].Op == OpARMCMN { - v_0 := b.Controls[0] - _ = v_0.Args[1] - v_0_0 := v_0.Args[0] - v_0_1 := v_0.Args[1] - for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { - x := v_0_0 - if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 { - continue - } - y := v_0_1.Args[0] - v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARMLE, v0) - return true - } - break - } // match: (LE (CMPconst [0] l:(SUB x y)) yes no) // cond: l.Uses==1 // result: (LEnoov (CMP x y) yes no) @@ -19992,42 +19884,6 @@ func rewriteBlockARM(b *Block) bool { b.resetWithControl(BlockARMGT, cmp) return true } - // match: (LT (CMP x (RSBconst [0] y))) - // result: (LT (CMN x y)) - for b.Controls[0].Op == OpARMCMP { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - v_0_1 := v_0.Args[1] - if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 { - break - } - y := v_0_1.Args[0] - v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARMLT, v0) - return true - } - // match: (LT (CMN x (RSBconst [0] y))) - // result: (LT (CMP x y)) - for b.Controls[0].Op == OpARMCMN { - v_0 := b.Controls[0] - _ = v_0.Args[1] - v_0_0 := v_0.Args[0] - v_0_1 := v_0.Args[1] - for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 { - x := v_0_0 - if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 { - continue - } - y := v_0_1.Args[0] - v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARMLT, v0) - return true - } - break - } // match: (LT (CMPconst [0] l:(SUB x y)) yes no) // cond: l.Uses==1 // result: (LTnoov (CMP x y) yes no) diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go index ad34855c30..c5f53e5507 100644 --- a/src/cmd/compile/internal/ssa/rewriteARM64.go +++ b/src/cmd/compile/internal/ssa/rewriteARM64.go @@ -27983,46 +27983,6 @@ func rewriteBlockARM64(b *Block) bool { } break } - // match: (GE (CMP x z:(NEG y)) yes no) - // cond: z.Uses == 1 - // result: (GE (CMN x y) yes no) - for b.Controls[0].Op == OpARM64CMP { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - z := v_0.Args[1] - if z.Op != OpARM64NEG { - break - } - y := z.Args[0] - if !(z.Uses == 1) { - break - } - v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARM64GE, v0) - return true - } - // match: (GE (CMPW x z:(NEG y)) yes no) - // cond: z.Uses == 1 - // result: (GE (CMNW x y) yes no) - for b.Controls[0].Op == OpARM64CMPW { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - z := v_0.Args[1] - if z.Op != OpARM64NEG { - break - } - y := z.Args[0] - if !(z.Uses == 1) { - break - } - v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARM64GE, v0) - return true - } // match: (GE (CMPconst [0] z:(MADD a x y)) yes no) // cond: z.Uses==1 // result: (GEnoov (CMN a (MUL x y)) yes no) @@ -28419,46 +28379,6 @@ func rewriteBlockARM64(b *Block) bool { } break } - // match: (GT (CMP x z:(NEG y)) yes no) - // cond: z.Uses == 1 - // result: (GT (CMN x y) yes no) - for b.Controls[0].Op == OpARM64CMP { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - z := v_0.Args[1] - if z.Op != OpARM64NEG { - break - } - y := z.Args[0] - if !(z.Uses == 1) { - break - } - v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARM64GT, v0) - return true - } - // match: (GT (CMPW x z:(NEG y)) yes no) - // cond: z.Uses == 1 - // result: (GT (CMNW x y) yes no) - for b.Controls[0].Op == OpARM64CMPW { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - z := v_0.Args[1] - if z.Op != OpARM64NEG { - break - } - y := z.Args[0] - if !(z.Uses == 1) { - break - } - v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARM64GT, v0) - return true - } // match: (GT (CMPconst [0] z:(MADD a x y)) yes no) // cond: z.Uses==1 // result: (GTnoov (CMN a (MUL x y)) yes no) @@ -28951,46 +28871,6 @@ func rewriteBlockARM64(b *Block) bool { } break } - // match: (LE (CMP x z:(NEG y)) yes no) - // cond: z.Uses == 1 - // result: (LE (CMN x y) yes no) - for b.Controls[0].Op == OpARM64CMP { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - z := v_0.Args[1] - if z.Op != OpARM64NEG { - break - } - y := z.Args[0] - if !(z.Uses == 1) { - break - } - v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARM64LE, v0) - return true - } - // match: (LE (CMPW x z:(NEG y)) yes no) - // cond: z.Uses == 1 - // result: (LE (CMNW x y) yes no) - for b.Controls[0].Op == OpARM64CMPW { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - z := v_0.Args[1] - if z.Op != OpARM64NEG { - break - } - y := z.Args[0] - if !(z.Uses == 1) { - break - } - v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARM64LE, v0) - return true - } // match: (LE (CMPconst [0] z:(MADD a x y)) yes no) // cond: z.Uses==1 // result: (LEnoov (CMN a (MUL x y)) yes no) @@ -29363,46 +29243,6 @@ func rewriteBlockARM64(b *Block) bool { } break } - // match: (LT (CMP x z:(NEG y)) yes no) - // cond: z.Uses == 1 - // result: (LT (CMN x y) yes no) - for b.Controls[0].Op == OpARM64CMP { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - z := v_0.Args[1] - if z.Op != OpARM64NEG { - break - } - y := z.Args[0] - if !(z.Uses == 1) { - break - } - v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARM64LT, v0) - return true - } - // match: (LT (CMPW x z:(NEG y)) yes no) - // cond: z.Uses == 1 - // result: (LT (CMNW x y) yes no) - for b.Controls[0].Op == OpARM64CMPW { - v_0 := b.Controls[0] - _ = v_0.Args[1] - x := v_0.Args[0] - z := v_0.Args[1] - if z.Op != OpARM64NEG { - break - } - y := z.Args[0] - if !(z.Uses == 1) { - break - } - v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags) - v0.AddArg2(x, y) - b.resetWithControl(BlockARM64LT, v0) - return true - } // match: (LT (CMPconst [0] z:(MADD a x y)) yes no) // cond: z.Uses==1 // result: (LTnoov (CMN a (MUL x y)) yes no) diff --git a/test/fixedbugs/issue50854.go b/test/fixedbugs/issue50854.go new file mode 100644 index 0000000000..a5be9195f1 --- /dev/null +++ b/test/fixedbugs/issue50854.go @@ -0,0 +1,38 @@ +// run + +// Copyright 2022 The Go 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 + +// This checks for incorrect application of CMP(-x,y) -> CMN(x,y) in arm and arm64 + +//go:noinline +func f(p int64, x, y int64) bool { return -x <= p && p <= y } + +//go:noinline +func g(p int32, x, y int32) bool { return -x <= p && p <= y } + +// There are some more complicated patterns involving compares and shifts, try to trigger those. + +//go:noinline +func h(p int64, x, y int64) bool { return -(x<<1) <= p && p <= y } + +//go:noinline +func k(p int32, x, y int32) bool { return -(1< Date: Wed, 26 Jan 2022 13:46:45 -0800 Subject: [PATCH 716/752] go/types, cmd/compile: fix composite literal structural typing For a composite literal expression like []T{{f: 1}}, we allow T to be a pointer to struct type, so it's consistent to allow T to also be a type parameter whose structural type is a pointer to struct type. Fixes #50833. Change-Id: Ib0781ec4a4f327c875ea25b97740ff2c0c86b916 Reviewed-on: https://go-review.googlesource.com/c/go/+/381075 Run-TryBot: Matthew Dempsky Reviewed-by: Robert Griesemer Trust: Matthew Dempsky TryBot-Result: Gopher Robot --- src/cmd/compile/internal/noder/expr.go | 2 +- src/cmd/compile/internal/noder/writer.go | 3 +-- src/cmd/compile/internal/types2/expr.go | 6 +---- .../types2/testdata/fixedbugs/issue50833.go2 | 16 +++++++++++++ src/go/types/expr.go | 6 +---- .../types/testdata/fixedbugs/issue50833.go2 | 16 +++++++++++++ test/typeparam/issue50833.go | 23 +++++++++++++++++++ 7 files changed, 59 insertions(+), 13 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50833.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50833.go2 create mode 100644 test/typeparam/issue50833.go diff --git a/src/cmd/compile/internal/noder/expr.go b/src/cmd/compile/internal/noder/expr.go index 6891d1ec30..8a9afeb095 100644 --- a/src/cmd/compile/internal/noder/expr.go +++ b/src/cmd/compile/internal/noder/expr.go @@ -332,7 +332,7 @@ func (g *irgen) exprs(exprs []syntax.Expr) []ir.Node { } func (g *irgen) compLit(typ types2.Type, lit *syntax.CompositeLit) ir.Node { - if ptr, ok := typ.Underlying().(*types2.Pointer); ok { + if ptr, ok := types2.StructuralType(typ).(*types2.Pointer); ok { n := ir.NewAddrExpr(g.pos(lit), g.compLit(ptr.Elem(), lit)) n.SetOp(ir.OPTRLIT) return typed(g.typ(typ), n) diff --git a/src/cmd/compile/internal/noder/writer.go b/src/cmd/compile/internal/noder/writer.go index 73f2df8e39..933f577825 100644 --- a/src/cmd/compile/internal/noder/writer.go +++ b/src/cmd/compile/internal/noder/writer.go @@ -1338,8 +1338,7 @@ func (w *writer) compLit(lit *syntax.CompositeLit) { w.typ(tv.Type) typ := tv.Type - // TODO(mdempsky): Use types2.StructuralType here too? See #50833. - if ptr, ok := typ.Underlying().(*types2.Pointer); ok { + if ptr, ok := types2.StructuralType(typ).(*types2.Pointer); ok { typ = ptr.Elem() } str, isStruct := types2.StructuralType(typ).(*types2.Struct) diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go index 3d6d9153ee..7a668d20f1 100644 --- a/src/cmd/compile/internal/types2/expr.go +++ b/src/cmd/compile/internal/types2/expr.go @@ -1262,11 +1262,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin case hint != nil: // no composite literal type present - use hint (element type of enclosing type) typ = hint - base = typ - if !isTypeParam(typ) { - base = under(typ) - } - base, _ = deref(base) // *T implies &T{} + base, _ = deref(structuralType(typ)) // *T implies &T{} default: // TODO(gri) provide better error messages depending on context diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50833.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50833.go2 new file mode 100644 index 0000000000..e912e4d67d --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50833.go2 @@ -0,0 +1,16 @@ +// Copyright 2022 The Go 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 ( + S struct{ f int } + PS *S +) + +func a() []*S { return []*S{{f: 1}} } +func b() []PS { return []PS{{f: 1}} } + +func c[P *S]() []P { return []P{{f: 1}} } +func d[P PS]() []P { return []P{{f: 1}} } diff --git a/src/go/types/expr.go b/src/go/types/expr.go index 36f0f467be..44e0288d3e 100644 --- a/src/go/types/expr.go +++ b/src/go/types/expr.go @@ -1241,11 +1241,7 @@ func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind { case hint != nil: // no composite literal type present - use hint (element type of enclosing type) typ = hint - base = typ - if !isTypeParam(typ) { - base = under(typ) - } - base, _ = deref(base) // *T implies &T{} + base, _ = deref(structuralType(typ)) // *T implies &T{} default: // TODO(gri) provide better error messages depending on context diff --git a/src/go/types/testdata/fixedbugs/issue50833.go2 b/src/go/types/testdata/fixedbugs/issue50833.go2 new file mode 100644 index 0000000000..e912e4d67d --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50833.go2 @@ -0,0 +1,16 @@ +// Copyright 2022 The Go 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 ( + S struct{ f int } + PS *S +) + +func a() []*S { return []*S{{f: 1}} } +func b() []PS { return []PS{{f: 1}} } + +func c[P *S]() []P { return []P{{f: 1}} } +func d[P PS]() []P { return []P{{f: 1}} } diff --git a/test/typeparam/issue50833.go b/test/typeparam/issue50833.go new file mode 100644 index 0000000000..07c1a86a6a --- /dev/null +++ b/test/typeparam/issue50833.go @@ -0,0 +1,23 @@ +// run -gcflags=-G=3 + +// Copyright 2022 The Go 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 + +type ( + S struct{ f int } + PS *S +) + +func a() []*S { return []*S{{f: 1}} } +func b() []PS { return []PS{{f: 1}} } + +func c[P *S]() []P { return []P{{f: 1}} } +func d[P PS]() []P { return []P{{f: 1}} } + +func main() { + c[*S]() + d[PS]() +} From f5fe5a4524d5e5390238ae7f5abcaa4299b31a37 Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Wed, 26 Jan 2022 20:50:51 -0500 Subject: [PATCH 717/752] go/types: update interface receivers after substituting Interface method receivers are synthetic: they record either the interface type or the the defined type for which they are the RHS of the type declaration. When instantiating, we need to update these receivers accordingly. Fixes #50839 Change-Id: Icd8e1a2817b0135059d25d034b01b0ff5207641f Reviewed-on: https://go-review.googlesource.com/c/go/+/381174 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/api_test.go | 17 +++++- src/cmd/compile/internal/types2/named.go | 23 +++++++- src/cmd/compile/internal/types2/subst.go | 62 +++++++++++++++++++-- src/go/types/api_test.go | 17 +++++- src/go/types/named.go | 23 +++++++- src/go/types/subst.go | 62 +++++++++++++++++++-- 6 files changed, 188 insertions(+), 16 deletions(-) diff --git a/src/cmd/compile/internal/types2/api_test.go b/src/cmd/compile/internal/types2/api_test.go index b54f84dde0..80e998ebee 100644 --- a/src/cmd/compile/internal/types2/api_test.go +++ b/src/cmd/compile/internal/types2/api_test.go @@ -697,6 +697,19 @@ func TestUsesInfo(t *testing.T) { // Uses of methods are uses of the instantiated method. {`package m0; type N[A any] int; func (r N[B]) m() { r.n() }; func (N[C]) n() {}`, `n`, `func (m0.N[B]).n()`}, {`package m1; type N[A any] int; func (r N[B]) m() { }; var f = N[int].m`, `m`, `func (m1.N[int]).m()`}, + {`package m2; func _[A any](v interface{ m() A }) { v.m() }`, `m`, `func (interface).m() A`}, + {`package m3; func f[A any]() interface{ m() A } { return nil }; var _ = f[int]().m()`, `m`, `func (interface).m() int`}, + {`package m4; type T[A any] func() interface{ m() A }; var x T[int]; var y = x().m`, `m`, `func (interface).m() int`}, + {`package m5; type T[A any] interface{ m() A }; func _[B any](t T[B]) { t.m() }`, `m`, `func (m5.T[B]).m() B`}, + {`package m6; type T[A any] interface{ m() }; func _[B any](t T[B]) { t.m() }`, `m`, `func (m6.T[B]).m()`}, + {`package m7; type T[A any] interface{ m() A }; func _(t T[int]) { t.m() }`, `m`, `func (m7.T[int]).m() int`}, + {`package m8; type T[A any] interface{ m() }; func _(t T[int]) { t.m() }`, `m`, `func (m8.T[int]).m()`}, + {`package m9; type T[A any] interface{ m() }; func _(t T[int]) { _ = t.m }`, `m`, `func (m9.T[int]).m()`}, + { + `package m10; type E[A any] interface{ m() }; type T[B any] interface{ E[B]; n() }; func _(t T[int]) { t.m() }`, + `m`, + `func (m10.E[int]).m()`, + }, } for _, test := range tests { @@ -709,8 +722,10 @@ func TestUsesInfo(t *testing.T) { var use Object for id, obj := range info.Uses { if id.Value == test.obj { + if use != nil { + panic(fmt.Sprintf("multiple uses of %q", id.Value)) + } use = obj - break } } if use == nil { diff --git a/src/cmd/compile/internal/types2/named.go b/src/cmd/compile/internal/types2/named.go index ed33a9ddf7..5248893a4a 100644 --- a/src/cmd/compile/internal/types2/named.go +++ b/src/cmd/compile/internal/types2/named.go @@ -351,13 +351,30 @@ func expandNamed(ctxt *Context, n *Named, instPos syntax.Pos) (tparams *TypePara smap := makeSubstMap(n.orig.tparams.list(), n.targs.list()) underlying = n.check.subst(instPos, n.orig.underlying, smap, ctxt) + // If the underlying of n is an interface, we need to set the receiver of + // its methods accurately -- we set the receiver of interface methods on + // the RHS of a type declaration to the defined type. + if iface, _ := underlying.(*Interface); iface != nil { + if methods, copied := replaceRecvType(iface.methods, n.orig, n); copied { + // If the underlying doesn't actually use type parameters, it's possible + // that it wasn't substituted. In this case we need to create a new + // *Interface before modifying receivers. + if iface == n.orig.underlying { + iface = &Interface{ + embeddeds: iface.embeddeds, + complete: iface.complete, + implicit: iface.implicit, // should be false but be conservative + } + underlying = iface + } + iface.methods = methods + } + } } else { underlying = Typ[Invalid] } - mlist := newLazyMethodList(n.orig.methods.Len()) - - return n.orig.tparams, underlying, mlist + return n.orig.tparams, underlying, newLazyMethodList(n.orig.methods.Len()) } // safeUnderlying returns the underlying of typ without expanding instances, to diff --git a/src/cmd/compile/internal/types2/subst.go b/src/cmd/compile/internal/types2/subst.go index 4108f6aa85..f2e8fecc05 100644 --- a/src/cmd/compile/internal/types2/subst.go +++ b/src/cmd/compile/internal/types2/subst.go @@ -106,12 +106,24 @@ func (subst *subster) typ(typ Type) Type { return subst.tuple(t) case *Signature: - // TODO(gri) rethink the recv situation with respect to methods on parameterized types - // recv := subst.var_(t.recv) // TODO(gri) this causes a stack overflow - explain + // Preserve the receiver: it is handled during *Interface and *Named type + // substitution. + // + // Naively doing the substitution here can lead to an infinite recursion in + // the case where the receiver is an interface. For example, consider the + // following declaration: + // + // type T[A any] struct { f interface{ m() } } + // + // In this case, the type of f is an interface that is itself the receiver + // type of all of its methods. Because we have no type name to break + // cycles, substituting in the recv results in an infinite loop of + // recv->interface->recv->interface->... recv := t.recv + params := subst.tuple(t.params) results := subst.tuple(t.results) - if recv != t.recv || params != t.params || results != t.results { + if params != t.params || results != t.results { return &Signature{ rparams: t.rparams, // TODO(gri) why can't we nil out tparams here, rather than in instantiate? @@ -137,7 +149,21 @@ func (subst *subster) typ(typ Type) Type { methods, mcopied := subst.funcList(t.methods) embeddeds, ecopied := subst.typeList(t.embeddeds) if mcopied || ecopied { - iface := &Interface{methods: methods, embeddeds: embeddeds, implicit: t.implicit, complete: t.complete} + iface := &Interface{embeddeds: embeddeds, implicit: t.implicit, complete: t.complete} + // If we've changed the interface type, we may need to replace its + // receiver if the receiver type is the original interface. Receivers of + // *Named type are replaced during named type expansion. + // + // Notably, it's possible to reach here and not create a new *Interface, + // even though the receiver type may be parameterized. For example: + // + // type T[P any] interface{ m() } + // + // In this case the interface will not be substituted here, because its + // method signatures do not depend on the type parameter P, but we still + // need to create new interface methods to hold the instantiated + // receiver. This is handled by expandNamed. + iface.methods, _ = replaceRecvType(methods, t, iface) return iface } @@ -349,3 +375,31 @@ func (subst *subster) termlist(in []*Term) (out []*Term, copied bool) { } return } + +// replaceRecvType updates any function receivers that have type old to have +// type new. It does not modify the input slice; if modifications are required, +// the input slice and any affected signatures will be copied before mutating. +// +// The resulting out slice contains the updated functions, and copied reports +// if anything was modified. +func replaceRecvType(in []*Func, old, new Type) (out []*Func, copied bool) { + out = in + for i, method := range in { + sig := method.Type().(*Signature) + if sig.recv != nil && sig.recv.Type() == old { + if !copied { + // Allocate a new methods slice before mutating for the first time. + // This is defensive, as we may share methods across instantiations of + // a given interface type if they do not get substituted. + out = make([]*Func, len(in)) + copy(out, in) + copied = true + } + newsig := *sig + sig = &newsig + sig.recv = NewVar(sig.recv.pos, sig.recv.pkg, "", new) + out[i] = NewFunc(method.pos, method.pkg, method.name, sig) + } + } + return +} diff --git a/src/go/types/api_test.go b/src/go/types/api_test.go index 5c61e54360..5f4d48472c 100644 --- a/src/go/types/api_test.go +++ b/src/go/types/api_test.go @@ -689,6 +689,19 @@ func TestUsesInfo(t *testing.T) { // Uses of methods are uses of the instantiated method. {`package generic_m0; type N[A any] int; func (r N[B]) m() { r.n() }; func (N[C]) n() {}`, `n`, `func (generic_m0.N[B]).n()`}, {`package generic_m1; type N[A any] int; func (r N[B]) m() { }; var f = N[int].m`, `m`, `func (generic_m1.N[int]).m()`}, + {`package generic_m2; func _[A any](v interface{ m() A }) { v.m() }`, `m`, `func (interface).m() A`}, + {`package generic_m3; func f[A any]() interface{ m() A } { return nil }; var _ = f[int]().m()`, `m`, `func (interface).m() int`}, + {`package generic_m4; type T[A any] func() interface{ m() A }; var x T[int]; var y = x().m`, `m`, `func (interface).m() int`}, + {`package generic_m5; type T[A any] interface{ m() A }; func _[B any](t T[B]) { t.m() }`, `m`, `func (generic_m5.T[B]).m() B`}, + {`package generic_m6; type T[A any] interface{ m() }; func _[B any](t T[B]) { t.m() }`, `m`, `func (generic_m6.T[B]).m()`}, + {`package generic_m7; type T[A any] interface{ m() A }; func _(t T[int]) { t.m() }`, `m`, `func (generic_m7.T[int]).m() int`}, + {`package generic_m8; type T[A any] interface{ m() }; func _(t T[int]) { t.m() }`, `m`, `func (generic_m8.T[int]).m()`}, + {`package generic_m9; type T[A any] interface{ m() }; func _(t T[int]) { _ = t.m }`, `m`, `func (generic_m9.T[int]).m()`}, + { + `package generic_m10; type E[A any] interface{ m() }; type T[B any] interface{ E[B]; n() }; func _(t T[int]) { t.m() }`, + `m`, + `func (generic_m10.E[int]).m()`, + }, } for _, test := range tests { @@ -701,8 +714,10 @@ func TestUsesInfo(t *testing.T) { var use Object for id, obj := range info.Uses { if id.Name == test.obj { + if use != nil { + panic(fmt.Sprintf("multiple uses of %q", id.Name)) + } use = obj - break } } if use == nil { diff --git a/src/go/types/named.go b/src/go/types/named.go index a9d1eab24b..28db26014f 100644 --- a/src/go/types/named.go +++ b/src/go/types/named.go @@ -353,13 +353,30 @@ func expandNamed(ctxt *Context, n *Named, instPos token.Pos) (tparams *TypeParam smap := makeSubstMap(n.orig.tparams.list(), n.targs.list()) underlying = n.check.subst(instPos, n.orig.underlying, smap, ctxt) + // If the underlying of n is an interface, we need to set the receiver of + // its methods accurately -- we set the receiver of interface methods on + // the RHS of a type declaration to the defined type. + if iface, _ := underlying.(*Interface); iface != nil { + if methods, copied := replaceRecvType(iface.methods, n.orig, n); copied { + // If the underlying doesn't actually use type parameters, it's possible + // that it wasn't substituted. In this case we need to create a new + // *Interface before modifying receivers. + if iface == n.orig.underlying { + iface = &Interface{ + embeddeds: iface.embeddeds, + complete: iface.complete, + implicit: iface.implicit, // should be false but be conservative + } + underlying = iface + } + iface.methods = methods + } + } } else { underlying = Typ[Invalid] } - mlist := newLazyMethodList(n.orig.methods.Len()) - - return n.orig.tparams, underlying, mlist + return n.orig.tparams, underlying, newLazyMethodList(n.orig.methods.Len()) } // safeUnderlying returns the underlying of typ without expanding instances, to diff --git a/src/go/types/subst.go b/src/go/types/subst.go index b7e3b12779..0cce46ac46 100644 --- a/src/go/types/subst.go +++ b/src/go/types/subst.go @@ -106,12 +106,24 @@ func (subst *subster) typ(typ Type) Type { return subst.tuple(t) case *Signature: - // TODO(gri) rethink the recv situation with respect to methods on parameterized types - // recv := subst.var_(t.recv) // TODO(gri) this causes a stack overflow - explain + // Preserve the receiver: it is handled during *Interface and *Named type + // substitution. + // + // Naively doing the substitution here can lead to an infinite recursion in + // the case where the receiver is an interface. For example, consider the + // following declaration: + // + // type T[A any] struct { f interface{ m() } } + // + // In this case, the type of f is an interface that is itself the receiver + // type of all of its methods. Because we have no type name to break + // cycles, substituting in the recv results in an infinite loop of + // recv->interface->recv->interface->... recv := t.recv + params := subst.tuple(t.params) results := subst.tuple(t.results) - if recv != t.recv || params != t.params || results != t.results { + if params != t.params || results != t.results { return &Signature{ rparams: t.rparams, // TODO(rFindley) why can't we nil out tparams here, rather than in instantiate? @@ -137,7 +149,21 @@ func (subst *subster) typ(typ Type) Type { methods, mcopied := subst.funcList(t.methods) embeddeds, ecopied := subst.typeList(t.embeddeds) if mcopied || ecopied { - iface := &Interface{methods: methods, embeddeds: embeddeds, implicit: t.implicit, complete: t.complete} + iface := &Interface{embeddeds: embeddeds, implicit: t.implicit, complete: t.complete} + // If we've changed the interface type, we may need to replace its + // receiver if the receiver type is the original interface. Receivers of + // *Named type are replaced during named type expansion. + // + // Notably, it's possible to reach here and not create a new *Interface, + // even though the receiver type may be parameterized. For example: + // + // type T[P any] interface{ m() } + // + // In this case the interface will not be substituted here, because its + // method signatures do not depend on the type parameter P, but we still + // need to create new interface methods to hold the instantiated + // receiver. This is handled by expandNamed. + iface.methods, _ = replaceRecvType(methods, t, iface) return iface } @@ -349,3 +375,31 @@ func (subst *subster) termlist(in []*Term) (out []*Term, copied bool) { } return } + +// replaceRecvType updates any function receivers that have type old to have +// type new. It does not modify the input slice; if modifications are required, +// the input slice and any affected signatures will be copied before mutating. +// +// The resulting out slice contains the updated functions, and copied reports +// if anything was modified. +func replaceRecvType(in []*Func, old, new Type) (out []*Func, copied bool) { + out = in + for i, method := range in { + sig := method.Type().(*Signature) + if sig.recv != nil && sig.recv.Type() == old { + if !copied { + // Allocate a new methods slice before mutating for the first time. + // This is defensive, as we may share methods across instantiations of + // a given interface type if they do not get substituted. + out = make([]*Func, len(in)) + copy(out, in) + copied = true + } + newsig := *sig + sig = &newsig + sig.recv = NewVar(sig.recv.pos, sig.recv.pkg, "", new) + out[i] = NewFunc(method.pos, method.pkg, method.name, sig) + } + } + return +} From ad345c265916bbf6c646865e4642eafce6d39e78 Mon Sep 17 00:00:00 2001 From: Katie Hockman Date: Wed, 19 Jan 2022 16:54:41 -0500 Subject: [PATCH 718/752] math/big: prevent overflow in (*Rat).SetString Credit to rsc@ for the original patch. Thanks to the OSS-Fuzz project for discovering this issue and to Emmanuel Odeke (@odeke_et) for reporting it. Fixes #50699 Fixes CVE-2022-23772 Change-Id: I590395a3d55689625390cf1e58f5f40623b26ee5 Reviewed-on: https://go-review.googlesource.com/c/go/+/379537 Trust: Katie Hockman Run-TryBot: Katie Hockman TryBot-Result: Gopher Robot Reviewed-by: Emmanuel Odeke Reviewed-by: Roland Shoemaker Reviewed-by: Julie Qiu --- src/math/big/ratconv.go | 5 +++++ src/math/big/ratconv_test.go | 1 + 2 files changed, 6 insertions(+) diff --git a/src/math/big/ratconv.go b/src/math/big/ratconv.go index ac3c8bd11f..90053a9c81 100644 --- a/src/math/big/ratconv.go +++ b/src/math/big/ratconv.go @@ -169,6 +169,11 @@ func (z *Rat) SetString(s string) (*Rat, bool) { n := exp5 if n < 0 { n = -n + if n < 0 { + // This can occur if -n overflows. -(-1 << 63) would become + // -1 << 63, which is still negative. + return nil, false + } } if n > 1e6 { return nil, false // avoid excessively large exponents diff --git a/src/math/big/ratconv_test.go b/src/math/big/ratconv_test.go index 15d206cb38..e55e655718 100644 --- a/src/math/big/ratconv_test.go +++ b/src/math/big/ratconv_test.go @@ -104,6 +104,7 @@ var setStringTests = []StringTest{ {in: "4/3/"}, {in: "4/3."}, {in: "4/"}, + {in: "13e-9223372036854775808"}, // CVE-2022-23772 // valid {"0", "0", true}, From 9ff00398489d9eb1822b3de028cd6ccf5674ebb3 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 27 Jan 2022 15:00:57 -0800 Subject: [PATCH 719/752] go/types, types2: delete _TypeSet.includes - not used (cleanup) Change-Id: Ia324c6185e36efd4ea7dc92d7c2233fec8f5a55f Reviewed-on: https://go-review.googlesource.com/c/go/+/381494 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/typeset.go | 5 ----- src/go/types/typeset.go | 5 ----- 2 files changed, 10 deletions(-) diff --git a/src/cmd/compile/internal/types2/typeset.go b/src/cmd/compile/internal/types2/typeset.go index 348b8150d3..7a1e1bdf2f 100644 --- a/src/cmd/compile/internal/types2/typeset.go +++ b/src/cmd/compile/internal/types2/typeset.go @@ -107,11 +107,6 @@ func (s *_TypeSet) hasTerms() bool { return !s.terms.isEmpty() && !s.terms.isAll // singleType returns the single type in s if there is exactly one; otherwise the result is nil. func (s *_TypeSet) singleType() Type { return s.terms.singleType() } -// includes reports whether t ∈ s. -// TODO(gri) This function is not used anywhere anymore. Remove once we -// are clear that we don't need it elsewhere in the future. -func (s *_TypeSet) includes(t Type) bool { return s.terms.includes(t) } - // subsetOf reports whether s1 ⊆ s2. func (s1 *_TypeSet) subsetOf(s2 *_TypeSet) bool { return s1.terms.subsetOf(s2.terms) } diff --git a/src/go/types/typeset.go b/src/go/types/typeset.go index 2317177f03..4598daacb0 100644 --- a/src/go/types/typeset.go +++ b/src/go/types/typeset.go @@ -105,11 +105,6 @@ func (s *_TypeSet) hasTerms() bool { return !s.terms.isEmpty() && !s.terms.isAll // singleType returns the single type in s if there is exactly one; otherwise the result is nil. func (s *_TypeSet) singleType() Type { return s.terms.singleType() } -// includes reports whether t ∈ s. -// TODO(gri) This function is not used anywhere anymore. Remove once we -// are clear that we don't need it elsewhere in the future. -func (s *_TypeSet) includes(t Type) bool { return s.terms.includes(t) } - // subsetOf reports whether s1 ⊆ s2. func (s1 *_TypeSet) subsetOf(s2 *_TypeSet) bool { return s1.terms.subsetOf(s2.terms) } From 8314544bd6b3c5f0bee89a6bd411ced0aeba1a8c Mon Sep 17 00:00:00 2001 From: Than McIntosh Date: Tue, 25 Jan 2022 09:34:35 -0500 Subject: [PATCH 720/752] debug/dwarf: fix problems with handling of bit offsets for bitfields This patch reworks the handling of the DWARF DW_AT_bit_offset and DW_AT_data_bit_offset attributes to resolve problems arising from a previous related change (CL 328709). In CL 328709 the DWARF type reader was updated to look for and use the DW_AT_data_bit_offset attribute for structure fields, handling the value of the attribute in the same way as for DW_AT_bit_offset. This caused problems for clients, since the two attributes have very different semantics. This CL effectively reverts CL 328709 and moves to a scheme in which we detect and report the two attributes separately/independently. This patch also corrects a problem in the DWARF type reader in the code that detects and fixes up the type of struct fields corresponding to zero-length arrays; the code in question was testing the DW_AT_bit_offset attribute value but assuming DW_AT_data_bit_offset semantics, meaning that it would fail to fix up cases such as typedef struct another_struct { unsigned short quix; int xyz[0]; unsigned x:1; long long array[40]; } t; The code in question has been changed to avoid using BitOffset and instead consider only ByteOffset and BitSize. Fixes #50685. Updates #46784. Change-Id: Ic15ce01c851af38ebd81af827973ec49badcab6f Reviewed-on: https://go-review.googlesource.com/c/go/+/380714 Trust: Than McIntosh Run-TryBot: Than McIntosh TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- api/go1.18.txt | 2 + src/debug/dwarf/testdata/bitfields.c | 17 +++ src/debug/dwarf/testdata/bitfields.elf4 | Bin 0 -> 2464 bytes src/debug/dwarf/testdata/typedef.elf5 | Bin 0 -> 6016 bytes src/debug/dwarf/type.go | 144 ++++++++++++++++++++---- src/debug/dwarf/type_test.go | 89 ++++++++++++--- 6 files changed, 211 insertions(+), 41 deletions(-) create mode 100644 src/debug/dwarf/testdata/bitfields.c create mode 100644 src/debug/dwarf/testdata/bitfields.elf4 create mode 100644 src/debug/dwarf/testdata/typedef.elf5 diff --git a/api/go1.18.txt b/api/go1.18.txt index afcb31c638..7805d29eb7 100644 --- a/api/go1.18.txt +++ b/api/go1.18.txt @@ -13,6 +13,8 @@ pkg debug/buildinfo, func ReadFile(string) (*debug.BuildInfo, error) pkg debug/buildinfo, type BuildInfo = debug.BuildInfo pkg debug/elf, const R_PPC64_RELATIVE = 22 pkg debug/elf, const R_PPC64_RELATIVE R_PPC64 +pkg debug/dwarf, type BasicType struct, DataBitOffset int64 +pkg debug/dwarf, type StructField struct, DataBitOffset int64 pkg debug/plan9obj, var ErrNoSymbols error pkg go/ast, method (*IndexListExpr) End() token.Pos pkg go/ast, method (*IndexListExpr) Pos() token.Pos diff --git a/src/debug/dwarf/testdata/bitfields.c b/src/debug/dwarf/testdata/bitfields.c new file mode 100644 index 0000000000..05833336c9 --- /dev/null +++ b/src/debug/dwarf/testdata/bitfields.c @@ -0,0 +1,17 @@ +// Copyright 2022 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +/* +Linux ELF: +gcc -gdwarf-4 -m64 -c bitfields.c -o bitfields.elf4 +*/ + +typedef struct another_struct { + unsigned short quix; + int xyz[0]; + unsigned x:1; + long long array[40]; +} t_another_struct; +t_another_struct q2; + diff --git a/src/debug/dwarf/testdata/bitfields.elf4 b/src/debug/dwarf/testdata/bitfields.elf4 new file mode 100644 index 0000000000000000000000000000000000000000..2e06e68ce9dded2509e1dae216322d9409cbd070 GIT binary patch literal 2464 zcmbtWON$dh5U$S4?9L`;3BK?(ilU;KY?gIdl-0ocS`_i(Ng+&<-t1s@qB9*$_M+fH zJb6?EAK=A5;6>1*zra7CC-o!NKCD;hBQO`&_FVm)^u2_oXImRZhqD+&)EK(se7_I}GYLS{904v-fjqT1v zLB)G$<{_8bfD$$gkp+YhgIr#s6Pc{%3&>@nn1|@0&m_ehz#!SLg$A&VJCRS_m<3jP zirR!+ggn5e+5TeLN*A{mOIrX^WtJ{l*<;pmiSj)4Q~cM|452Rs|h!KX~>z7 zw9_#02Ym83ynx6weEDH3&pCbh;wOlst5>25RtdvJV?L4!ERC22T4UYD8kx&lP3&4g9gP?;5x=LHqT--YLg3BmTa! zUnxn)s?U%hty7)oiV=$Bgu^xAHc^TolB-%1d?3J)bLcd~5S)N_T}RGo!}C{q=%bl! zxXot3Z~o$T1K00xOo<}8p3k+8)xl}?*48*qw1anrJ9sB6p>SK*qL%)LZ^vYF?^Lf& zEP?d+Y1bZ92#e1g`Rc?H$jm>0G4y!-Ykm!L&6>1qofy*FNQ}4{djvf+&-GD6q`XuO zT~Y}&rxd3jT78ce5i@I2h3~|W^xQ?(@3C|rlJcJ@(AJ4cnz82*PwM}xx}>^K>YsiI z&Hm}$nKcoDHwvWliIW*iBS_dxJP7pwGP5qCYABO)5&P{3ZXk$~VH`qsljN zy{^W|P73{`z?Uizf3W47V4fenOm}*R5Sl4?e@uM literal 0 HcmV?d00001 diff --git a/src/debug/dwarf/testdata/typedef.elf5 b/src/debug/dwarf/testdata/typedef.elf5 new file mode 100644 index 0000000000000000000000000000000000000000..aec48f64522f651a2b5c341c4b6c0badf92c2801 GIT binary patch literal 6016 zcmbuCc|6tG8^^!*TCy(@ku2HCt(V~=QDK#;ghTl2YbNs%YF@OEe>vcWnd7sboobx@~_iNpP03R-g z!;r#ZJemJ_gffiRWL8~T^V$T&%9cwJDS(ikn+M?95eXdx`b~#ZVhL}W;d4KweN1{h&42u4wMI2{+bavI;^B; zyWGci|JCo}Ubp=1+wOjUR@bS(!?`|MCYxMcvO1$ZD^upH+sr=TY_<2(yoHOhloJb{ zCiYez%kZ7w;WV-_?vs-@UI!E=4&N<)ReE;a@RX<9K3sk5y0NX`Z<8A}wT`lfe#nV& zdEc*EdEVY2$svO((cw0y_pMVm$+}!^uMVkwZTCWFp^b%pYWp3%)D^pz&ok)yBjiq8 z{jiFR;-JTmp_Ml+Th38#m>{^|v!hDg4Zvu9QXuY$3<&%OHAq}?GzE9FOnxsxLO`omYQq$+vf2i-P&M-S>&dBS`zpI{__g%N& z^jOE>v_ZqV`l))s@ip7mIJEGd-}4{H^{?6gT>JZ)2j-Qmf^YRd+o@|9YQ6UZQOdPj-u7)nn{=njbBC1z>dtPzI7xiYpqE>*X=F=(nEV3Q z>D8Aa);B9u^uMvqvsCeSxKVn|?0HGERlrcJaEXp=TZ%K^GS6K8R#Xaam9NEa-o=)H zq0<3h)SFE@)~8(FZujww!tVt?Prs4(vS z_lBaQo?qA#8@|0gM2xj&bx@~xO>#U-Lzv7siIX(0B!*4EZEjd`K``%9Oi?r24 zM@O7OgF4^)xzIhdLmbSlIb$Ug^K4-61GnrxxepAj%s1HVSX}q!+0)*ny4B`Qi5ZWU ziKjO?j%?IA^Go4cUnMu+-=orGu4`5{wb~AjR49MmSREd}{@rihm`)oz*5mWwK>3o2 z4nagjL?pvelaFq?oHLzalo`f55Xs~i1;z$h4u|uXnkqJU^3V@ejHL6(RUU@?$#G2Ezj)2Xs{9_&FXbjv zyMBx)xnFYOZm2?6TK7e{D8(Zm)Qg-goIRrhOn&)(YeS{+@%*w%!}puKcFw(2ed5R; z)7O^I>VC6zt4{DmH}x|KYdt;k6nf8Bp)KaxWYH;(qp9*sAOouBF*4=d6&+$`M-Y?0URD=D0}M*48;A z+dSn}pn2h^>+Eb!=tW=N&=9^|t0b2{U};!#WlqU?8~yY%_S#3L$@CSk{Ceg$M$8_q z=J9oorsi8xVOuqG;bOnV9gAYx?RkOxYqbGC{cO+k?+o%=Y_s_1AnTx+{vGyyc0517 znSN$Ieu{VI$SN~>V$(~E@4R{L##Zx%k@12gV?Lkf$aApcJ6c0^tRq=ujL{FjMtlR8 zGHA)0Fe8NnK3Q*VXy9Z9GaQKqXPU|+g)OMj0CD`o1#LuznX9I;fjduC-UkV=|1SmS zm1PD-Cu)`%pOv>;Wl+RKMTU`|2s1K_;=gd|NdM6$!>Ig&VWlR@L<)H(HQ>Z27Qe=^ zUIPLMp8|X;#j%g|#uUf*0OnQ{Hv~@Z1(M$cxGSYM1MWp}oEPU`Nb#A#mrxw{hxN-S zJ{x!h#od9&QQQ-F3dOyFODOIGJcr``zzZmjFG4)dEffz%{$$p^8s7opj1*zCFoqY! z2pk!~ECC~MVg$1pfioj;VFa#>z>N{`9ng=Den`Q0L=wJZB>FQ8{g9ZC)O;l8BR$`h zNfg8;3x^zFarWEv9E;;;CZ&hP$M0CwIK<-Y zx2y(Sj<{cPH{x8@ERNr`qOvBWuaxQ(1g2i|euYN){*Y z4%{3MoILMc*bics9*{H}zVmUxdRS7aPv#ttldYd2Z5`9&_nIB}_&Wm^oCotI*g=Iq zX2$sn@IAoN`Hg|&KH2>;ywr?Du^Nw?h)*lY}G$bwR2ahfDpa 0 { s += " : " + strconv.FormatInt(f.BitSize, 10) - s += "@" + strconv.FormatInt(f.BitOffset, 10) + s += "@" + strconv.FormatInt(f.bitOffset(), 10) } } s += "}" @@ -469,8 +554,12 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off // AttrName: name of base type in programming language of the compilation unit [required] // AttrEncoding: encoding value for type (encFloat etc) [required] // AttrByteSize: size of type in bytes [required] - // AttrBitOffset: for sub-byte types, size in bits - // AttrBitSize: for sub-byte types, bit offset of high order bit in the AttrByteSize bytes + // AttrBitOffset: bit offset of value within containing storage unit + // AttrDataBitOffset: bit offset of value within containing storage unit + // AttrBitSize: size in bits + // + // For most languages BitOffset/DataBitOffset/BitSize will not be present + // for base types. name, _ := e.Val(AttrName).(string) enc, ok := e.Val(AttrEncoding).(int64) if !ok { @@ -517,8 +606,12 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off t.Name = name t.BitSize, _ = e.Val(AttrBitSize).(int64) haveBitOffset := false - if t.BitOffset, haveBitOffset = e.Val(AttrBitOffset).(int64); !haveBitOffset { - t.BitOffset, _ = e.Val(AttrDataBitOffset).(int64) + haveDataBitOffset := false + t.BitOffset, haveBitOffset = e.Val(AttrBitOffset).(int64) + t.DataBitOffset, haveDataBitOffset = e.Val(AttrDataBitOffset).(int64) + if haveBitOffset && haveDataBitOffset { + err = DecodeError{name, e.Offset, "duplicate bit offset attributes"} + goto Error } case TagClassType, TagStructType, TagUnionType: @@ -533,6 +626,7 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off // AttrType: type of member [required] // AttrByteSize: size in bytes // AttrBitOffset: bit offset within bytes for bit fields + // AttrDataBitOffset: field bit offset relative to struct start // AttrBitSize: bit size for bit fields // AttrDataMemberLoc: location within struct [required for struct, class] // There is much more to handle C++, all ignored for now. @@ -551,7 +645,8 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off t.Incomplete = e.Val(AttrDeclaration) != nil t.Field = make([]*StructField, 0, 8) var lastFieldType *Type - var lastFieldBitOffset int64 + var lastFieldBitSize int64 + var lastFieldByteOffset int64 for kid := next(); kid != nil; kid = next() { if kid.Tag != TagMember { continue @@ -578,30 +673,31 @@ func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Off f.ByteOffset = loc } - haveBitOffset := false f.Name, _ = kid.Val(AttrName).(string) f.ByteSize, _ = kid.Val(AttrByteSize).(int64) - if f.BitOffset, haveBitOffset = kid.Val(AttrBitOffset).(int64); !haveBitOffset { - f.BitOffset, haveBitOffset = kid.Val(AttrDataBitOffset).(int64) + haveBitOffset := false + haveDataBitOffset := false + f.BitOffset, haveBitOffset = kid.Val(AttrBitOffset).(int64) + f.DataBitOffset, haveDataBitOffset = kid.Val(AttrDataBitOffset).(int64) + if haveBitOffset && haveDataBitOffset { + err = DecodeError{name, e.Offset, "duplicate bit offset attributes"} + goto Error } f.BitSize, _ = kid.Val(AttrBitSize).(int64) t.Field = append(t.Field, f) - bito := f.BitOffset - if !haveBitOffset { - bito = f.ByteOffset * 8 - } - if bito == lastFieldBitOffset && t.Kind != "union" { + if lastFieldBitSize == 0 && lastFieldByteOffset == f.ByteOffset && t.Kind != "union" { // Last field was zero width. Fix array length. // (DWARF writes out 0-length arrays as if they were 1-length arrays.) fixups.recordArrayType(lastFieldType) } lastFieldType = &f.Type - lastFieldBitOffset = bito + lastFieldByteOffset = f.ByteOffset + lastFieldBitSize = f.BitSize } if t.Kind != "union" { b, ok := e.Val(AttrByteSize).(int64) - if ok && b*8 == lastFieldBitOffset { + if ok && b == lastFieldByteOffset { // Final field must be zero width. Fix array length. fixups.recordArrayType(lastFieldType) } diff --git a/src/debug/dwarf/type_test.go b/src/debug/dwarf/type_test.go index 431d0853e0..0acc606df7 100644 --- a/src/debug/dwarf/type_test.go +++ b/src/debug/dwarf/type_test.go @@ -83,15 +83,19 @@ func peData(t *testing.T, name string) *Data { return d } -func TestTypedefsELF(t *testing.T) { testTypedefs(t, elfData(t, "testdata/typedef.elf"), "elf") } - -func TestTypedefsMachO(t *testing.T) { - testTypedefs(t, machoData(t, "testdata/typedef.macho"), "macho") +func TestTypedefsELF(t *testing.T) { + testTypedefs(t, elfData(t, "testdata/typedef.elf"), "elf", typedefTests) } -func TestTypedefsELFDwarf4(t *testing.T) { testTypedefs(t, elfData(t, "testdata/typedef.elf4"), "elf") } +func TestTypedefsMachO(t *testing.T) { + testTypedefs(t, machoData(t, "testdata/typedef.macho"), "macho", typedefTests) +} -func testTypedefs(t *testing.T, d *Data, kind string) { +func TestTypedefsELFDwarf4(t *testing.T) { + testTypedefs(t, elfData(t, "testdata/typedef.elf4"), "elf", typedefTests) +} + +func testTypedefs(t *testing.T, d *Data, kind string, testcases map[string]string) { r := d.Reader() seen := make(map[string]bool) for { @@ -115,7 +119,7 @@ func testTypedefs(t *testing.T, d *Data, kind string) { typstr = t1.Type.String() } - if want, ok := typedefTests[t1.Name]; ok { + if want, ok := testcases[t1.Name]; ok { if seen[t1.Name] { t.Errorf("multiple definitions for %s", t1.Name) } @@ -130,7 +134,7 @@ func testTypedefs(t *testing.T, d *Data, kind string) { } } - for k := range typedefTests { + for k := range testcases { if !seen[k] { t.Errorf("missing %s", k) } @@ -229,21 +233,42 @@ func TestUnsupportedTypes(t *testing.T) { } } -func TestBitOffsetsELF(t *testing.T) { testBitOffsets(t, elfData(t, "testdata/typedef.elf")) } +var expectedBitOffsets1 = map[string]string{ + "x": "S:1 DBO:32", + "y": "S:4 DBO:33", +} + +var expectedBitOffsets2 = map[string]string{ + "x": "S:1 BO:7", + "y": "S:4 BO:27", +} + +func TestBitOffsetsELF(t *testing.T) { + f := "testdata/typedef.elf" + testBitOffsets(t, elfData(t, f), f, expectedBitOffsets2) +} func TestBitOffsetsMachO(t *testing.T) { - testBitOffsets(t, machoData(t, "testdata/typedef.macho")) + f := "testdata/typedef.macho" + testBitOffsets(t, machoData(t, f), f, expectedBitOffsets2) } func TestBitOffsetsMachO4(t *testing.T) { - testBitOffsets(t, machoData(t, "testdata/typedef.macho4")) + f := "testdata/typedef.macho4" + testBitOffsets(t, machoData(t, f), f, expectedBitOffsets1) } func TestBitOffsetsELFDwarf4(t *testing.T) { - testBitOffsets(t, elfData(t, "testdata/typedef.elf4")) + f := "testdata/typedef.elf4" + testBitOffsets(t, elfData(t, f), f, expectedBitOffsets1) } -func testBitOffsets(t *testing.T, d *Data) { +func TestBitOffsetsELFDwarf5(t *testing.T) { + f := "testdata/typedef.elf5" + testBitOffsets(t, elfData(t, f), f, expectedBitOffsets1) +} + +func testBitOffsets(t *testing.T, d *Data, tag string, expectedBitOffsets map[string]string) { r := d.Reader() for { e, err := r.Next() @@ -262,15 +287,26 @@ func testBitOffsets(t *testing.T, d *Data) { t1 := typ.(*StructType) + bitInfoDump := func(f *StructField) string { + res := fmt.Sprintf("S:%d", f.BitSize) + if f.BitOffset != 0 { + res += fmt.Sprintf(" BO:%d", f.BitOffset) + } + if f.DataBitOffset != 0 { + res += fmt.Sprintf(" DBO:%d", f.DataBitOffset) + } + return res + } + for _, field := range t1.Field { // We're only testing for bitfields if field.BitSize == 0 { continue } - - // Ensure BitOffset is not zero - if field.BitOffset == 0 { - t.Errorf("bit offset of field %s in %s %s is not set", field.Name, t1.Kind, t1.StructName) + got := bitInfoDump(field) + want := expectedBitOffsets[field.Name] + if got != want { + t.Errorf("%s: field %s in %s: got info %q want %q", tag, field.Name, t1.StructName, got, want) } } } @@ -279,3 +315,22 @@ func testBitOffsets(t *testing.T, d *Data) { } } } + +var bitfieldTests = map[string]string{ + "t_another_struct": "struct another_struct {quix short unsigned int@0; xyz [0]int@4; x unsigned int@4 : 1@31; array [40]long long int@8}", +} + +// TestBitFieldZeroArrayIssue50685 checks to make sure that the DWARF +// type reading code doesn't get confused by the presence of a +// specifically-sized bitfield member immediately following a field +// whose type is a zero-length array. Prior to the fix for issue +// 50685, we would get this type for the case in testdata/bitfields.c: +// +// another_struct {quix short unsigned int@0; xyz [-1]int@4; x unsigned int@4 : 1@31; array [40]long long int@8} +// +// Note the "-1" for the xyz field, which should be zero. +// +func TestBitFieldZeroArrayIssue50685(t *testing.T) { + f := "testdata/bitfields.elf4" + testTypedefs(t, elfData(t, f), "elf", bitfieldTests) +} From 654d5f4b5dfc30167bbffd0d7aeba3c1e29277c8 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 30 Nov 2021 09:29:45 -0800 Subject: [PATCH 721/752] spec: add section on type inference Change-Id: Ic338788d6410ed0d09ad129811377ee9ce5ed496 Reviewed-on: https://go-review.googlesource.com/c/go/+/367954 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 385 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 382 insertions(+), 3 deletions(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index b25cf5fa6e..c653cbffc0 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1,6 +1,6 @@ @@ -4128,8 +4128,8 @@ with the same underlying array.

    Instantiations

    -A parameterized function or type is instantiated by substituting -type arguments for the type parameters. +A parameterized function or type is instantiated by substituting type arguments +for the type parameters. Instantiation proceeds in two phases:

    @@ -4201,6 +4201,385 @@ b := min[float64](2.0, 3) // b has value 2.0 of type float64 c := min(b, -1) // c has value -1.0 of type float64 +

    Type inference

    + +

    +Missing type arguments may be inferred by a series of steps, described below. +Each step attempts to use known information to infer additional type arguments. +Type inference stops as soon as all type arguments are known. +After type inference is complete, it is still necessary to substitute all type arguments +for type parameters and verify that each type argument implements the relevant constraint; +it is possible for an inferred type argument to fail to implement a constraint, in which +case instantiation fails. +

    + +

    +Type inference is based on +

    + +
      +
    • + a type parameter list +
      • +
    • + a substitution map M initialized with the known type arguments, if any +
      • +
    • + a (possibly empty) list of ordinary function arguments (in case of a function call only) +
      • +
    + +

    +and then proceeds with the following steps: +

    + +
      +
    1. + apply function argument type inference + to all typed ordinary function arguments +
      2. +
    2. + apply constraint type inference +
      3. +
    3. + apply function argument type inference to all untyped ordinary function arguments + using the default type for each of the untyped function arguments +
      4. +
    4. + apply constraint type inference +
      5. +
    + +

    +If there are no ordinary or untyped function arguments, the respective steps are skipped. +Constraint type inference is skipped if the previous step didn't infer any new type arguments, +but it is run at least once if there are missing type arguments. +

    + +

    +The substitution map M is carried through all steps, and each step may add entries to M. +The process stops as soon as M has a type argument for each type parameter or if an inference step fails. +If an inference step fails, or if M is still missing type arguments after the last step, type inference fails. +

    + +

    Type unification

    + +

    +Type inference is based on type unification. A single unification step +applies to a substitution map and two types, either +or both of which may be or contain type parameters. The substitution map tracks +the known (explicitly provided or already inferred) type arguments: the map +contains an entry P → A for each type +parameter P and corresponding known type argument A. +During unification, known type arguments take the place of their corresponding type +parameters when comparing types. Unification is the process of finding substitution +map entries that make the two types equivalent. +

    + +

    +For unification, two types that don't contain any type parameters from the current type +parameter list are equivalent +if they are identical, or if they are channel types that are identical ignoring channel +direction, or if their underlying types are equivalent. +

    + +

    +Unification works by comparing the structure of pairs of types: their structure +disregarding type parameters must be identical, and types other than type parameters +must be equivalent. +A type parameter in one type may match any complete subtype in the other type; +each successful match causes an entry to be added to the substitution map. +If the structure differs, or types other than type parameters are not equivalent, +unification fails. +

    + + + +

    +For example, if T1 and T2 are type parameters, +[]map[int]bool can be unified with any of the following: +

    + +
    +[]map[int]bool   // types are identical
+T1               // adds T1 → []map[int]bool to substitution map
+[]T1             // adds T1 → map[int]bool to substitution map
+[]map[T1]T2      // adds T1 → int and T2 → bool to substitution map
+
    + +

    +On the other hand, []map[int]bool cannot be unified with any of +

    + +
    +int              // int is not a slice
+struct{}         // a struct is not a slice
+[]struct{}       // a struct is not a map
+[]map[T1]string  // map element types don't match
+
    + +

    +As an exception to this general rule, because a defined type +D and a type literal L are never equivalent, +unification compares the underlying type of D with L instead. +For example, given the defined type +

    + +
    +type Vector []float64
+
    + +

    +and the type literal []E, unification compares []float64 with +[]E and adds an entry E → float64 to +the substitution map. +

    + +

    Function argument type inference

    + + + +

    +Function argument type inference infers type arguments from function arguments: +if a function parameter is declared with a type T that uses +type parameters, +unifying the type of the corresponding +function argument with T may infer type arguments for the type +parameters used by T. +

    + +

    +For instance, given the type-parameterized function +

    + +
    +func scale[Number ~int64|~float64|~complex128](v []Number, s Number) []Number
+
    + +

    +and the call +

    + +
    +var vector []float64
+scaledVector := scale(vector, 42)
+
    + +

    +the type argument for Number can be inferred from the function argument +vector by unifying the type of vector with the corresponding +parameter type: []float64 and []Number +match in structure and float64 matches with Number. +This adds the entry Number → float64 to the +substitution map. +Untyped arguments, such as the second function argument 42 here, are ignored +in the first round of function argument type inference and only considered if there are +unresolved type parameters left. +

    + +

    +Function argument type inference can be used when the function has ordinary parameters +whose types are defined using the function's type parameters. Inference happens in two +separate phases; each phase operates on a specific list of (parameter, argument) pairs: +

    + +
      +
    1. + The list Lt contains all (parameter, argument) pairs where the parameter + type uses type parameters and where the function argument is typed. +
      2. +
    2. + The list Lu contains all remaining pairs where the parameter type is a single + type parameter. In this list, the respective function arguments are untyped. +
      3. +
    + +

    +Any other (parameter, argument) pair is ignored. +

    + +

    +By construction, the arguments of the pairs in Lu are untyped constants +(or the untyped boolean result of a comparison). And because default types +of untyped values are always predeclared non-composite types, they can never match against +a composite type, so it is sufficient to only consider parameter types that are single type +parameters. +

    + +

    +Each list is processed in a separate phase: +

    + +
      +
    1. + In the first phase, the parameter and argument types of each pair in Lt + are unified. If unification succeeds for a pair, it may yield new entries that + are added to the substitution map M. If unification fails, type inference + fails. +
      2. +
    2. + The second phase considers the entries of list Lu. Type parameters for + which the type argument has already been determined are ignored in this phase. + For each remaining pair, the parameter type (which is a single type parameter) and + the default type of the corresponding untyped argument is + unified. If unification fails, type inference fails. +
      3. +
    + +

    +Example: +

    + +
    +func min[T constraints.Ordered](x, y T) T
+
+var x int
+min(x, 2.0)    // T is int, inferred from typed argument x; 2.0 is assignable to int
+min(1.0, 2.0)  // T is float64, inferred from default type for 1.0 and matches default type for 2.0
+min(1.0, 2)    // illegal: default type float64 (for 1.0) doesn't match default type int (for 2)
+
    + +

    Constraint type inference

    + + + +

    +Constraint type inference infers type arguments from already known +type arguments by considering structural type constraints: +if the structural type T of a structural constraint is parameterized, +unifying a known type argument with T may +infer type arguments for other type parameters used by the structural type. +

    + +

    +For instance, consider the type parameter list with type parameters List and +Elem: +

    + +
    +[List ~[]Elem, Elem any]
+
    + +

    +Constraint type inference can deduce the type of Elem from the type argument +for List because Elem is a type parameter in the structural constraint +~[]Elem for List. +If the type argument is Bytes: +

    + +
    +type Bytes []byte
+
    + +

    +unifying the underlying type of Bytes with the structural constraint means +unifying []byte with []Elem. That unification succeeds and yields +the substitution map entry +Elem → byte. +Thus, in this example, constraint type inference can infer the second type argument from the +first one. +

    + +

    +Generally, constraint type inference proceeds in two phases: Starting with a given +substitution map M +

    + +
      +
    1. +For all type parameters with a structural constraint, unify the type parameter with the structural +type of its constraint. If any unification fails, constraint type inference fails. +
      2. + +
    2. +At this point, some entries in M may map type parameters to other +type parameters or to types containing type parameters. For each entry +P → A in M where A is or +contains type parameters Q for which there exist entries +Q → B in M, substitute those +Q with the respective B in A. +Stop when no further substitution is possible. +
      3. +
    + +

    +The result of constraint type inference is the final substitution map M from type +parameters P to type arguments A where no type parameter P +appears in any of the A. +

    + +

    +For instance, given the type parameter list +

    + +
    +[A any, B []C, C *A]
+
    + +

    +and the single provided type argument int for type parameter A, +the initial substitution map M contains the entry A → int. +

    + +

    +In the first phase, the type parameters B and C are unified +with the structural type of their respective constraints. This adds the entries +B → []C and C → *A +to M. + +

    +At this point there are two entries in M where the right-hand side +is or contains type parameters for which there exists other entries in M: +[]C and *A. +In the second phase, these type parameters are replaced with their respective +types. It doesn't matter in which order this happens. Starting with the state +of M after the first phase: +

    + +

    +A → int, +B → []C, +C → *A +

    + +

    +Replace A on the right-hand side of → with int: +

    + +

    +A → int, +B → []C, +C → *int +

    + +

    +Replace C on the right-hand side of → with *int: +

    + +

    +A → int, +B → []*int, +C → *int +

    + +

    +At this point no further substitution is possible and the map is full. +Therefore, M represents the final map of type parameters +to type arguments for the given type parameter list. +

    +

    Operators

    From 2e30c4b4bb7c4426ebc27e8af6d0570dbd97054b Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 27 Jan 2022 10:28:46 -0800 Subject: [PATCH 722/752] go/types, types2: better error reporting for Checker.implements This CL copies (and adjusts as needed) the logic for error reporting from operand.assignableTo to Checker.implements in the case of a missing method failure and assignment to an interface pointer. Preparation for using Checker.implements in operand.assignableTo rather than implementing the same logic twice. This also leads to better errors from Checker.implements as it's using the same logic we already use elsewhere. For #50646. Change-Id: I199a1e02cf328b222ae52c10131db871539863bf Reviewed-on: https://go-review.googlesource.com/c/go/+/381434 Trust: Robert Griesemer Reviewed-by: Robert Findley --- .../compile/internal/types2/instantiate.go | 34 +++++++++------- .../internal/types2/testdata/check/issues.go2 | 2 +- src/go/types/instantiate.go | 39 ++++++++++++------- src/go/types/testdata/check/issues.go2 | 2 +- 4 files changed, 48 insertions(+), 29 deletions(-) diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go index e520d0ffa3..02ab13ec59 100644 --- a/src/cmd/compile/internal/types2/instantiate.go +++ b/src/cmd/compile/internal/types2/instantiate.go @@ -173,7 +173,13 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { Ti, _ := Tu.(*Interface) if Ti == nil { - return errorf("%s is not an interface", T) + var cause string + if isInterfacePtr(Tu) { + cause = sprintf(qf, false, "type %s is pointer to interface, not interface", T) + } else { + cause = sprintf(qf, false, "%s is not an interface", T) + } + return errorf("%s does not implement %s (%s)", V, T, cause) } // Every type satisfies the empty interface. @@ -197,19 +203,21 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { // V must implement T's methods, if any. if Ti.NumMethods() > 0 { - if m, wrong := check.missingMethod(V, Ti, true); m != nil { - // TODO(gri) needs to print updated name to avoid major confusion in error message! - // (print warning for now) - // Old warning: - // check.softErrorf(pos, "%s does not implement %s (warning: name not updated) = %s (missing method %s)", V, T, Ti, m) - if wrong != nil { - // TODO(gri) This can still report uninstantiated types which makes the error message - // more difficult to read then necessary. - return errorf("%s does not implement %s: wrong method signature\n\tgot %s\n\twant %s", - V, T, wrong, m, - ) + if m, wrong := check.missingMethod(V, Ti, true); m != nil /* !Implements(V, Ti) */ { + if check != nil && check.conf.CompilerErrorMessages { + return errorf("%s does not implement %s %s", V, T, check.missingMethodReason(V, T, m, wrong)) } - return errorf("%s does not implement %s (missing method %s)", V, T, m.name) + var cause string + if wrong != nil { + if Identical(m.typ, wrong.typ) { + cause = fmt.Sprintf("missing method %s (%s has pointer receiver)", m.name, m.name) + } else { + cause = fmt.Sprintf("wrong type for method %s (have %s, want %s)", m.Name(), wrong.typ, m.typ) + } + } else { + cause = "missing method " + m.Name() + } + return errorf("%s does not implement %s: %s", V, T, cause) } } diff --git a/src/cmd/compile/internal/types2/testdata/check/issues.go2 b/src/cmd/compile/internal/types2/testdata/check/issues.go2 index 0b80939653..3463c42572 100644 --- a/src/cmd/compile/internal/types2/testdata/check/issues.go2 +++ b/src/cmd/compile/internal/types2/testdata/check/issues.go2 @@ -47,7 +47,7 @@ func (T) m1() func (*T) m2() func _() { - f2[T /* ERROR wrong method signature */ ]() + f2[T /* ERROR m2 has pointer receiver */ ]() f2[*T]() } diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go index dc1c2029bc..7dea8a5e1d 100644 --- a/src/go/types/instantiate.go +++ b/src/go/types/instantiate.go @@ -173,7 +173,17 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { Ti, _ := Tu.(*Interface) if Ti == nil { - return errorf("%s is not an interface", T) + var fset *token.FileSet + if check != nil { + fset = check.fset + } + var cause string + if isInterfacePtr(Tu) { + cause = sprintf(fset, qf, false, "type %s is pointer to interface, not interface", T) + } else { + cause = sprintf(fset, qf, false, "%s is not an interface", T) + } + return errorf("%s does not implement %s (%s)", V, T, cause) } // Every type satisfies the empty interface. @@ -197,20 +207,21 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { // V must implement T's methods, if any. if Ti.NumMethods() > 0 { - if m, wrong := check.missingMethod(V, Ti, true); m != nil { - // TODO(gri) needs to print updated name to avoid major confusion in error message! - // (print warning for now) - // Old warning: - // check.softErrorf(pos, "%s does not implement %s (warning: name not updated) = %s (missing method %s)", V, T, Ti, m) - if wrong != nil { - // TODO(gri) This can still report uninstantiated types which makes the error message - // more difficult to read then necessary. - // TODO(rFindley) should this use parentheses rather than ':' for qualification? - return errorf("%s does not implement %s: wrong method signature\n\tgot %s\n\twant %s", - V, T, wrong, m, - ) + if m, wrong := check.missingMethod(V, Ti, true); m != nil /* !Implements(V, Ti) */ { + if check != nil && compilerErrorMessages { + return errorf("%s does not implement %s %s", V, T, check.missingMethodReason(V, T, m, wrong)) } - return errorf("%s does not implement %s (missing method %s)", V, T, m.name) + var cause string + if wrong != nil { + if Identical(m.typ, wrong.typ) { + cause = fmt.Sprintf("missing method %s (%s has pointer receiver)", m.name, m.name) + } else { + cause = fmt.Sprintf("wrong type for method %s (have %s, want %s)", m.Name(), wrong.typ, m.typ) + } + } else { + cause = "missing method " + m.Name() + } + return errorf("%s does not implement %s: %s", V, T, cause) } } diff --git a/src/go/types/testdata/check/issues.go2 b/src/go/types/testdata/check/issues.go2 index a11bcaac4b..c164825eb7 100644 --- a/src/go/types/testdata/check/issues.go2 +++ b/src/go/types/testdata/check/issues.go2 @@ -47,7 +47,7 @@ func (T) m1() func (*T) m2() func _() { - f2[T /* ERROR wrong method signature */ ]() + f2[T /* ERROR m2 has pointer receiver */ ]() f2[*T]() } From 25b4b862f29900af00c794424b033b01eb5ab0cb Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 27 Jan 2022 10:52:22 -0800 Subject: [PATCH 723/752] go/types, types2: use Checker.implements in operand.assignableTo Now that we have the detailed error reporting in Checker.implements we don't need it anymore in operand.assignableTo and can simply call Checker.implements. This also more directly matches the spec. For #50646. Change-Id: Ic44ced999c75be6cc9edaab01177ee0495147ea1 Reviewed-on: https://go-review.googlesource.com/c/go/+/381435 Trust: Robert Griesemer Reviewed-by: Robert Findley --- .../compile/internal/types2/instantiate.go | 2 + src/cmd/compile/internal/types2/operand.go | 47 ++++++------------ .../internal/types2/testdata/check/issues.src | 4 +- src/go/types/instantiate.go | 2 + src/go/types/operand.go | 49 ++++++------------- src/go/types/testdata/check/issues.src | 4 +- 6 files changed, 38 insertions(+), 70 deletions(-) diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go index 02ab13ec59..e8f2d98d25 100644 --- a/src/cmd/compile/internal/types2/instantiate.go +++ b/src/cmd/compile/internal/types2/instantiate.go @@ -157,6 +157,8 @@ func (check *Checker) verify(pos syntax.Pos, tparams []*TypeParam, targs []Type) // implements checks if V implements T and reports an error if it doesn't. // If a qualifier is provided, it is used in error formatting. +// The receiver may be nil if implements is called through an exported +// API call such as AssignableTo. func (check *Checker) implements(V, T Type, qf Qualifier) error { Vu := under(V) Tu := under(T) diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go index 1eb24d136b..1bda0a51f5 100644 --- a/src/cmd/compile/internal/types2/operand.go +++ b/src/cmd/compile/internal/types2/operand.go @@ -288,47 +288,30 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er return true, 0 } - // T is an interface type and x implements T and T is not a type parameter - if Ti, ok := Tu.(*Interface); ok && Tp == nil { - if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* !Implements(V, Ti) */ { + // T is an interface type and x implements T and T is not a type parameter. + // Also handle the case where T is a pointer to an interface. + if _, ok := Tu.(*Interface); ok && Tp == nil || isInterfacePtr(Tu) { + var qf Qualifier + if check != nil { + qf = check.qualifier + } + if err := check.implements(V, T, qf); err != nil { if reason != nil { - if check != nil && check.conf.CompilerErrorMessages { - *reason = check.sprintf("%s does not implement %s %s", x.typ, T, - check.missingMethodReason(x.typ, T, m, wrongType)) - } else { - if wrongType != nil { - if Identical(m.typ, wrongType.typ) { - *reason = fmt.Sprintf("missing method %s (%s has pointer receiver)", m.name, m.name) - } else { - *reason = fmt.Sprintf("wrong type for method %s (have %s, want %s)", m.Name(), wrongType.typ, m.typ) - } - } else { - *reason = "missing method " + m.Name() - } - } + *reason = err.Error() } return false, _InvalidIfaceAssign } return true, 0 } - // Provide extra detail in compiler error messages in some cases when T is - // not an interface. - if check != nil && check.conf.CompilerErrorMessages { - if isInterfacePtr(Tu) { + // If V is an interface, check if a missing type assertion is the problem. + if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil { + if check.implements(T, V, nil) == nil { + // T implements V, so give hint about type assertion. if reason != nil { - *reason = check.sprintf("%s does not implement %s (type %s is pointer to interface, not interface)", x.typ, T, T) - } - return false, _InvalidIfaceAssign - } - if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil { - if m, _ := check.missingMethod(T, Vi, true); m == nil { - // T implements Vi, so give hint about type assertion. - if reason != nil { - *reason = check.sprintf("need type assertion") - } - return false, _IncompatibleAssign + *reason = "need type assertion" } + return false, _IncompatibleAssign } } diff --git a/src/cmd/compile/internal/types2/testdata/check/issues.src b/src/cmd/compile/internal/types2/testdata/check/issues.src index 868df46bd9..fb7d89fb68 100644 --- a/src/cmd/compile/internal/types2/testdata/check/issues.src +++ b/src/cmd/compile/internal/types2/testdata/check/issues.src @@ -165,8 +165,8 @@ func issue10260() { _ = map[int]I1{0: i0 /* ERROR cannot use .* missing method foo */ } _ = map[int]I1{0: i2 /* ERROR cannot use .* wrong type for method foo */ } - make(chan I1) <- i0 /* ERROR cannot use .* in send: missing method foo */ - make(chan I1) <- i2 /* ERROR cannot use .* in send: wrong type for method foo */ + make(chan I1) <- i0 /* ERROR I0 does not implement I1: missing method foo */ + make(chan I1) <- i2 /* ERROR wrong type for method foo \(have func\(x int\), want func\(\)\) */ } // Check that constants representable as integers are in integer form diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go index 7dea8a5e1d..4a167eb91e 100644 --- a/src/go/types/instantiate.go +++ b/src/go/types/instantiate.go @@ -157,6 +157,8 @@ func (check *Checker) verify(pos token.Pos, tparams []*TypeParam, targs []Type) // implements checks if V implements T and reports an error if it doesn't. // If a qualifier is provided, it is used in error formatting. +// The receiver may be nil if implements is called through an exported +// API call such as AssignableTo. func (check *Checker) implements(V, T Type, qf Qualifier) error { Vu := under(V) Tu := under(T) diff --git a/src/go/types/operand.go b/src/go/types/operand.go index d119b5ee7b..c04c5742a8 100644 --- a/src/go/types/operand.go +++ b/src/go/types/operand.go @@ -8,7 +8,6 @@ package types import ( "bytes" - "fmt" "go/ast" "go/constant" "go/token" @@ -278,48 +277,30 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er return true, 0 } - // T is an interface type and x implements T and T is not a type parameter - if Ti, ok := Tu.(*Interface); ok && Tp == nil { - if m, wrongType := check.missingMethod(V, Ti, true); m != nil /* Implements(V, Ti) */ { + // T is an interface type and x implements T and T is not a type parameter. + // Also handle the case where T is a pointer to an interface. + if _, ok := Tu.(*Interface); ok && Tp == nil || isInterfacePtr(Tu) { + var qf Qualifier + if check != nil { + qf = check.qualifier + } + if err := check.implements(V, T, qf); err != nil { if reason != nil { - if check != nil && compilerErrorMessages { - *reason = check.sprintf("%s does not implement %s %s", x.typ, T, - check.missingMethodReason(x.typ, T, m, wrongType)) - } else { - if wrongType != nil { - if Identical(m.typ, wrongType.typ) { - *reason = fmt.Sprintf("missing method %s (%s has pointer receiver)", m.name, m.name) - } else { - *reason = fmt.Sprintf("wrong type for method %s (have %s, want %s)", m.Name(), wrongType.typ, m.typ) - } - - } else { - *reason = "missing method " + m.Name() - } - } + *reason = err.Error() } return false, _InvalidIfaceAssign } return true, 0 } - // Provide extra detail in compiler error messages in some cases when T is - // not an interface. - if check != nil && compilerErrorMessages { - if isInterfacePtr(Tu) { + // If V is an interface, check if a missing type assertion is the problem. + if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil { + if check.implements(T, V, nil) == nil { + // T implements V, so give hint about type assertion. if reason != nil { - *reason = check.sprintf("%s does not implement %s (type %s is pointer to interface, not interface)", x.typ, T, T) - } - return false, _InvalidIfaceAssign - } - if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil { - if m, _ := check.missingMethod(T, Vi, true); m == nil { - // T implements Vi, so give hint about type assertion. - if reason != nil { - *reason = check.sprintf("need type assertion") - } - return false, _IncompatibleAssign + *reason = "need type assertion" } + return false, _IncompatibleAssign } } diff --git a/src/go/types/testdata/check/issues.src b/src/go/types/testdata/check/issues.src index 88ce452959..0b77b0e854 100644 --- a/src/go/types/testdata/check/issues.src +++ b/src/go/types/testdata/check/issues.src @@ -165,8 +165,8 @@ func issue10260() { _ = map[int]I1{0: i0 /* ERROR cannot use .* missing method foo */ } _ = map[int]I1{0: i2 /* ERROR cannot use .* wrong type for method foo */ } - make(chan I1) <- i0 /* ERROR cannot use .* in send: missing method foo */ - make(chan I1) <- i2 /* ERROR cannot use .* in send: wrong type for method foo */ + make(chan I1) <- i0 /* ERROR I0 does not implement I1: missing method foo */ + make(chan I1) <- i2 /* ERROR wrong type for method foo \(have func\(x int\), want func\(\)\) */ } // Check that constants representable as integers are in integer form From 8f7d96f5bcb927a576a43b890f2643e521107665 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 27 Jan 2022 12:53:13 -0800 Subject: [PATCH 724/752] go/types, types2: remove Qualifier parameter from Checker.implements Where we provide it we take it from the Checker (which is already passed in). Thus there's no need to pass it separately. Cleanup. Change-Id: I63ae445ccac5643235d85e1867462ef5c01ad5fe Reviewed-on: https://go-review.googlesource.com/c/go/+/381297 Trust: Robert Griesemer Reviewed-by: Robert Findley --- src/cmd/compile/internal/types2/api.go | 2 +- src/cmd/compile/internal/types2/instantiate.go | 17 ++++++----------- src/cmd/compile/internal/types2/operand.go | 8 ++------ src/go/types/api.go | 2 +- src/go/types/instantiate.go | 17 ++++++----------- src/go/types/operand.go | 8 ++------ 6 files changed, 18 insertions(+), 36 deletions(-) diff --git a/src/cmd/compile/internal/types2/api.go b/src/cmd/compile/internal/types2/api.go index fe754db7a4..ee4f275bc0 100644 --- a/src/cmd/compile/internal/types2/api.go +++ b/src/cmd/compile/internal/types2/api.go @@ -450,7 +450,7 @@ func Implements(V Type, T *Interface) bool { if V.Underlying() == Typ[Invalid] { return false } - return (*Checker)(nil).implements(V, T, nil) == nil + return (*Checker)(nil).implements(V, T) == nil } // Identical reports whether x and y are identical types. diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go index e8f2d98d25..81a3cdeb0b 100644 --- a/src/cmd/compile/internal/types2/instantiate.go +++ b/src/cmd/compile/internal/types2/instantiate.go @@ -133,14 +133,6 @@ func (check *Checker) validateTArgLen(pos syntax.Pos, ntparams, ntargs int) bool } func (check *Checker) verify(pos syntax.Pos, tparams []*TypeParam, targs []Type) (int, error) { - // TODO(rfindley): it would be great if users could pass in a qualifier here, - // rather than falling back to verbose qualification. Maybe this can be part - // of the shared context. - var qf Qualifier - if check != nil { - qf = check.qualifier - } - smap := makeSubstMap(tparams, targs) for i, tpar := range tparams { // The type parameter bound is parameterized with the same type parameters @@ -148,7 +140,7 @@ func (check *Checker) verify(pos syntax.Pos, tparams []*TypeParam, targs []Type) // need to instantiate it with the type arguments with which we instantiated // the parameterized type. bound := check.subst(pos, tpar.bound, smap, nil) - if err := check.implements(targs[i], bound, qf); err != nil { + if err := check.implements(targs[i], bound); err != nil { return i, err } } @@ -156,10 +148,9 @@ func (check *Checker) verify(pos syntax.Pos, tparams []*TypeParam, targs []Type) } // implements checks if V implements T and reports an error if it doesn't. -// If a qualifier is provided, it is used in error formatting. // The receiver may be nil if implements is called through an exported // API call such as AssignableTo. -func (check *Checker) implements(V, T Type, qf Qualifier) error { +func (check *Checker) implements(V, T Type) error { Vu := under(V) Tu := under(T) if Vu == Typ[Invalid] || Tu == Typ[Invalid] { @@ -169,6 +160,10 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { return nil // avoid follow-on errors (see issue #49541 for an example) } + var qf Qualifier + if check != nil { + qf = check.qualifier + } errorf := func(format string, args ...interface{}) error { return errors.New(sprintf(qf, false, format, args...)) } diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go index 1bda0a51f5..fce9a11ffa 100644 --- a/src/cmd/compile/internal/types2/operand.go +++ b/src/cmd/compile/internal/types2/operand.go @@ -291,11 +291,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er // T is an interface type and x implements T and T is not a type parameter. // Also handle the case where T is a pointer to an interface. if _, ok := Tu.(*Interface); ok && Tp == nil || isInterfacePtr(Tu) { - var qf Qualifier - if check != nil { - qf = check.qualifier - } - if err := check.implements(V, T, qf); err != nil { + if err := check.implements(V, T); err != nil { if reason != nil { *reason = err.Error() } @@ -306,7 +302,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er // If V is an interface, check if a missing type assertion is the problem. if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil { - if check.implements(T, V, nil) == nil { + if check.implements(T, V) == nil { // T implements V, so give hint about type assertion. if reason != nil { *reason = "need type assertion" diff --git a/src/go/types/api.go b/src/go/types/api.go index a2cc289fbc..2776e05232 100644 --- a/src/go/types/api.go +++ b/src/go/types/api.go @@ -446,7 +446,7 @@ func Implements(V Type, T *Interface) bool { if V.Underlying() == Typ[Invalid] { return false } - return (*Checker)(nil).implements(V, T, nil) == nil + return (*Checker)(nil).implements(V, T) == nil } // Identical reports whether x and y are identical types. diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go index 4a167eb91e..09a841bb98 100644 --- a/src/go/types/instantiate.go +++ b/src/go/types/instantiate.go @@ -133,14 +133,6 @@ func (check *Checker) validateTArgLen(pos token.Pos, ntparams, ntargs int) bool } func (check *Checker) verify(pos token.Pos, tparams []*TypeParam, targs []Type) (int, error) { - // TODO(rfindley): it would be great if users could pass in a qualifier here, - // rather than falling back to verbose qualification. Maybe this can be part - // of the shared context. - var qf Qualifier - if check != nil { - qf = check.qualifier - } - smap := makeSubstMap(tparams, targs) for i, tpar := range tparams { // The type parameter bound is parameterized with the same type parameters @@ -148,7 +140,7 @@ func (check *Checker) verify(pos token.Pos, tparams []*TypeParam, targs []Type) // need to instantiate it with the type arguments with which we instantiated // the parameterized type. bound := check.subst(pos, tpar.bound, smap, nil) - if err := check.implements(targs[i], bound, qf); err != nil { + if err := check.implements(targs[i], bound); err != nil { return i, err } } @@ -156,10 +148,9 @@ func (check *Checker) verify(pos token.Pos, tparams []*TypeParam, targs []Type) } // implements checks if V implements T and reports an error if it doesn't. -// If a qualifier is provided, it is used in error formatting. // The receiver may be nil if implements is called through an exported // API call such as AssignableTo. -func (check *Checker) implements(V, T Type, qf Qualifier) error { +func (check *Checker) implements(V, T Type) error { Vu := under(V) Tu := under(T) if Vu == Typ[Invalid] || Tu == Typ[Invalid] { @@ -169,6 +160,10 @@ func (check *Checker) implements(V, T Type, qf Qualifier) error { return nil // avoid follow-on errors (see issue #49541 for an example) } + var qf Qualifier + if check != nil { + qf = check.qualifier + } errorf := func(format string, args ...any) error { return errors.New(sprintf(nil, qf, false, format, args...)) } diff --git a/src/go/types/operand.go b/src/go/types/operand.go index c04c5742a8..4d7f1e3b63 100644 --- a/src/go/types/operand.go +++ b/src/go/types/operand.go @@ -280,11 +280,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er // T is an interface type and x implements T and T is not a type parameter. // Also handle the case where T is a pointer to an interface. if _, ok := Tu.(*Interface); ok && Tp == nil || isInterfacePtr(Tu) { - var qf Qualifier - if check != nil { - qf = check.qualifier - } - if err := check.implements(V, T, qf); err != nil { + if err := check.implements(V, T); err != nil { if reason != nil { *reason = err.Error() } @@ -295,7 +291,7 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) (bool, er // If V is an interface, check if a missing type assertion is the problem. if Vi, _ := Vu.(*Interface); Vi != nil && Vp == nil { - if check.implements(T, V, nil) == nil { + if check.implements(T, V) == nil { // T implements V, so give hint about type assertion. if reason != nil { *reason = "need type assertion" From b37c6e15477a934f894488751bed8abcf16b4f5c Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 27 Jan 2022 21:26:27 -0800 Subject: [PATCH 725/752] go/types, types2: delete TypeList.String This method is unused and was not discussed in the API proposals. Note that all error output goes through the local sprintf which handles arguments specially. Fixes #50760. Change-Id: Iae66b0253cc0ece037d3d280951dc2d223c119fb Reviewed-on: https://go-review.googlesource.com/c/go/+/381634 Trust: Robert Griesemer Reviewed-by: Robert Findley --- api/go1.18.txt | 1 - src/cmd/compile/internal/types2/typelists.go | 11 ----------- src/go/types/typelists.go | 11 ----------- 3 files changed, 23 deletions(-) diff --git a/api/go1.18.txt b/api/go1.18.txt index 7805d29eb7..2d05c3f41c 100644 --- a/api/go1.18.txt +++ b/api/go1.18.txt @@ -51,7 +51,6 @@ pkg go/types, method (*Term) Tilde() bool pkg go/types, method (*Term) Type() Type pkg go/types, method (*TypeList) At(int) Type pkg go/types, method (*TypeList) Len() int -pkg go/types, method (*TypeList) String() string pkg go/types, method (*TypeParam) Constraint() Type pkg go/types, method (*TypeParam) Index() int pkg go/types, method (*TypeParam) Obj() *TypeName diff --git a/src/cmd/compile/internal/types2/typelists.go b/src/cmd/compile/internal/types2/typelists.go index 0b77edbde2..a2aba4a9a5 100644 --- a/src/cmd/compile/internal/types2/typelists.go +++ b/src/cmd/compile/internal/types2/typelists.go @@ -4,8 +4,6 @@ package types2 -import "bytes" - // TypeParamList holds a list of type parameters. type TypeParamList struct{ tparams []*TypeParam } @@ -54,15 +52,6 @@ func (l *TypeList) list() []Type { return l.types } -func (l *TypeList) String() string { - if l == nil || len(l.types) == 0 { - return "[]" - } - var buf bytes.Buffer - newTypeWriter(&buf, nil).typeList(l.types) - return buf.String() -} - // ---------------------------------------------------------------------------- // Implementation diff --git a/src/go/types/typelists.go b/src/go/types/typelists.go index aea19e946d..0f241356c3 100644 --- a/src/go/types/typelists.go +++ b/src/go/types/typelists.go @@ -4,8 +4,6 @@ package types -import "bytes" - // TypeParamList holds a list of type parameters. type TypeParamList struct{ tparams []*TypeParam } @@ -54,15 +52,6 @@ func (l *TypeList) list() []Type { return l.types } -func (l *TypeList) String() string { - if l == nil || len(l.types) == 0 { - return "[]" - } - var buf bytes.Buffer - newTypeWriter(&buf, nil).typeList(l.types) - return buf.String() -} - // ---------------------------------------------------------------------------- // Implementation From 1fadc392ccaefd76ef7be5b685fb3889dbee27c6 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Fri, 28 Jan 2022 14:32:56 -0800 Subject: [PATCH 726/752] doc/go1.18: in workspace mode doc, link to "go work" docs For #45713 For #47694 Change-Id: I6f615c07749fca49c19f2ae22f79971c29aa8183 Reviewed-on: https://go-review.googlesource.com/c/go/+/381779 Trust: Ian Lance Taylor Reviewed-by: Michael Matloob --- doc/go1.18.html | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/doc/go1.18.html b/doc/go1.18.html index fb9e685c69..7db56a46de 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -312,7 +312,9 @@ Do not send CLs removing the interior tags from such phrases. In workspace mode, the go.work file will be used to determine the set of main modules used as the roots for module resolution, instead of using the normally-found go.mod - file to specify the single main module. + file to specify the single main module. For more information see the + go work + documentation.

    From 5fd8c9b5c5a0348317e49e6c58e34b9a6e00e91a Mon Sep 17 00:00:00 2001 From: Mark Pulford Date: Sat, 22 Jan 2022 16:43:53 +1030 Subject: [PATCH 727/752] cmd/go: correct -trimpath docs for the standard library Fixes #50402 Change-Id: Ic539afc1aef3906ef591b403eba0fde20a5ccef2 Reviewed-on: https://go-review.googlesource.com/c/go/+/380078 Reviewed-by: Bryan Mills Trust: Emmanuel Odeke Run-TryBot: Emmanuel Odeke --- src/cmd/go/alldocs.go | 5 ++--- src/cmd/go/internal/work/build.go | 5 ++--- 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index 1d3098a76e..826b0ccf19 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -209,9 +209,8 @@ // -trimpath // remove all file system paths from the resulting executable. // Instead of absolute file system paths, the recorded file names -// will begin with either "go" (for the standard library), -// or a module path@version (when using modules), -// or a plain import path (when using GOPATH). +// will begin either a module path@version (when using modules), +// or a plain import path (when using the standard library, or GOPATH). // -toolexec 'cmd args' // a program to use to invoke toolchain programs like vet and asm. // For example, instead of running asm, the go command will run diff --git a/src/cmd/go/internal/work/build.go b/src/cmd/go/internal/work/build.go index 56648338c5..1c278d3d99 100644 --- a/src/cmd/go/internal/work/build.go +++ b/src/cmd/go/internal/work/build.go @@ -162,9 +162,8 @@ and test commands: -trimpath remove all file system paths from the resulting executable. Instead of absolute file system paths, the recorded file names - will begin with either "go" (for the standard library), - or a module path@version (when using modules), - or a plain import path (when using GOPATH). + will begin either a module path@version (when using modules), + or a plain import path (when using the standard library, or GOPATH). -toolexec 'cmd args' a program to use to invoke toolchain programs like vet and asm. For example, instead of running asm, the go command will run From 122654739dce506364d10c450afcc36d7572922d Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Fri, 28 Jan 2022 13:15:16 -0800 Subject: [PATCH 728/752] doc/go1.18: mention new debug/dwarf DataBitOffset fields For #46784 For #47694 For #50685 Change-Id: I5351b56722d036a520d1a598ef7af95c5eb44c35 Reviewed-on: https://go-review.googlesource.com/c/go/+/381778 Trust: Ian Lance Taylor Reviewed-by: Than McIntosh --- doc/go1.18.html | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index 7db56a46de..c93c91ebbc 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -595,6 +595,17 @@ Do not send CLs removing the interior tags from such phrases. +

    debug/dwarf
    +
    +

    + The StructField + and BasicType + structs both now have a DataBitOffset field, which + holds the value of the DW_AT_data_bit_offset + attribute if present. +

    +
    +
    debug/elf

    From a5c0b190809436fd196a348f85eca0416f4de7fe Mon Sep 17 00:00:00 2001 From: zhouguangyuan Date: Tue, 2 Nov 2021 20:23:34 +0800 Subject: [PATCH 729/752] cmd/go: fix error message when missing import Fixes #48907 Change-Id: I504f846fc2ea655ba00aedb30f90847f938c347c Reviewed-on: https://go-review.googlesource.com/c/go/+/360615 Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor Trust: Emmanuel Odeke --- src/cmd/go/testdata/script/mod_go_version_missing.txt | 2 +- src/go/build/build.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/testdata/script/mod_go_version_missing.txt b/src/cmd/go/testdata/script/mod_go_version_missing.txt index d704816729..2159a1e4c0 100644 --- a/src/cmd/go/testdata/script/mod_go_version_missing.txt +++ b/src/cmd/go/testdata/script/mod_go_version_missing.txt @@ -27,7 +27,7 @@ cmp go.mod go.mod.orig ! go list -mod=vendor all ! stderr '^go: inconsistent vendoring' -stderr 'cannot find package "\." in:\n\t.*[/\\]vendor[/\\]example.com[/\\]badedit$' +stderr 'cannot find package "vendor/example.com/badedit" in:\n\t.*[/\\]vendor[/\\]example.com[/\\]badedit$' # When we set -mod=mod, the go version should be updated immediately, # to the current version, converting the requirements from eager to lazy. diff --git a/src/go/build/build.go b/src/go/build/build.go index 6f7260b78f..dce0304ba4 100644 --- a/src/go/build/build.go +++ b/src/go/build/build.go @@ -789,7 +789,7 @@ Found: } // package was not found - return p, fmt.Errorf("cannot find package %q in:\n\t%s", path, p.Dir) + return p, fmt.Errorf("cannot find package %q in:\n\t%s", p.ImportPath, p.Dir) } if mode&FindOnly != 0 { From 41f485b9a7d8fd647c415be1d11b612063dff21c Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 28 Jan 2022 17:22:32 -0500 Subject: [PATCH 730/752] cmd/go: rewrite TestScript/cgo_stale_precompiled to be agnostic to staleness The configuration set by x/build/cmd/releasebot causes runtime/cgo to be stale in the darwin/amd64 release (see #36025, #35459). That staleness is mostly benign because we can reasonably assume that users on macOS will either disable CGO entirely or have a C compiler installed to rebuild (and cache) the stale packages if needed. Fixes #50892 Fixes #50893 Updates #46347 Change-Id: Ib9ce6b5014de436264238f680f7ca4ae02c9a220 Reviewed-on: https://go-review.googlesource.com/c/go/+/381854 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Russ Cox --- .../testdata/script/cgo_stale_precompiled.txt | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/src/cmd/go/testdata/script/cgo_stale_precompiled.txt b/src/cmd/go/testdata/script/cgo_stale_precompiled.txt index cda804070a..80ed751afc 100644 --- a/src/cmd/go/testdata/script/cgo_stale_precompiled.txt +++ b/src/cmd/go/testdata/script/cgo_stale_precompiled.txt @@ -4,14 +4,25 @@ [!cgo] skip -# Control case: net must not already be stale. -! stale net +# This test may start with the runtime/cgo package already stale. +# Explicitly rebuild it to ensure that it is cached. +# (See https://go.dev/issue/50892.) +# +# If running in non-short mode, explicitly vary CGO_CFLAGS +# as a control case (to ensure that our regexps do catch rebuilds). + +[!short] env GOCACHE=$WORK/cache +[!short] env CGO_CFLAGS=-DTestScript_cgo_stale_precompiled=true +go build -x runtime/cgo +[!short] stderr '[/\\]cgo'$GOEXE'["]? .* -importpath runtime/cgo' # https://go.dev/issue/47215: a missing $(go env CC) caused the precompiled net to be stale. [!plan9] env PATH='' # Guaranteed not to include $(go env CC)! [plan9] env path='' -! stale net # issue #47215 +go build -x runtime/cgo +! stderr '[/\\]cgo'$GOEXE'["]? .* -importpath runtime/cgo' # https://go.dev/issue/50183: a mismatched GOROOT_FINAL caused net to be stale. env GOROOT_FINAL=$WORK${/}goroot -! stale net +go build -x runtime/cgo +! stderr '[/\\]cgo'$GOEXE'["]? .* -importpath runtime/cgo' From 360e1b8197b78685cf08ab5914aa629fb739b2c3 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Wed, 26 Jan 2022 22:48:44 -0800 Subject: [PATCH 731/752] go/types, types2: fix implements and identical predicates - Use the correct predicate in Checker.implements: for interfaces we cannot use the API Comparable because it always returns true for all non-type parameter interface types: Comparable simply answers if == and != is permitted, and it's always been permitted for interfaces. Instead we must use Interface.IsComparable which looks at the type set of an interface. - When comparing interfaces for identity, we must also consider the whether the type sets have the comparable bit set. With this change, `any` doesn't implement `comparable` anymore. This only matters for generic functions and types, and the API functions. It does mean that for now (until we allow type-constrained interfaces for general non-constraint use, at some point in the future) a type parameter that needs to be comparable cannot be instantiated with an interface anymore. For #50646. Change-Id: I7e7f711bdcf94461f330c90509211ec0c2cf3633 Reviewed-on: https://go-review.googlesource.com/c/go/+/381254 Trust: Robert Griesemer Reviewed-by: Robert Findley --- .../compile/internal/types2/instantiate.go | 2 +- .../compile/internal/types2/issues_test.go | 9 ++--- src/cmd/compile/internal/types2/predicates.go | 3 ++ .../internal/types2/testdata/check/issues.go2 | 11 +++--- .../types2/testdata/fixedbugs/issue50646.go2 | 11 ++---- src/cmd/compile/internal/types2/unify.go | 3 ++ src/go/types/instantiate.go | 2 +- src/go/types/issues_test.go | 9 ++--- src/go/types/predicates.go | 3 ++ src/go/types/testdata/check/issues.go2 | 11 +++--- .../types/testdata/fixedbugs/issue50646.go2 | 11 ++---- src/go/types/unify.go | 3 ++ test/typeparam/issue48276a.go | 2 +- test/typeparam/issue48276a.out | 2 +- test/typeparam/issue50646.go | 39 ------------------- 15 files changed, 42 insertions(+), 79 deletions(-) delete mode 100644 test/typeparam/issue50646.go diff --git a/src/cmd/compile/internal/types2/instantiate.go b/src/cmd/compile/internal/types2/instantiate.go index 81a3cdeb0b..e0f2d8abe1 100644 --- a/src/cmd/compile/internal/types2/instantiate.go +++ b/src/cmd/compile/internal/types2/instantiate.go @@ -221,7 +221,7 @@ func (check *Checker) implements(V, T Type) error { // If T is comparable, V must be comparable. // Remember as a pending error and report only if we don't have a more specific error. var pending error - if Ti.IsComparable() && !Comparable(V) { + if Ti.IsComparable() && ((Vi != nil && !Vi.IsComparable()) || (Vi == nil && !Comparable(V))) { pending = errorf("%s does not implement comparable", V) } diff --git a/src/cmd/compile/internal/types2/issues_test.go b/src/cmd/compile/internal/types2/issues_test.go index 6b64251118..697a73525c 100644 --- a/src/cmd/compile/internal/types2/issues_test.go +++ b/src/cmd/compile/internal/types2/issues_test.go @@ -623,16 +623,15 @@ func TestIssue50646(t *testing.T) { t.Errorf("comparable is not a comparable type") } - // TODO(gri) should comparable be an alias, like any? (see #50791) - if !Implements(anyType, comparableType.Underlying().(*Interface)) { - t.Errorf("any does not implement comparable") + if Implements(anyType, comparableType.Underlying().(*Interface)) { + t.Errorf("any implements comparable") } if !Implements(comparableType, anyType.(*Interface)) { t.Errorf("comparable does not implement any") } - if !AssignableTo(anyType, comparableType) { - t.Errorf("any not assignable to comparable") + if AssignableTo(anyType, comparableType) { + t.Errorf("any assignable to comparable") } if !AssignableTo(comparableType, anyType) { t.Errorf("comparable not assignable to any") diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go index cc3c76e695..003e58db38 100644 --- a/src/cmd/compile/internal/types2/predicates.go +++ b/src/cmd/compile/internal/types2/predicates.go @@ -306,6 +306,9 @@ func identical(x, y Type, cmpTags bool, p *ifacePair) bool { if y, ok := y.(*Interface); ok { xset := x.typeSet() yset := y.typeSet() + if xset.comparable != yset.comparable { + return false + } if !xset.terms.equal(yset.terms) { return false } diff --git a/src/cmd/compile/internal/types2/testdata/check/issues.go2 b/src/cmd/compile/internal/types2/testdata/check/issues.go2 index 3463c42572..1763550c04 100644 --- a/src/cmd/compile/internal/types2/testdata/check/issues.go2 +++ b/src/cmd/compile/internal/types2/testdata/check/issues.go2 @@ -9,19 +9,18 @@ package p import "io" import "context" -// Interfaces are always comparable (though the comparison may panic at runtime). func eql[T comparable](x, y T) bool { return x == y } -func _() { - var x interface{} - var y interface{ m() } +func _[X comparable, Y interface{comparable; m()}]() { + var x X + var y Y eql(x, y /* ERROR does not match */ ) // interfaces of different types eql(x, x) eql(y, y) - eql(y, nil) - eql[io.Reader](nil, nil) + eql(y, nil /* ERROR cannot use nil as Y value in argument to eql */ ) + eql[io /* ERROR does not implement comparable */ .Reader](nil, nil) } // If we have a receiver of pointer to type parameter type (below: *T) diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50646.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50646.go2 index 6e8419f247..3bdba1113a 100644 --- a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50646.go2 +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50646.go2 @@ -4,9 +4,6 @@ package p -// Because we can use == and != with values of arbitrary -// interfaces, all interfaces implement comparable. - func f1[_ comparable]() {} func f2[_ interface{ comparable }]() {} @@ -14,15 +11,15 @@ type T interface{ m() } func _[P comparable, Q ~int, R any]() { _ = f1[int] - _ = f1[T] - _ = f1[any] + _ = f1[T /* ERROR T does not implement comparable */ ] + _ = f1[any /* ERROR any does not implement comparable */ ] _ = f1[P] _ = f1[Q] _ = f1[R /* ERROR R does not implement comparable */] _ = f2[int] - _ = f2[T] - _ = f2[any] + _ = f2[T /* ERROR T does not implement comparable */ ] + _ = f2[any /* ERROR any does not implement comparable */ ] _ = f2[P] _ = f2[Q] _ = f2[R /* ERROR R does not implement comparable */] diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go index 8762bae559..b844fb22b6 100644 --- a/src/cmd/compile/internal/types2/unify.go +++ b/src/cmd/compile/internal/types2/unify.go @@ -387,6 +387,9 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool { if y, ok := y.(*Interface); ok { xset := x.typeSet() yset := y.typeSet() + if xset.comparable != yset.comparable { + return false + } if !xset.terms.equal(yset.terms) { return false } diff --git a/src/go/types/instantiate.go b/src/go/types/instantiate.go index 09a841bb98..347815f9dd 100644 --- a/src/go/types/instantiate.go +++ b/src/go/types/instantiate.go @@ -225,7 +225,7 @@ func (check *Checker) implements(V, T Type) error { // If T is comparable, V must be comparable. // Remember as a pending error and report only if we don't have a more specific error. var pending error - if Ti.IsComparable() && !Comparable(V) { + if Ti.IsComparable() && ((Vi != nil && !Vi.IsComparable()) || (Vi == nil && !Comparable(V))) { pending = errorf("%s does not implement comparable", V) } diff --git a/src/go/types/issues_test.go b/src/go/types/issues_test.go index 613ced92ed..bd98f48177 100644 --- a/src/go/types/issues_test.go +++ b/src/go/types/issues_test.go @@ -650,16 +650,15 @@ func TestIssue50646(t *testing.T) { t.Errorf("comparable is not a comparable type") } - // TODO(gri) should comparable be an alias, like any? (see #50791) - if !Implements(anyType, comparableType.Underlying().(*Interface)) { - t.Errorf("any does not implement comparable") + if Implements(anyType, comparableType.Underlying().(*Interface)) { + t.Errorf("any implements comparable") } if !Implements(comparableType, anyType.(*Interface)) { t.Errorf("comparable does not implement any") } - if !AssignableTo(anyType, comparableType) { - t.Errorf("any not assignable to comparable") + if AssignableTo(anyType, comparableType) { + t.Errorf("any assignable to comparable") } if !AssignableTo(comparableType, anyType) { t.Errorf("comparable not assignable to any") diff --git a/src/go/types/predicates.go b/src/go/types/predicates.go index 1ba0043327..9ae6cd51b7 100644 --- a/src/go/types/predicates.go +++ b/src/go/types/predicates.go @@ -308,6 +308,9 @@ func identical(x, y Type, cmpTags bool, p *ifacePair) bool { if y, ok := y.(*Interface); ok { xset := x.typeSet() yset := y.typeSet() + if xset.comparable != yset.comparable { + return false + } if !xset.terms.equal(yset.terms) { return false } diff --git a/src/go/types/testdata/check/issues.go2 b/src/go/types/testdata/check/issues.go2 index c164825eb7..8291852a49 100644 --- a/src/go/types/testdata/check/issues.go2 +++ b/src/go/types/testdata/check/issues.go2 @@ -9,19 +9,18 @@ package p import "io" import "context" -// Interfaces are always comparable (though the comparison may panic at runtime). func eql[T comparable](x, y T) bool { return x == y } -func _() { - var x interface{} - var y interface{ m() } +func _[X comparable, Y interface{comparable; m()}]() { + var x X + var y Y eql(x, y /* ERROR does not match */ ) // interfaces of different types eql(x, x) eql(y, y) - eql(y, nil) - eql[io.Reader](nil, nil) + eql(y, nil /* ERROR cannot use nil as Y value in argument to eql */ ) + eql[io /* ERROR does not implement comparable */ .Reader](nil, nil) } // If we have a receiver of pointer to type parameter type (below: *T) diff --git a/src/go/types/testdata/fixedbugs/issue50646.go2 b/src/go/types/testdata/fixedbugs/issue50646.go2 index 6e8419f247..3bdba1113a 100644 --- a/src/go/types/testdata/fixedbugs/issue50646.go2 +++ b/src/go/types/testdata/fixedbugs/issue50646.go2 @@ -4,9 +4,6 @@ package p -// Because we can use == and != with values of arbitrary -// interfaces, all interfaces implement comparable. - func f1[_ comparable]() {} func f2[_ interface{ comparable }]() {} @@ -14,15 +11,15 @@ type T interface{ m() } func _[P comparable, Q ~int, R any]() { _ = f1[int] - _ = f1[T] - _ = f1[any] + _ = f1[T /* ERROR T does not implement comparable */ ] + _ = f1[any /* ERROR any does not implement comparable */ ] _ = f1[P] _ = f1[Q] _ = f1[R /* ERROR R does not implement comparable */] _ = f2[int] - _ = f2[T] - _ = f2[any] + _ = f2[T /* ERROR T does not implement comparable */ ] + _ = f2[any /* ERROR any does not implement comparable */ ] _ = f2[P] _ = f2[Q] _ = f2[R /* ERROR R does not implement comparable */] diff --git a/src/go/types/unify.go b/src/go/types/unify.go index ad6d316227..085048f797 100644 --- a/src/go/types/unify.go +++ b/src/go/types/unify.go @@ -387,6 +387,9 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool { if y, ok := y.(*Interface); ok { xset := x.typeSet() yset := y.typeSet() + if xset.comparable != yset.comparable { + return false + } if !xset.terms.equal(yset.terms) { return false } diff --git a/test/typeparam/issue48276a.go b/test/typeparam/issue48276a.go index 060ac3eb7f..25e939f536 100644 --- a/test/typeparam/issue48276a.go +++ b/test/typeparam/issue48276a.go @@ -9,7 +9,7 @@ package main import "fmt" func main() { - IsZero[interface{}]("") + IsZero[int](0) } func IsZero[T comparable](val T) bool { diff --git a/test/typeparam/issue48276a.out b/test/typeparam/issue48276a.out index 7e8a8a9a2e..8f38db999d 100644 --- a/test/typeparam/issue48276a.out +++ b/test/typeparam/issue48276a.out @@ -1 +1 @@ -: +0:0 diff --git a/test/typeparam/issue50646.go b/test/typeparam/issue50646.go deleted file mode 100644 index 44bbe2ae6f..0000000000 --- a/test/typeparam/issue50646.go +++ /dev/null @@ -1,39 +0,0 @@ -// run -gcflags=-G=3 - -// Copyright 2022 The Go 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 eql[P comparable](x, y P) { - if x != y { - panic("not equal") - } -} - -func expectPanic(f func()) { - defer func() { - if recover() == nil { - panic("function succeeded unexpectedly") - } - }() - f() -} - -func main() { - eql[int](1, 1) - eql(1, 1) - - // all interfaces implement comparable - var x, y any = 2, 2 - eql[any](x, y) - eql(x, y) - - // but we may get runtime panics - x, y = 1, 2 // x != y - expectPanic(func() { eql(x, y) }) - - x, y = main, main // functions are not comparable - expectPanic(func() { eql(x, y) }) -} From 38cf79526a5859fb6363e607b2277ab442b28dcb Mon Sep 17 00:00:00 2001 From: doujiang24 Date: Sun, 30 Jan 2022 06:16:03 +0000 Subject: [PATCH 732/752] runtime: mgcmark.go typo fix: gorountine -> goroutine. Change-Id: I5cd980a7c825619cc782a3bca2a1c9c7971fdca2 GitHub-Last-Rev: 6833eedf2dab77f7263f9803839a64b79f57e43e GitHub-Pull-Request: golang/go#50910 Reviewed-on: https://go-review.googlesource.com/c/go/+/381959 Reviewed-by: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Austin Clements --- src/runtime/mgcmark.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/runtime/mgcmark.go b/src/runtime/mgcmark.go index 68acfd4d49..0bf044e314 100644 --- a/src/runtime/mgcmark.go +++ b/src/runtime/mgcmark.go @@ -401,7 +401,7 @@ func markrootSpans(gcw *gcWork, shard int) { } // gcAssistAlloc performs GC work to make gp's assist debt positive. -// gp must be the calling user gorountine. +// gp must be the calling user goroutine. // // This must be called with preemption enabled. func gcAssistAlloc(gp *g) { From 822dbcb7d4b7ab2410bdc19355a0bff99c3c467e Mon Sep 17 00:00:00 2001 From: Michael Pratt Date: Mon, 31 Jan 2022 17:10:58 -0500 Subject: [PATCH 733/752] Revert "runtime: normalize sigprof traceback flags" This reverts commit CL 358900. Adding _TraceJumpStack to cgo traceback exposed a crashing condition. This CL was primarily a cleanup, so we revert it entirely for now and follow-up with the VDSO and libcall parts later. Fixes #50936. Change-Id: Ie45c9caaa8e2ef5bc9498ba65c36c887ca821bf7 Reviewed-on: https://go-review.googlesource.com/c/go/+/382079 Reviewed-by: Cherry Mui Trust: Michael Pratt Run-TryBot: Michael Pratt TryBot-Result: Gopher Robot --- src/runtime/proc.go | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/runtime/proc.go b/src/runtime/proc.go index eee0a25fee..1be7a60830 100644 --- a/src/runtime/proc.go +++ b/src/runtime/proc.go @@ -4671,7 +4671,6 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) { getg().m.mallocing++ var stk [maxCPUProfStack]uintptr - flags := uint(_TraceJumpStack) n := 0 if mp.ncgo > 0 && mp.curg != nil && mp.curg.syscallpc != 0 && mp.curg.syscallsp != 0 { cgoOff := 0 @@ -4689,12 +4688,12 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) { } // Collect Go stack that leads to the cgo call. - n = gentraceback(mp.curg.syscallpc, mp.curg.syscallsp, 0, mp.curg, 0, &stk[cgoOff], len(stk)-cgoOff, nil, nil, flags) + n = gentraceback(mp.curg.syscallpc, mp.curg.syscallsp, 0, mp.curg, 0, &stk[cgoOff], len(stk)-cgoOff, nil, nil, 0) if n > 0 { n += cgoOff } } else { - n = gentraceback(pc, sp, lr, gp, 0, &stk[0], len(stk), nil, nil, _TraceTrap|flags) + n = gentraceback(pc, sp, lr, gp, 0, &stk[0], len(stk), nil, nil, _TraceTrap|_TraceJumpStack) } if n <= 0 { @@ -4704,10 +4703,10 @@ func sigprof(pc, sp, lr uintptr, gp *g, mp *m) { 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, flags) + n = gentraceback(mp.libcallpc, mp.libcallsp, 0, mp.libcallg.ptr(), 0, &stk[0], len(stk), nil, nil, 0) } if n == 0 && mp != nil && mp.vdsoSP != 0 { - n = gentraceback(mp.vdsoPC, mp.vdsoSP, 0, gp, 0, &stk[0], len(stk), nil, nil, flags) + n = gentraceback(mp.vdsoPC, mp.vdsoSP, 0, gp, 0, &stk[0], len(stk), nil, nil, _TraceTrap|_TraceJumpStack) } if n == 0 { // If all of the above has failed, account it against abstract "System" or "GC". From d3f5cf9d285d39258b2e6f9002c44aaab3e77c42 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Fri, 28 Jan 2022 15:17:46 -0800 Subject: [PATCH 734/752] cmd/go: update go work edit -json types to final version For #45713 Change-Id: Ia55a96702b99cccaf5d96c2125ee513700658444 Reviewed-on: https://go-review.googlesource.com/c/go/+/381874 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Michael Matloob Trust: Michael Matloob --- src/cmd/go/alldocs.go | 18 +++++++++--------- src/cmd/go/internal/workcmd/edit.go | 18 +++++++++--------- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index 826b0ccf19..9dd41a8078 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -1472,19 +1472,14 @@ // The -json flag prints the final go.work file in JSON format instead of // writing it back to go.mod. The JSON output corresponds to these Go types: // -// type Module struct { -// Path string -// Version string -// } -// // type GoWork struct { -// Go string -// Directory []Directory -// Replace []Replace +// Go string +// Use []Use +// Replace []Replace // } // // type Use struct { -// Path string +// DiskPath string // ModulePath string // } // @@ -1493,6 +1488,11 @@ // New Module // } // +// type Module struct { +// Path string +// Version string +// } +// // See the workspaces design proposal at // https://go.googlesource.com/proposal/+/master/design/45713-workspace.md for // more information. diff --git a/src/cmd/go/internal/workcmd/edit.go b/src/cmd/go/internal/workcmd/edit.go index c42000710e..879ddc3b1d 100644 --- a/src/cmd/go/internal/workcmd/edit.go +++ b/src/cmd/go/internal/workcmd/edit.go @@ -63,19 +63,14 @@ writing it back to go.mod. The -json flag prints the final go.work file in JSON format instead of writing it back to go.mod. The JSON output corresponds to these Go types: - type Module struct { - Path string - Version string - } - type GoWork struct { - Go string - Directory []Directory - Replace []Replace + Go string + Use []Use + Replace []Replace } type Use struct { - Path string + DiskPath string ModulePath string } @@ -84,6 +79,11 @@ writing it back to go.mod. The JSON output corresponds to these Go types: New Module } + type Module struct { + Path string + Version string + } + See the workspaces design proposal at https://go.googlesource.com/proposal/+/master/design/45713-workspace.md for more information. From eab9a77a60f5b6aaba978b61fbb260f2fbb307fb Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 31 Jan 2022 12:51:45 -0800 Subject: [PATCH 735/752] go/types, types2: fix unification code for defined types Fixes #50929. Change-Id: I65b8eaf5e4b423839bc53c7b1db3679961498c8a Reviewed-on: https://go-review.googlesource.com/c/go/+/382076 Trust: Robert Griesemer Reviewed-by: Robert Findley --- .../types2/testdata/fixedbugs/issue50929.go2 | 68 +++++++++++++++++++ src/cmd/compile/internal/types2/unify.go | 5 +- .../types/testdata/fixedbugs/issue50929.go2 | 68 +++++++++++++++++++ src/go/types/unify.go | 7 +- 4 files changed, 145 insertions(+), 3 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50929.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50929.go2 diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50929.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50929.go2 new file mode 100644 index 0000000000..941dbaa3c1 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50929.go2 @@ -0,0 +1,68 @@ +// Copyright 2022 The Go 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 is tested when running "go test -run Manual" +// without source arguments. Use for one-off debugging. + +package p + +import "fmt" + +type F[A, B any] int + +func G[A, B any](F[A, B]) { +} + +func _() { + // TODO(gri) only report one error below (issue #50932) + var x F /* ERROR cannot infer B */ /* ERROR got 1 arguments but 2 type parameters */ [int] + G(x /* ERROR does not match */) +} + +// test case from issue +// (lots of errors but doesn't crash anymore) + +type RC[G any, RG any] interface { + ~[]RG +} + +type RG[G any] struct{} + +type RSC[G any] []*RG[G] + +type M[Rc RC[G, RG], G any, RG any] struct { + Fn func(Rc) +} + +type NFn[Rc RC[G, RG], G any, RG any] func(Rc) + +func NC[Rc RC[G, RG], G any, RG any](nFn NFn[Rc, G, RG]) { + var empty Rc + nFn(empty) +} + +func NSG[G any](c RSC[G]) { + fmt.Println(c) +} + +func MMD[Rc RC /* ERROR cannot infer RG */ /* ERROR got 1 arguments */ [RG], RG any, G any]() M /* ERROR got 2 arguments */ /* ERROR Rc does not match */ [Rc, RG] { + + var nFn NFn /* ERROR got 2 arguments */ /* ERROR Rc does not match */ [Rc, RG] + + var empty Rc + switch any(empty).(type) { + case BC /* ERROR undeclared name: BC */ : + + case RSC[G]: + nFn = NSG /* ERROR cannot use NSG\[G\] */ [G] + } + + return M /* ERROR got 2 arguments */ [Rc, RG]{ + Fn: func(rc Rc) { + NC(nFn /* ERROR does not match */ ) + }, + } + + return M /* ERROR got 2 arguments */ [Rc, RG]{} +} diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go index b844fb22b6..13d5af671e 100644 --- a/src/cmd/compile/internal/types2/unify.go +++ b/src/cmd/compile/internal/types2/unify.go @@ -457,11 +457,14 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool { xargs := x.targs.list() yargs := y.targs.list() + if len(xargs) != len(yargs) { + return false + } + // TODO(gri) This is not always correct: two types may have the same names // in the same package if one of them is nested in a function. // Extremely unlikely but we need an always correct solution. if x.obj.pkg == y.obj.pkg && x.obj.name == y.obj.name { - assert(len(xargs) == len(yargs)) for i, x := range xargs { if !u.nify(x, yargs[i], p) { return false diff --git a/src/go/types/testdata/fixedbugs/issue50929.go2 b/src/go/types/testdata/fixedbugs/issue50929.go2 new file mode 100644 index 0000000000..941dbaa3c1 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50929.go2 @@ -0,0 +1,68 @@ +// Copyright 2022 The Go 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 is tested when running "go test -run Manual" +// without source arguments. Use for one-off debugging. + +package p + +import "fmt" + +type F[A, B any] int + +func G[A, B any](F[A, B]) { +} + +func _() { + // TODO(gri) only report one error below (issue #50932) + var x F /* ERROR cannot infer B */ /* ERROR got 1 arguments but 2 type parameters */ [int] + G(x /* ERROR does not match */) +} + +// test case from issue +// (lots of errors but doesn't crash anymore) + +type RC[G any, RG any] interface { + ~[]RG +} + +type RG[G any] struct{} + +type RSC[G any] []*RG[G] + +type M[Rc RC[G, RG], G any, RG any] struct { + Fn func(Rc) +} + +type NFn[Rc RC[G, RG], G any, RG any] func(Rc) + +func NC[Rc RC[G, RG], G any, RG any](nFn NFn[Rc, G, RG]) { + var empty Rc + nFn(empty) +} + +func NSG[G any](c RSC[G]) { + fmt.Println(c) +} + +func MMD[Rc RC /* ERROR cannot infer RG */ /* ERROR got 1 arguments */ [RG], RG any, G any]() M /* ERROR got 2 arguments */ /* ERROR Rc does not match */ [Rc, RG] { + + var nFn NFn /* ERROR got 2 arguments */ /* ERROR Rc does not match */ [Rc, RG] + + var empty Rc + switch any(empty).(type) { + case BC /* ERROR undeclared name: BC */ : + + case RSC[G]: + nFn = NSG /* ERROR cannot use NSG\[G\] */ [G] + } + + return M /* ERROR got 2 arguments */ [Rc, RG]{ + Fn: func(rc Rc) { + NC(nFn /* ERROR does not match */ ) + }, + } + + return M /* ERROR got 2 arguments */ [Rc, RG]{} +} diff --git a/src/go/types/unify.go b/src/go/types/unify.go index 085048f797..5d6d78bff0 100644 --- a/src/go/types/unify.go +++ b/src/go/types/unify.go @@ -164,7 +164,7 @@ func (d *tparamsList) index(typ Type) int { } // If tpar is a type parameter in list, tparamIndex returns the type parameter index. -// Otherwise, the result is < 0. tpar must not be nil.j +// Otherwise, the result is < 0. tpar must not be nil. func tparamIndex(list []*TypeParam, tpar *TypeParam) int { // Once a type parameter is bound its index is >= 0. However, there are some // code paths (namely tracing and type hashing) by which it is possible to @@ -457,11 +457,14 @@ func (u *unifier) nify(x, y Type, p *ifacePair) bool { xargs := x.targs.list() yargs := y.targs.list() + if len(xargs) != len(yargs) { + return false + } + // TODO(gri) This is not always correct: two types may have the same names // in the same package if one of them is nested in a function. // Extremely unlikely but we need an always correct solution. if x.obj.pkg == y.obj.pkg && x.obj.name == y.obj.name { - assert(len(xargs) == len(yargs)) for i, x := range xargs { if !u.nify(x, yargs[i], p) { return false From 4fea5935f5f03b5037c792f8d5f5aa4cba90f1d6 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 31 Jan 2022 15:12:53 -0800 Subject: [PATCH 736/752] go/types, types2: disallow real, imag, complex on type parameters We can type-check these fine but the API implications are unclear. Fixes #50912. For #50937. Change-Id: If29bbb4a257ff6a85e3bfcd4755fd8f90c80fb87 Reviewed-on: https://go-review.googlesource.com/c/go/+/382116 Trust: Robert Griesemer Run-TryBot: Robert Griesemer Reviewed-by: Robert Findley TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/builtins.go | 18 ++++++++---- .../types2/testdata/fixedbugs/issue50912.go2 | 19 ++++++++++++ src/go/types/builtins.go | 29 +++++++++++++++---- .../types/testdata/fixedbugs/issue50912.go2 | 19 ++++++++++++ test/typeparam/absdiff2.go | 20 +++++++++++-- test/typeparam/absdiff3.go | 20 +++++++++++-- test/typeparam/absdiffimp2.dir/a.go | 20 +++++++++++-- 7 files changed, 127 insertions(+), 18 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50912.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50912.go2 diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go index cea4fd3631..c2f955ce8c 100644 --- a/src/cmd/compile/internal/types2/builtins.go +++ b/src/cmd/compile/internal/types2/builtins.go @@ -309,7 +309,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( } return nil } - resTyp := check.applyTypeFunc(f, x.typ) + resTyp := check.applyTypeFunc(f, x, id) if resTyp == nil { check.errorf(x, invalidArg+"arguments have type %s, expected floating-point", x.typ) return @@ -437,7 +437,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) ( } return nil } - resTyp := check.applyTypeFunc(f, x.typ) + resTyp := check.applyTypeFunc(f, x, id) if resTyp == nil { check.errorf(x, invalidArg+"argument has type %s, expected complex type", x.typ) return @@ -800,8 +800,8 @@ func hasVarSize(t Type) bool { // of x. If any of these applications of f return nil, // applyTypeFunc returns nil. // If x is not a type parameter, the result is f(x). -func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type { - if tp, _ := x.(*TypeParam); tp != nil { +func (check *Checker) applyTypeFunc(f func(Type) Type, x *operand, id builtinId) Type { + if tp, _ := x.typ.(*TypeParam); tp != nil { // Test if t satisfies the requirements for the argument // type and collect possible result types at the same time. var terms []*Term @@ -818,17 +818,23 @@ func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type { return nil } + // We can type-check this fine but we're introducing a synthetic + // type parameter for the result. It's not clear what the API + // implications are here. Report an error for 1.18 but continue + // type-checking. + check.softErrorf(x, "%s not supported as argument to %s for go1.18 (see issue #50937)", x, predeclaredFuncs[id].name) + // Construct a suitable new type parameter for the result type. // The type parameter is placed in the current package so export/import // works as expected. - tpar := NewTypeName(nopos, check.pkg, "", nil) + tpar := NewTypeName(nopos, check.pkg, tp.obj.name, nil) ptyp := check.newTypeParam(tpar, NewInterfaceType(nil, []Type{NewUnion(terms)})) // assigns type to tpar as a side-effect ptyp.index = tp.index return ptyp } - return f(x) + return f(x.typ) } // makeSig makes a signature for the given argument and result types. diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50912.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50912.go2 new file mode 100644 index 0000000000..f161925049 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50912.go2 @@ -0,0 +1,19 @@ +// Copyright 2022 The Go 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 Real[P ~complex128](x P) { + _ = real(x /* ERROR not supported */ ) +} + +func Imag[P ~complex128](x P) { + _ = imag(x /* ERROR not supported */ ) +} + +func Complex[P ~float64](x P) { + _ = complex(x /* ERROR not supported */ , 0) + _ = complex(0 /* ERROR not supported */ , x) + _ = complex(x /* ERROR not supported */ , x) +} diff --git a/src/go/types/builtins.go b/src/go/types/builtins.go index 35a2d1ae2e..f9aece225b 100644 --- a/src/go/types/builtins.go +++ b/src/go/types/builtins.go @@ -314,7 +314,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b } return nil } - resTyp := check.applyTypeFunc(f, x.typ) + resTyp := check.applyTypeFunc(f, x, id) if resTyp == nil { check.invalidArg(x, _InvalidComplex, "arguments have type %s, expected floating-point", x.typ) return @@ -442,7 +442,7 @@ func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ b } return nil } - resTyp := check.applyTypeFunc(f, x.typ) + resTyp := check.applyTypeFunc(f, x, id) if resTyp == nil { code := _InvalidImag if id == _Real { @@ -809,8 +809,8 @@ func hasVarSize(t Type) bool { // of x. If any of these applications of f return nil, // applyTypeFunc returns nil. // If x is not a type parameter, the result is f(x). -func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type { - if tp, _ := x.(*TypeParam); tp != nil { +func (check *Checker) applyTypeFunc(f func(Type) Type, x *operand, id builtinId) Type { + if tp, _ := x.typ.(*TypeParam); tp != nil { // Test if t satisfies the requirements for the argument // type and collect possible result types at the same time. var terms []*Term @@ -827,17 +827,34 @@ func (check *Checker) applyTypeFunc(f func(Type) Type, x Type) Type { return nil } + // We can type-check this fine but we're introducing a synthetic + // type parameter for the result. It's not clear what the API + // implications are here. Report an error for 1.18 (see #50912), + // but continue type-checking. + var code errorCode + switch id { + case _Real: + code = _InvalidReal + case _Imag: + code = _InvalidImag + case _Complex: + code = _InvalidComplex + default: + unreachable() + } + check.softErrorf(x, code, "%s not supported as argument to %s for go1.18 (see issue #50937)", x, predeclaredFuncs[id].name) + // Construct a suitable new type parameter for the result type. // The type parameter is placed in the current package so export/import // works as expected. - tpar := NewTypeName(token.NoPos, check.pkg, "", nil) + tpar := NewTypeName(token.NoPos, check.pkg, tp.obj.name, nil) ptyp := check.newTypeParam(tpar, NewInterfaceType(nil, []Type{NewUnion(terms)})) // assigns type to tpar as a side-effect ptyp.index = tp.index return ptyp } - return f(x) + return f(x.typ) } // makeSig makes a signature for the given argument and result types. diff --git a/src/go/types/testdata/fixedbugs/issue50912.go2 b/src/go/types/testdata/fixedbugs/issue50912.go2 new file mode 100644 index 0000000000..f161925049 --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50912.go2 @@ -0,0 +1,19 @@ +// Copyright 2022 The Go 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 Real[P ~complex128](x P) { + _ = real(x /* ERROR not supported */ ) +} + +func Imag[P ~complex128](x P) { + _ = imag(x /* ERROR not supported */ ) +} + +func Complex[P ~float64](x P) { + _ = complex(x /* ERROR not supported */ , 0) + _ = complex(0 /* ERROR not supported */ , x) + _ = complex(x /* ERROR not supported */ , x) +} diff --git a/test/typeparam/absdiff2.go b/test/typeparam/absdiff2.go index 2d82c4721c..36de8ff2c9 100644 --- a/test/typeparam/absdiff2.go +++ b/test/typeparam/absdiff2.go @@ -66,9 +66,25 @@ type complexAbs[T Complex] struct { Value T } +func realimag(x any) (re, im float64) { + switch z := x.(type) { + case complex64: + re = float64(real(z)) + im = float64(imag(z)) + case complex128: + re = real(z) + im = imag(z) + default: + panic("unknown complex type") + } + return +} + func (a complexAbs[T]) Abs() T { - r := float64(real(a.Value)) - i := float64(imag(a.Value)) + // TODO use direct conversion instead of realimag once #50937 is fixed + r, i := realimag(a.Value) + // r := float64(real(a.Value)) + // i := float64(imag(a.Value)) d := math.Sqrt(r*r + i*i) return T(complex(d, 0)) } diff --git a/test/typeparam/absdiff3.go b/test/typeparam/absdiff3.go index 3ca03fe26f..99fa6f11ab 100644 --- a/test/typeparam/absdiff3.go +++ b/test/typeparam/absdiff3.go @@ -43,9 +43,25 @@ type Complex interface { ~complex64 | ~complex128 } +func realimag(x any) (re, im float64) { + switch z := x.(type) { + case complex64: + re = float64(real(z)) + im = float64(imag(z)) + case complex128: + re = real(z) + im = imag(z) + default: + panic("unknown complex type") + } + return +} + func ComplexAbs[T Complex](a T) T { - r := float64(real(a)) - i := float64(imag(a)) + // TODO use direct conversion instead of realimag once #50937 is fixed + r, i := realimag(a) + // r := float64(real(a)) + // i := float64(imag(a)) d := math.Sqrt(r*r + i*i) return T(complex(d, 0)) } diff --git a/test/typeparam/absdiffimp2.dir/a.go b/test/typeparam/absdiffimp2.dir/a.go index 302b69b976..43493e1430 100644 --- a/test/typeparam/absdiffimp2.dir/a.go +++ b/test/typeparam/absdiffimp2.dir/a.go @@ -60,9 +60,25 @@ type complexAbs[T Complex] struct { Value T } +func realimag(x any) (re, im float64) { + switch z := x.(type) { + case complex64: + re = float64(real(z)) + im = float64(imag(z)) + case complex128: + re = real(z) + im = imag(z) + default: + panic("unknown complex type") + } + return +} + func (a complexAbs[T]) Abs() T { - r := float64(real(a.Value)) - i := float64(imag(a.Value)) + // TODO use direct conversion instead of realimag once #50937 is fixed + r, i := realimag(a.Value) + // r := float64(real(a.Value)) + // i := float64(imag(a.Value)) d := math.Sqrt(r*r + i*i) return T(complex(d, 0)) } From 9152e211328f735e7dadaf69780920d64af09a2a Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 28 Jan 2022 15:34:40 -0800 Subject: [PATCH 737/752] spec: add section on comparable constraint For #50646. Fixes #50791. Change-Id: I8fec25ae3f0280c5b5a778011d23842b886ba79e Reviewed-on: https://go-review.googlesource.com/c/go/+/381896 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go_spec.html | 49 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 48 insertions(+), 1 deletion(-) diff --git a/doc/go_spec.html b/doc/go_spec.html index c653cbffc0..69ac1d353f 100644 --- a/doc/go_spec.html +++ b/doc/go_spec.html @@ -1,6 +1,6 @@ @@ -2656,6 +2656,53 @@ may be omitted for convenience: type Constraint ~int // illegal: ~int is not inside a type parameter list + + +

    +The predeclared +interface type comparable +denotes the set of all concrete (non-interface) types that are +comparable. Specifically, +a type T implements comparable if: +

    + +
      +
    • + T is not an interface type and T supports the operations + == and !=; or +
      • +
    • + T is an interface type and each type in T's + type set implements comparable. +
      • +
    + +

    +Even though interfaces that are not type parameters can be +compared +(possibly causing a run-time panic) they do not implement +comparable. +

    + +
    +int                          // implements comparable
+[]byte                       // does not implement comparable (slices cannot be compared)
+interface{}                  // does not implement comparable (see above)
+interface{ ~int | ~string }  // type parameter only: implements comparable
+interface{ comparable }      // type parameter only: implements comparable
+interface{ ~int | ~[]byte }  // type parameter only: does not implement comparable (not all types in the type set are comparable)
+
    + +

    +The comparable interface and interfaces that (directly or indirectly) embed +comparable may only be used as type constraints. They cannot be the types of +values or variables, or components of other, non-interface types. +

    +

    Variable declarations

    From f1e7dcb49cba50203d656f931c3fb90b29727629 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Tue, 1 Feb 2022 09:56:41 -0500 Subject: [PATCH 738/752] cmd/go/internal/workcmd: fix typo in help string Fixes #50945 Change-Id: Ib6251a5be09f4c6ba428ef4c97fe23ebffca3506 Reviewed-on: https://go-review.googlesource.com/c/go/+/382118 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/cmd/go/alldocs.go | 2 +- src/cmd/go/internal/workcmd/work.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index 9dd41a8078..8e13a0f653 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -1379,7 +1379,7 @@ // builds from local modules. // // go.work files are line-oriented. Each line holds a single directive, -// made up of a keyword followed by aruments. For example: +// made up of a keyword followed by arguments. For example: // // go 1.18 // diff --git a/src/cmd/go/internal/workcmd/work.go b/src/cmd/go/internal/workcmd/work.go index 5bb0a2e8ba..d3cc250231 100644 --- a/src/cmd/go/internal/workcmd/work.go +++ b/src/cmd/go/internal/workcmd/work.go @@ -27,7 +27,7 @@ workspace that does not specify modules to be used cannot be used to do builds from local modules. go.work files are line-oriented. Each line holds a single directive, -made up of a keyword followed by aruments. For example: +made up of a keyword followed by arguments. For example: go 1.18 From 93fe469de5388b71af2aa2c959dc485fa3d4bee3 Mon Sep 17 00:00:00 2001 From: Roland Shoemaker Date: Sun, 30 Jan 2022 11:21:28 -0800 Subject: [PATCH 739/752] internal/fuzz: properly handle duplicates during cache loading When loading the corpus, if the cache contained an entry which was a duplicate of an entry added using f.Add, coordinator.addCorpusEntries would return early, ignoring everything after this entry in the cache. Instead, skip duplicates as intended, and continue to load the rest of the cache. Fixes #50913 Change-Id: I3a64b93cbb217c5c364a9f8d0005752e9e9d10ff Reviewed-on: https://go-review.googlesource.com/c/go/+/381960 Trust: Katie Hockman Reviewed-by: Katie Hockman Trust: Roland Shoemaker Run-TryBot: Roland Shoemaker TryBot-Result: Gopher Robot --- .../testdata/script/test_fuzz_dup_cache.txt | 52 +++++++++++++++++++ src/internal/fuzz/fuzz.go | 20 +++++-- 2 files changed, 67 insertions(+), 5 deletions(-) create mode 100644 src/cmd/go/testdata/script/test_fuzz_dup_cache.txt diff --git a/src/cmd/go/testdata/script/test_fuzz_dup_cache.txt b/src/cmd/go/testdata/script/test_fuzz_dup_cache.txt new file mode 100644 index 0000000000..52d44a26ff --- /dev/null +++ b/src/cmd/go/testdata/script/test_fuzz_dup_cache.txt @@ -0,0 +1,52 @@ +[!fuzz] skip +[short] skip + +# This test checks that cached corpus loading properly handles duplicate entries (this can +# happen when a f.Add value has a duplicate entry in the cached corpus.) Duplicate entries +# should be discarded, and the rest of the cache should be loaded as normal. + +env GOCACHE=$WORK/cache +env GODEBUG=fuzzdebug=1 + +mkdir -p $GOCACHE/fuzz/fuzztest/FuzzTarget +go run ./populate $GOCACHE/fuzz/fuzztest/FuzzTarget + +go test -fuzz=FuzzTarget -fuzztime=10x . +stdout 'entries: 5' + +-- go.mod -- +module fuzztest + +go 1.17 + +-- fuzz_test.go -- +package fuzz + +import "testing" + +func FuzzTarget(f *testing.F) { + f.Add(int(0)) + f.Fuzz(func(t *testing.T, _ int) {}) +} + +-- populate/main.go -- +package main + +import ( + "path/filepath" + "fmt" + "os" +) + +func main() { + for i := 0; i < 10; i++ { + b := byte(0) + if i > 5 { + b = byte(i) + } + tmpl := "go test fuzz v1\nint(%d)\n" + if err := os.WriteFile(filepath.Join(os.Args[1], fmt.Sprint(i)), []byte(fmt.Sprintf(tmpl, b)), 0777); err != nil { + panic(err) + } + } +} \ No newline at end of file diff --git a/src/internal/fuzz/fuzz.go b/src/internal/fuzz/fuzz.go index 73f32dd4c7..f2ff3a1390 100644 --- a/src/internal/fuzz/fuzz.go +++ b/src/internal/fuzz/fuzz.go @@ -316,12 +316,12 @@ func CoordinateFuzzing(ctx context.Context, opts CoordinateFuzzingOpts) (err err } else { // Update the coordinator's coverage mask and save the value. inputSize := len(result.entry.Data) - duplicate, err := c.addCorpusEntries(true, result.entry) + entryNew, err := c.addCorpusEntries(true, result.entry) if err != nil { stop(err) break } - if duplicate { + if !entryNew { continue } c.updateCoverage(keepCoverage) @@ -419,11 +419,21 @@ type corpus struct { hashes map[[sha256.Size]byte]bool } +// addCorpusEntries adds entries to the corpus, and optional also writes the entries +// to the cache directory. If an entry is already in the corpus it is skipped. If +// all of the entries are unique, addCorpusEntries returns true and a nil error, +// if at least one of the entries was a duplicate, it returns false and a nil error. func (c *coordinator) addCorpusEntries(addToCache bool, entries ...CorpusEntry) (bool, error) { + noDupes := true for _, e := range entries { - h := sha256.Sum256(e.Data) + data, err := CorpusEntryData(e) + if err != nil { + return false, err + } + h := sha256.Sum256(data) if c.corpus.hashes[h] { - return true, nil + noDupes = false + continue } if addToCache { if err := writeToCorpus(&e, c.opts.CacheDir); err != nil { @@ -437,7 +447,7 @@ func (c *coordinator) addCorpusEntries(addToCache bool, entries ...CorpusEntry) c.corpus.hashes[h] = true c.corpus.entries = append(c.corpus.entries, e) } - return false, nil + return noDupes, nil } // CorpusEntry represents an individual input for fuzzing. From 902dc38212dfdc21911fc32035704ec50a7b9994 Mon Sep 17 00:00:00 2001 From: Dan Scales Date: Wed, 26 Jan 2022 10:09:39 -0800 Subject: [PATCH 740/752] go/types, types2: tweak missingMethodReason logic to improve message This makes the error case pointed out in the issue like the current message in Go 1.17 or -G=0 mode. The priority is to point out the similar but wrong method name, rather than a difference in type. Made changes to both cmd/compile/internal/types2 and go/types. Added in a missing tab in an error message in go/types. At the same time, removed the extra "at info" on the have lines (and pointer receiver lines) of error messages, as requested in #50907. Fixes #50816 Fixes #50907 Change-Id: I04f8151955bdb6192246cbcb59adc1c4b8a2c4e5 Reviewed-on: https://go-review.googlesource.com/c/go/+/381774 Reviewed-by: Robert Griesemer Trust: Dan Scales Run-TryBot: Dan Scales TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/lookup.go | 20 +++++++------- .../internal/types2/testdata/check/issues.src | 2 +- .../types2/testdata/fixedbugs/issue50816.go2 | 23 ++++++++++++++++ src/go/types/lookup.go | 23 ++++++++-------- .../types/testdata/fixedbugs/issue50816.go2 | 23 ++++++++++++++++ test/fixedbugs/issue48471.go | 27 ++++++++++++++----- 6 files changed, 88 insertions(+), 30 deletions(-) create mode 100644 src/cmd/compile/internal/types2/testdata/fixedbugs/issue50816.go2 create mode 100644 src/go/types/testdata/fixedbugs/issue50816.go2 diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go index 408832846d..a71dd409e1 100644 --- a/src/cmd/compile/internal/types2/lookup.go +++ b/src/cmd/compile/internal/types2/lookup.go @@ -403,20 +403,18 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string mname = "method " + m.Name() } if wrongType != nil { - if Identical(m.typ, wrongType.typ) { - if m.Name() == wrongType.Name() { - r = check.sprintf("(%s has pointer receiver) at %s", mname, wrongType.Pos()) - } else { - r = check.sprintf("(missing %s)\n\t\thave %s^^%s at %s\n\t\twant %s^^%s", - mname, wrongType.Name(), wrongType.typ, wrongType.Pos(), m.Name(), m.typ) - } + if m.Name() != wrongType.Name() { + r = check.sprintf("(missing %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", + mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) + } else if Identical(m.typ, wrongType.typ) { + r = check.sprintf("(%s has pointer receiver)", mname) } else { if check.conf.CompilerErrorMessages { - r = check.sprintf("(wrong type for %s)\n\t\thave %s^^%s at %s\n\t\twant %s^^%s", - mname, wrongType.Name(), wrongType.typ, wrongType.Pos(), m.Name(), m.typ) + r = check.sprintf("(wrong type for %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", + mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) } else { - r = check.sprintf("(wrong type for %s)\n\thave %s at %s\n\twant %s", - mname, wrongType.typ, wrongType.Pos(), m.typ) + r = check.sprintf("(wrong type for %s)\n\thave %s\n\twant %s", + mname, wrongType.typ, m.typ) } } // This is a hack to print the function type without the leading diff --git a/src/cmd/compile/internal/types2/testdata/check/issues.src b/src/cmd/compile/internal/types2/testdata/check/issues.src index fb7d89fb68..a19f99b31a 100644 --- a/src/cmd/compile/internal/types2/testdata/check/issues.src +++ b/src/cmd/compile/internal/types2/testdata/check/issues.src @@ -137,7 +137,7 @@ func issue10260() { T1{}.foo /* ERROR cannot call pointer method foo on T1 */ () x.Foo /* ERROR "x.Foo undefined \(type I1 has no field or method Foo, but does have foo\)" */ () - _ = i2. /* ERROR impossible type assertion: i2.\(\*T1\)\n\t\*T1 does not implement I2 \(wrong type for method foo\)\n\thave func\(\) at \w+.+\d+.\d+\n\twant func\(x int\) */ (*T1) + _ = i2. /* ERROR impossible type assertion: i2.\(\*T1\)\n\t\*T1 does not implement I2 \(wrong type for method foo\)\n\thave func\(\)\n\twant func\(x int\) */ (*T1) i1 = i0 /* ERROR cannot use .* missing method foo */ i1 = t0 /* ERROR cannot use .* missing method foo */ diff --git a/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50816.go2 b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50816.go2 new file mode 100644 index 0000000000..b2bcb45248 --- /dev/null +++ b/src/cmd/compile/internal/types2/testdata/fixedbugs/issue50816.go2 @@ -0,0 +1,23 @@ +// Copyright 2022 The Go 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 pkg + +type I interface { + Foo() +} + +type T1 struct{} + +func (T1) foo() {} + +type T2 struct{} + +func (T2) foo() string { return "" } + +func _() { + var i I + _ = i./* ERROR impossible type assertion: i.\(T1\)\n\tT1 does not implement I \(missing method Foo\)\n\t\thave foo\(\)\n\t\twant Foo\(\) */ (T1) + _ = i./* ERROR impossible type assertion: i.\(T2\)\n\tT2 does not implement I \(missing method Foo\)\n\t\thave foo\(\) string\n\t\twant Foo\(\) */ (T2) +} diff --git a/src/go/types/lookup.go b/src/go/types/lookup.go index 8198b058bd..bee76ccb55 100644 --- a/src/go/types/lookup.go +++ b/src/go/types/lookup.go @@ -390,21 +390,20 @@ func (check *Checker) missingMethodReason(V, T Type, m, wrongType *Func) string mname = "method " + m.Name() } if wrongType != nil { - pos := check.fset.Position(wrongType.Pos()) - if Identical(m.typ, wrongType.typ) { - if m.Name() == wrongType.Name() { - r = check.sprintf("(%s has pointer receiver) at %s", mname, pos) - } else { - r = check.sprintf("(missing %s)\n\t\thave %s^^%s at %s\n\t\twant %s^^%s", - mname, wrongType.Name(), wrongType.typ, pos, m.Name(), m.typ) - } + if m.Name() != wrongType.Name() { + // Note: this case can't happen because we don't look for alternative + // method spellings, unlike types2. Keep for symmetry with types2. + r = check.sprintf("(missing %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", + mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) + } else if Identical(m.typ, wrongType.typ) { + r = check.sprintf("(%s has pointer receiver)", mname) } else { if compilerErrorMessages { - r = check.sprintf("(wrong type for %s)\n\t\thave %s^^%s at %s\n\t\twant %s^^%s", - mname, wrongType.Name(), wrongType.typ, pos, m.Name(), m.typ) + r = check.sprintf("(wrong type for %s)\n\t\thave %s^^%s\n\t\twant %s^^%s", + mname, wrongType.Name(), wrongType.typ, m.Name(), m.typ) } else { - r = check.sprintf("(wrong type for %s)\n\thave %s at %s\nwant %s", - mname, wrongType.typ, pos, m.typ) + r = check.sprintf("(wrong type for %s)\n\thave %s\n\twant %s", + mname, wrongType.typ, m.typ) } } // This is a hack to print the function type without the leading diff --git a/src/go/types/testdata/fixedbugs/issue50816.go2 b/src/go/types/testdata/fixedbugs/issue50816.go2 new file mode 100644 index 0000000000..a5eecc551b --- /dev/null +++ b/src/go/types/testdata/fixedbugs/issue50816.go2 @@ -0,0 +1,23 @@ +// Copyright 2022 The Go 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 pkg + +type I interface { + Foo() +} + +type T1 struct{} + +func (T1) foo() {} + +type T2 struct{} + +func (T2) foo() string { return "" } + +func _() { + var i I + _ = i/* ERROR i \(variable of type I\) cannot have dynamic type T1 \(missing method Foo\) */.(T1) + _ = i/* ERROR i \(variable of type I\) cannot have dynamic type T2 \(missing method Foo\) */.(T2) +} diff --git a/test/fixedbugs/issue48471.go b/test/fixedbugs/issue48471.go index 8c5d3d4efa..eaf8a9412c 100644 --- a/test/fixedbugs/issue48471.go +++ b/test/fixedbugs/issue48471.go @@ -22,19 +22,34 @@ type T4 struct{} func (*T4) M(int) +type T5 struct{} + +func (T5) m(int) {} + +type T6 struct{} + +func (T6) m(int) string { return "" } + func f(I) func g() { f(new(T)) // ERROR "cannot use new\(T\) \(.*type \*T\) as type I in argument to f:\n\t\*T does not implement I \(missing M method\)" + var i I i = new(T) // ERROR "cannot use new\(T\) \(.*type \*T\) as type I in assignment:\n\t\*T does not implement I \(missing M method\)" i = I(new(T)) // ERROR "cannot convert new\(T\) \(.*type \*T\) to type I:\n\t\*T does not implement I \(missing M method\)" - i = new(T2) // ERROR "cannot use new\(T2\) \(.*type \*T2\) as type I in assignment:\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\) at \w+.+\d.\d+\n\t\twant M\(int\)" - i = new(T3) // ERROR "cannot use new\(T3\) \(.*type \*T3\) as type I in assignment:\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\) at \w+.+\d.\d+\n\t\twant M\(int\)" - i = T4{} // ERROR "cannot use T4\{\} \(.*type T4\) as type I in assignment:\n\tT4 does not implement I \(M method has pointer receiver\)" - i = new(I) // ERROR "cannot use new\(I\) \(.*type \*I\) as type I in assignment:\n\t\*I does not implement I \(type \*I is pointer to interface, not interface\)" - _ = i.(*T2) // ERROR "impossible type assertion: i.\(\*T2\)\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\) at \w+.+\d.\d+\n\t\twant M\(int\)" - _ = i.(*T3) // ERROR "impossible type assertion: i.\(\*T3\)\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\) at \w+.+\d.\d+\n\t\twant M\(int\)" + i = new(T2) // ERROR "cannot use new\(T2\) \(.*type \*T2\) as type I in assignment:\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\)\n\t\twant M\(int\)" + + i = new(T3) // ERROR "cannot use new\(T3\) \(.*type \*T3\) as type I in assignment:\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\)\n\t\twant M\(int\)" + + i = T4{} // ERROR "cannot use T4\{\} \(.*type T4\) as type I in assignment:\n\tT4 does not implement I \(M method has pointer receiver\)" + i = new(I) // ERROR "cannot use new\(I\) \(.*type \*I\) as type I in assignment:\n\t\*I does not implement I \(type \*I is pointer to interface, not interface\)" + + _ = i.(*T2) // ERROR "impossible type assertion: i.\(\*T2\)\n\t\*T2 does not implement I \(missing M method\)\n\t\thave m\(int\)\n\t\twant M\(int\)" + _ = i.(*T3) // ERROR "impossible type assertion: i.\(\*T3\)\n\t\*T3 does not implement I \(wrong type for M method\)\n\t\thave M\(string\)\n\t\twant M\(int\)" + _ = i.(T5) // ERROR ""impossible type assertion: i.\(T5\)\n\tT5 does not implement I \(missing M method\)\n\t\thave m\(int\)\n\t\twant M\(int\)" + _ = i.(T6) // ERROR "impossible type assertion: i.\(T6\)\n\tT6 does not implement I \(missing M method\)\n\t\thave m\(int\) string\n\t\twant M\(int\)" + var t *T4 t = i // ERROR "cannot use i \(variable of type I\) as type \*T4 in assignment:\n\tneed type assertion" _ = i From 125c5a3d69c99378b17f50dc3f05e3cf3a8b9d2b Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 1 Feb 2022 08:37:05 -0800 Subject: [PATCH 741/752] doc/go1.18: document restrictions for real, imag, complex For #47694. For #50912. For #50937. Change-Id: I3fae6c8dbbd61a45e669b8fb0c18ac76f2183963 Reviewed-on: https://go-review.googlesource.com/c/go/+/381967 Trust: Robert Griesemer Run-TryBot: Robert Griesemer TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index c93c91ebbc..daf8755b28 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -97,6 +97,11 @@ Do not send CLs removing the interior tags from such phrases. The Go compiler cannot currently handle type declarations inside generic functions or methods. We hope to provide support for this feature in Go 1.19. +

  • + The Go compiler currently does not accept arguments of type parameter type with + the predeclared functions real, imag, and complex. + We hope to remove this restriction in Go 1.19. +
  • Embedding a type parameter, or a pointer to a type parameter, as an unnamed field in a struct type is not permitted. Similarly From a42bbf47d6b0d6f67ad843252cb2e8f56a9d32b7 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 1 Feb 2022 09:07:49 -0800 Subject: [PATCH 742/752] doc/go1.18: explain changes to compiler error messages For #47694. For #50954. Change-Id: I3789e145d64025fe2bf787fa5d01a21832903586 Reviewed-on: https://go-review.googlesource.com/c/go/+/381968 Trust: Robert Griesemer Reviewed-by: Ian Lance Taylor --- doc/go1.18.html | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index daf8755b28..b72c1288d1 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -443,6 +443,14 @@ Do not send CLs removing the interior tags from such phrases. new go command -asan option.

    +

    + Because the compiler's type checker was replaced in its entirety to + support generics, some error messages now may use different wording + than before. In some cases, pre-Go 1.18 error messages provided more + detail or were phrased in a more helpful way. + We intend to address these cases in Go 1.19. +

    +

    Because of changes in the compiler related to supporting generics, the Go 1.18 compile speed can be roughly 15% slower than the Go 1.17 compile speed. From e22a14b7eb1e4a172d0c20d14a0d2433fdf20e5c Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Tue, 1 Feb 2022 10:16:48 -0500 Subject: [PATCH 743/752] cmd/go: add missing newlines in TestScript '? cmp' output Change-Id: I0314c2e9073b162119060a23c5eee9a78ca08ebf Reviewed-on: https://go-review.googlesource.com/c/go/+/382239 Trust: Bryan Mills Run-TryBot: Bryan Mills TryBot-Result: Gopher Robot Reviewed-by: Ian Lance Taylor --- src/cmd/go/script_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go index 0fc4b0f7ab..165d3308a8 100644 --- a/src/cmd/go/script_test.go +++ b/src/cmd/go/script_test.go @@ -648,9 +648,9 @@ func (ts *testScript) doCmdCmp(want simpleStatus, args []string, env, quiet bool } case successOrFailure: if eq { - fmt.Fprintf(&ts.log, "%s and %s do not differ", name1, name2) + fmt.Fprintf(&ts.log, "%s and %s do not differ\n", name1, name2) } else { - fmt.Fprintf(&ts.log, "%s and %s differ", name1, name2) + fmt.Fprintf(&ts.log, "%s and %s differ\n", name1, name2) } default: ts.fatalf("unsupported: %v cmp", want) From 5522f8c8e6132fe36e4da74f6628a9d63f643d60 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Tue, 1 Feb 2022 11:25:13 -0500 Subject: [PATCH 744/752] cmd/go: fix relative-path normalization in go.work files We had been statting 'dir' instead of 'absDir', which statted the wrong directory if 'dir' was made relative to the location of the go.work file and that location was different from the current working directory. While we're here, I also noticed some other dir-vs.-absDir discrepancies. The haveDirs map had assumed relative, slash-separated filesystem paths, but absolute paths on Windows are not slash-separated and we do retain those. Moreover, if users hand-edit the go.work file they may introduce non-canonical paths. I have changed the haveDirs logic to retain absolute paths in their platform-specific forms, and to call DropUse with the original path from the go.work file instead of the newly-resolved path. Fixes #50931 Updates #48257 Change-Id: Ib0a46179aa20c99f045aac5c7c02dbb55da455c8 Reviewed-on: https://go-review.googlesource.com/c/go/+/382240 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Michael Matloob TryBot-Result: Gopher Robot --- src/cmd/go/internal/workcmd/use.go | 41 +++++++++++++-------- src/cmd/go/testdata/script/work_use_dot.txt | 33 +++++++++++++++++ 2 files changed, 59 insertions(+), 15 deletions(-) create mode 100644 src/cmd/go/testdata/script/work_use_dot.txt diff --git a/src/cmd/go/internal/workcmd/use.go b/src/cmd/go/internal/workcmd/use.go index 852e5b910c..a5ba6c7133 100644 --- a/src/cmd/go/internal/workcmd/use.go +++ b/src/cmd/go/internal/workcmd/use.go @@ -43,8 +43,6 @@ func init() { } func runUse(ctx context.Context, cmd *base.Command, args []string) { - modload.InitWorkfile() - modload.ForceUseModules = true var gowork string @@ -56,29 +54,42 @@ func runUse(ctx context.Context, cmd *base.Command, args []string) { base.Fatalf("go: %v", err) } - haveDirs := make(map[string]bool) - for _, dir := range workFile.Use { - haveDirs[filepath.Join(filepath.Dir(gowork), filepath.FromSlash(dir.Path))] = true + haveDirs := make(map[string][]string) // absolute → original(s) + for _, use := range workFile.Use { + var absDir string + if filepath.IsAbs(use.Path) { + absDir = filepath.Clean(use.Path) + } else { + absDir = filepath.Join(filepath.Dir(gowork), use.Path) + } + haveDirs[absDir] = append(haveDirs[absDir], use.Path) } addDirs := make(map[string]bool) removeDirs := make(map[string]bool) lookDir := func(dir string) { - absDir := filepath.Join(base.Cwd(), dir) - // If the path is absolute, keep it absolute. If it's relative, + // If the path is absolute, try to keep it absolute. If it's relative, // make it relative to the go.work file rather than the working directory. + absDir := dir if !filepath.IsAbs(dir) { + absDir = filepath.Join(base.Cwd(), dir) rel, err := filepath.Rel(filepath.Dir(gowork), absDir) if err == nil { - dir = rel + // Normalize relative paths to use slashes, so that checked-in go.work + // files with relative paths within the repo are platform-independent. + dir = filepath.ToSlash(rel) + } else { + // The path can't be made relative to the go.work file, + // so it must be kept absolute instead. + dir = absDir } } - fi, err := os.Stat(filepath.Join(dir, "go.mod")) + + fi, err := os.Stat(filepath.Join(absDir, "go.mod")) if err != nil { if os.IsNotExist(err) { - - if haveDirs[absDir] { - removeDirs[dir] = true + for _, origDir := range haveDirs[absDir] { + removeDirs[origDir] = true } return } @@ -89,7 +100,7 @@ func runUse(ctx context.Context, cmd *base.Command, args []string) { base.Errorf("go: %v is not regular", filepath.Join(dir, "go.mod")) } - if !haveDirs[absDir] { + if len(haveDirs[absDir]) == 0 { addDirs[dir] = true } } @@ -109,10 +120,10 @@ func runUse(ctx context.Context, cmd *base.Command, args []string) { } for dir := range removeDirs { - workFile.DropUse(filepath.ToSlash(dir)) + workFile.DropUse(dir) } for dir := range addDirs { - workFile.AddUse(filepath.ToSlash(dir), "") + workFile.AddUse(dir, "") } modload.UpdateWorkFile(workFile) modload.WriteWorkFile(gowork, workFile) diff --git a/src/cmd/go/testdata/script/work_use_dot.txt b/src/cmd/go/testdata/script/work_use_dot.txt new file mode 100644 index 0000000000..c24aae33e8 --- /dev/null +++ b/src/cmd/go/testdata/script/work_use_dot.txt @@ -0,0 +1,33 @@ +cp go.work go.work.orig + +# 'go work use .' should add an entry for the current directory. +cd bar/baz +go work use . +cmp ../../go.work ../../go.work.rel + +# If the current directory lacks a go.mod file, 'go work use .' +# should remove its entry. +mv go.mod go.mod.bak +go work use . +cmp ../../go.work ../../go.work.orig + +mv go.mod.bak go.mod +go work use $PWD +cmpenv ../../go.work ../../go.work.abs + +-- go.mod -- +module example +go 1.18 +-- go.work -- +go 1.18 +-- go.work.rel -- +go 1.18 + +use bar/baz +-- go.work.abs -- +go 1.18 + +use $PWD +-- bar/baz/go.mod -- +module example/bar/baz +go 1.18 From a6a7c7a1fd6a2450cfec11e54217e04dce843a54 Mon Sep 17 00:00:00 2001 From: "Bryan C. Mills" Date: Fri, 28 Jan 2022 16:18:22 -0500 Subject: [PATCH 745/752] cmd/go: add detail to test failures For #50892 Change-Id: I14ff1c43b39687a0ba5e668ee962cecfb49e4beb Reviewed-on: https://go-review.googlesource.com/c/go/+/381836 Trust: Bryan Mills Run-TryBot: Bryan Mills Reviewed-by: Dmitri Shuralyov Reviewed-by: Michael Matloob TryBot-Result: Gopher Robot --- src/cmd/go/go_test.go | 2 +- src/cmd/go/script_test.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go index 7aaec4eb98..1ea347ca6e 100644 --- a/src/cmd/go/go_test.go +++ b/src/cmd/go/go_test.go @@ -133,7 +133,7 @@ func TestMain(m *testing.M) { } gotool, err := testenv.GoTool() if err != nil { - fmt.Fprintln(os.Stderr, err) + fmt.Fprintln(os.Stderr, "locating go tool: ", err) os.Exit(2) } diff --git a/src/cmd/go/script_test.go b/src/cmd/go/script_test.go index 165d3308a8..722921f74c 100644 --- a/src/cmd/go/script_test.go +++ b/src/cmd/go/script_test.go @@ -902,7 +902,7 @@ func (ts *testScript) cmdStale(want simpleStatus, args []string) { tmpl := "{{if .Error}}{{.ImportPath}}: {{.Error.Err}}{{else}}" switch want { case failure: - tmpl += "{{if .Stale}}{{.ImportPath}} is unexpectedly stale{{end}}" + tmpl += "{{if .Stale}}{{.ImportPath}} is unexpectedly stale: {{.StaleReason}}{{end}}" case success: tmpl += "{{if not .Stale}}{{.ImportPath}} is unexpectedly NOT stale{{end}}" default: From 36b81acfa19d9fedf6a0cd60c394fd7a7703834e Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Fri, 28 Jan 2022 15:48:32 -0800 Subject: [PATCH 746/752] cmd/go: document that GOENV=off disables the default config file MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fixes #46840 Change-Id: Icc5475e312003e316dc039413a35089485163ba6 Reviewed-on: https://go-review.googlesource.com/c/go/+/381894 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor Trust: Daniel Martí Reviewed-by: Daniel Martí Reviewed-by: Bryan Mills TryBot-Result: Gopher Robot --- src/cmd/go/alldocs.go | 2 ++ src/cmd/go/internal/help/helpdoc.go | 2 ++ 2 files changed, 4 insertions(+) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index 8e13a0f653..13a3f00d6f 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -2036,6 +2036,8 @@ // GOENV // The location of the Go environment configuration file. // Cannot be set using 'go env -w'. +// Setting GOENV=off in the environment disables the use of the +// default configuration file. // GOFLAGS // A space-separated list of -flag=value settings to apply // to go commands by default, when the given flag is known by diff --git a/src/cmd/go/internal/help/helpdoc.go b/src/cmd/go/internal/help/helpdoc.go index 7dc066cfba..d1eaad1c12 100644 --- a/src/cmd/go/internal/help/helpdoc.go +++ b/src/cmd/go/internal/help/helpdoc.go @@ -506,6 +506,8 @@ General-purpose environment variables: GOENV The location of the Go environment configuration file. Cannot be set using 'go env -w'. + Setting GOENV=off in the environment disables the use of the + default configuration file. GOFLAGS A space-separated list of -flag=value settings to apply to go commands by default, when the given flag is known by From 9784ef8ab139491773684386c1cefa0b75fdb89e Mon Sep 17 00:00:00 2001 From: Katie Hockman Date: Tue, 1 Feb 2022 12:30:36 -0500 Subject: [PATCH 747/752] internal/fuzz: small cleanups Change-Id: I9fc12f352d57db776d176990277e104f64f9908d Reviewed-on: https://go-review.googlesource.com/c/go/+/382238 Reviewed-by: Julie Qiu Reviewed-by: Roland Shoemaker Trust: Katie Hockman Run-TryBot: Katie Hockman TryBot-Result: Gopher Robot --- src/internal/fuzz/fuzz.go | 10 +++++----- src/internal/fuzz/worker.go | 4 ++-- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/internal/fuzz/fuzz.go b/src/internal/fuzz/fuzz.go index f2ff3a1390..0014cde04f 100644 --- a/src/internal/fuzz/fuzz.go +++ b/src/internal/fuzz/fuzz.go @@ -419,14 +419,14 @@ type corpus struct { hashes map[[sha256.Size]byte]bool } -// addCorpusEntries adds entries to the corpus, and optional also writes the entries +// addCorpusEntries adds entries to the corpus, and optionally writes the entries // to the cache directory. If an entry is already in the corpus it is skipped. If // all of the entries are unique, addCorpusEntries returns true and a nil error, // if at least one of the entries was a duplicate, it returns false and a nil error. func (c *coordinator) addCorpusEntries(addToCache bool, entries ...CorpusEntry) (bool, error) { noDupes := true for _, e := range entries { - data, err := CorpusEntryData(e) + data, err := corpusEntryData(e) if err != nil { return false, err } @@ -478,9 +478,9 @@ type CorpusEntry = struct { IsSeed bool } -// Data returns the raw input bytes, either from the data struct field, -// or from disk. -func CorpusEntryData(ce CorpusEntry) ([]byte, error) { +// corpusEntryData returns the raw input bytes, either from the data struct +// field, or from disk. +func corpusEntryData(ce CorpusEntry) ([]byte, error) { if ce.Data != nil { return ce.Data, nil } diff --git a/src/internal/fuzz/worker.go b/src/internal/fuzz/worker.go index c2d553240c..e984ba73b2 100644 --- a/src/internal/fuzz/worker.go +++ b/src/internal/fuzz/worker.go @@ -973,7 +973,7 @@ func (wc *workerClient) minimize(ctx context.Context, entryIn CorpusEntry, args return CorpusEntry{}, minimizeResponse{}, errSharedMemClosed } mem.header().count = 0 - inp, err := CorpusEntryData(entryIn) + inp, err := corpusEntryData(entryIn) if err != nil { return CorpusEntry{}, minimizeResponse{}, err } @@ -1059,7 +1059,7 @@ func (wc *workerClient) fuzz(ctx context.Context, entryIn CorpusEntry, args fuzz return CorpusEntry{}, fuzzResponse{}, true, errSharedMemClosed } mem.header().count = 0 - inp, err := CorpusEntryData(entryIn) + inp, err := corpusEntryData(entryIn) if err != nil { return CorpusEntry{}, fuzzResponse{}, true, err } From edbe4742a296239c06cd99721bb0dbc5008d35a1 Mon Sep 17 00:00:00 2001 From: pierwill Date: Wed, 2 Feb 2022 18:21:04 +0000 Subject: [PATCH 748/752] cmd/compile: edit README Make some small edits for clarification of important concepts. Change-Id: I1f78f2a59489ac71e3948dc924641540508613ce GitHub-Last-Rev: 1819140ee607edf8be3ed35f846848178065391a GitHub-Pull-Request: golang/go#50980 Reviewed-on: https://go-review.googlesource.com/c/go/+/382458 Reviewed-by: Robert Griesemer Reviewed-by: Matthew Dempsky --- src/cmd/compile/README.md | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/src/cmd/compile/README.md b/src/cmd/compile/README.md index babc3f7679..25fa8187bb 100644 --- a/src/cmd/compile/README.md +++ b/src/cmd/compile/README.md @@ -40,12 +40,12 @@ which is used for error reporting and the creation of debugging information. * `cmd/compile/internal/gc` (create compiler AST, type checking, AST transformations) -The gc package includes an AST definition carried over from when it was written -in C. All of its code is written in terms of it, so the first thing that the gc +The gc package includes its own AST definition carried over from when it was written +in C. All of its code is written in terms of this AST, so the first thing that the gc package must do is convert the syntax package's syntax tree to the compiler's AST representation. This extra step may be refactored away in the future. -The AST is then type-checked. The first steps are name resolution and type +The gc AST is then type-checked. The first steps are name resolution and type inference, which determine which object belongs to which identifier, and what type each expression has. Type-checking includes certain extra checks, such as "declared and not used" as well as determining whether or not a function @@ -79,8 +79,7 @@ historical reasons, but the long-term plan is to move all of them here. Then, a series of machine-independent passes and rules are applied. These do not concern any single computer architecture, and thus run on all `GOARCH` variants. - -Some examples of these generic passes include dead code elimination, removal of +These passes include dead code elimination, removal of unneeded nil checks, and removal of unused branches. The generic rewrite rules mainly concern expressions, such as replacing some expressions with constant values, and optimizing multiplications and float operations. From 77eff30ec0bc63df61ea742bb8278f92e2c133dc Mon Sep 17 00:00:00 2001 From: Robert Findley Date: Wed, 2 Feb 2022 13:47:31 -0500 Subject: [PATCH 749/752] go/types, types2: add a const to control recursion panics in unification Add a panicAtUnificationDepthLimit const to replace the use of the debug const to control whether to panic when the unification recursion depth is reached. Our tests should pass when debug==true. Change-Id: I58847f49d66010bd4ca01c0408ec10acac95cba6 Reviewed-on: https://go-review.googlesource.com/c/go/+/382534 Trust: Robert Findley Run-TryBot: Robert Findley Reviewed-by: Robert Griesemer TryBot-Result: Gopher Robot --- src/cmd/compile/internal/types2/unify.go | 14 ++++++++++---- src/go/types/unify.go | 14 ++++++++++---- 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/src/cmd/compile/internal/types2/unify.go b/src/cmd/compile/internal/types2/unify.go index 13d5af671e..079db3276c 100644 --- a/src/cmd/compile/internal/types2/unify.go +++ b/src/cmd/compile/internal/types2/unify.go @@ -33,9 +33,15 @@ import ( // by setting up one of them (using init) and then assigning its value // to the other. -// Upper limit for recursion depth. Used to catch infinite recursions -// due to implementation issues (e.g., see issues #48619, #48656). -const unificationDepthLimit = 50 +const ( + // Upper limit for recursion depth. Used to catch infinite recursions + // due to implementation issues (e.g., see issues #48619, #48656). + unificationDepthLimit = 50 + + // Whether to panic when unificationDepthLimit is reached. Turn on when + // investigating infinite recursion. + panicAtUnificationDepthLimit = false +) // A unifier maintains the current type parameters for x and y // and the respective types inferred for each type parameter. @@ -244,7 +250,7 @@ func (u *unifier) nifyEq(x, y Type, p *ifacePair) bool { func (u *unifier) nify(x, y Type, p *ifacePair) bool { // Stop gap for cases where unification fails. if u.depth >= unificationDepthLimit { - if debug { + if panicAtUnificationDepthLimit { panic("unification reached recursion depth limit") } return false diff --git a/src/go/types/unify.go b/src/go/types/unify.go index 5d6d78bff0..be2037ca81 100644 --- a/src/go/types/unify.go +++ b/src/go/types/unify.go @@ -33,9 +33,15 @@ import ( // by setting up one of them (using init) and then assigning its value // to the other. -// Upper limit for recursion depth. Used to catch infinite recursions -// due to implementation issues (e.g., see issues #48619, #48656). -const unificationDepthLimit = 50 +const ( + // Upper limit for recursion depth. Used to catch infinite recursions + // due to implementation issues (e.g., see issues #48619, #48656). + unificationDepthLimit = 50 + + // Whether to panic when unificationDepthLimit is reached. Turn on when + // investigating infinite recursion. + panicAtUnificationDepthLimit = false +) // A unifier maintains the current type parameters for x and y // and the respective types inferred for each type parameter. @@ -244,7 +250,7 @@ func (u *unifier) nifyEq(x, y Type, p *ifacePair) bool { func (u *unifier) nify(x, y Type, p *ifacePair) bool { // Stop gap for cases where unification fails. if u.depth >= unificationDepthLimit { - if debug { + if panicAtUnificationDepthLimit { panic("unification reached recursion depth limit") } return false From 53d6a725f85b9b688a02bbf40cd8961c78bf0b91 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 1 Feb 2022 19:32:08 -0800 Subject: [PATCH 750/752] runtime: update _defer comment to not mention freedefer CL 339669 changed freedefer to not mention every field of _defer, so no need to call it out in the _defer comment. Change-Id: Id8b67ba2298685f609bf901b5948fd30666bd6e3 Reviewed-on: https://go-review.googlesource.com/c/go/+/382251 Trust: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gopher Robot Reviewed-by: Austin Clements --- src/runtime/runtime2.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go index d0b7a162d5..3eada37840 100644 --- a/src/runtime/runtime2.go +++ b/src/runtime/runtime2.go @@ -941,7 +941,7 @@ func extendRandom(r []byte, n int) { } // A _defer holds an entry on the list of deferred calls. -// If you add a field here, add code to clear it in freedefer and deferProcStack +// If you add a field here, add code to clear it in deferProcStack. // This struct must match the code in cmd/compile/internal/ssagen/ssa.go:deferstruct // and cmd/compile/internal/ssagen/ssa.go:(*state).call. // Some defers will be allocated on the stack and some on the heap. From a9384eef7ae3a2587d215e3ec3d79bc1b335ce82 Mon Sep 17 00:00:00 2001 From: Filippo Valsorda Date: Tue, 1 Feb 2022 21:24:51 +0100 Subject: [PATCH 751/752] doc/go1.18: add crypto/tls, crypto/x509, and crypto/elliptic release notes Updates #45428 Updates #41682 Change-Id: I811bc4f8ec8de6b6db6a2917e265a72134a05e78 Reviewed-on: https://go-review.googlesource.com/c/go/+/382454 Trust: Filippo Valsorda Trust: Katie Hockman Reviewed-by: Katie Hockman --- doc/go1.18.html | 62 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) diff --git a/doc/go1.18.html b/doc/go1.18.html index b72c1288d1..e69113411e 100644 --- a/doc/go1.18.html +++ b/doc/go1.18.html @@ -546,6 +546,39 @@ Do not send CLs removing the interior tags from such phrases. UDPAddr.AddrPort.

    +

    TLS 1.0 and 1.1 disabled by default client-side

    + +

    + If Config.MinVersion + is not set, it now defaults to TLS 1.2 for client connections. Any safely + up-to-date server is expected to support TLS 1.2, and browsers have required + it since 2020. TLS 1.0 and 1.1 are still supported by setting + Config.MinVersion to VersionTLS10. + The server-side default is unchanged at TLS 1.0. +

    + +

    + The default can be temporarily reverted to TLS 1.0 by setting the + GODEBUG=tls10default=1 environment variable. + This option will be removed in Go 1.19. +

    + +

    Rejecting SHA-1 certificates

    + +

    + crypto/x509 will now + reject certificates signed with the SHA-1 hash function. This doesn't + apply to self-signed root certificates. Practical attacks against SHA-1 + have been demonstrated since 2017 and publicly + trusted Certificate Authorities have not issued SHA-1 certificates since 2015. +

    + +

    + This can be temporarily reverted by setting the + GODEBUG=x509sha1=1 environment variable. + This option will be removed in Go 1.19. +

    +

    Minor changes to the library

    @@ -598,6 +631,35 @@ Do not send CLs removing the interior tags from such phrases.

    • +
    crypto/elliptic
    +
    +

    + The P224, + P384, and + P521 curve + implementations are now all backed by code generated by the + addchain and + fiat-crypto + projects, the latter of which is based on a formally-verified model + of the arithmetic operations. They now use safer complete formulas + and internal APIs. P-224 and P-384 are now approximately four times + faster. All specific curve implementations are now constant-time. +

    + +

    + Operating on invalid curve points (those for which the + IsOnCurve method returns false, and which are never returned + by Unmarshal or + a Curve method operating on a valid point) has always been + undefined behavior, can lead to key recovery attacks, and is now + unsupported by the new backend. If an invalid point is supplied to a + P224, P384, or P521 method, that + method will now return a random point. The behavior might change to an + explicit panic in a future release. +

    +
    +
    +
    crypto/tls

    From 8384fe86a5b7f579a50c7ad423d4dd4eb2d1f117 Mon Sep 17 00:00:00 2001 From: Filippo Valsorda Date: Sat, 30 Oct 2021 00:27:51 -0400 Subject: [PATCH 752/752] crypto/ecdsa,crypto/elliptic: update docs and spec references crypto/ecdsa was long overdue a cleanup. Bump the FIPS 186 version, and make sure we consistently reference that and SEC 1, not the paywalled ANSI standard. Change-Id: Idd90bd6c14b334941fdcd829d89b796a60a8b174 Reviewed-on: https://go-review.googlesource.com/c/go/+/352529 Run-TryBot: Filippo Valsorda Trust: Filippo Valsorda TryBot-Result: Gopher Robot Reviewed-by: Roland Shoemaker --- src/crypto/ecdsa/ecdsa.go | 95 +++++++++++++++++---------------- src/crypto/elliptic/elliptic.go | 40 +++++++------- src/crypto/elliptic/p256.go | 8 +-- 3 files changed, 75 insertions(+), 68 deletions(-) diff --git a/src/crypto/ecdsa/ecdsa.go b/src/crypto/ecdsa/ecdsa.go index 282596d2d2..9f9a09a884 100644 --- a/src/crypto/ecdsa/ecdsa.go +++ b/src/crypto/ecdsa/ecdsa.go @@ -3,28 +3,21 @@ // license that can be found in the LICENSE file. // Package ecdsa implements the Elliptic Curve Digital Signature Algorithm, as -// defined in FIPS 186-3. +// defined in FIPS 186-4 and SEC 1, Version 2.0. // -// This implementation derives the nonce from an AES-CTR CSPRNG keyed by: -// -// SHA2-512(priv.D || entropy || hash)[:32] -// -// The CSPRNG key is indifferentiable from a random oracle as shown in -// [Coron], the AES-CTR stream is indifferentiable from a random oracle -// under standard cryptographic assumptions (see [Larsson] for examples). -// -// References: -// [Coron] -// https://cs.nyu.edu/~dodis/ps/merkle.pdf -// [Larsson] -// https://web.archive.org/web/20040719170906/https://www.nada.kth.se/kurser/kth/2D1441/semteo03/lecturenotes/assump.pdf +// Signatures generated by this package are not deterministic, but entropy is +// mixed with the private key and the message, achieving the same level of +// security in case of randomness source failure. package ecdsa -// Further references: -// [NSA]: Suite B implementer's guide to FIPS 186-3 -// https://apps.nsa.gov/iaarchive/library/ia-guidance/ia-solutions-for-classified/algorithm-guidance/suite-b-implementers-guide-to-fips-186-3-ecdsa.cfm -// [SECG]: SECG, SEC1 -// http://www.secg.org/sec1-v2.pdf +// [FIPS 186-4] references ANSI X9.62-2005 for the bulk of the ECDSA algorithm. +// That standard is not freely available, which is a problem in an open source +// implementation, because not only the implementer, but also any maintainer, +// contributor, reviewer, auditor, and learner needs access to it. Instead, this +// package references and follows the equivalent [SEC 1, Version 2.0]. +// +// [FIPS 186-4]: https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf +// [SEC 1, Version 2.0]: https://www.secg.org/sec1-v2.pdf import ( "crypto" @@ -41,15 +34,16 @@ import ( "golang.org/x/crypto/cryptobyte/asn1" ) -// A invertible implements fast inverse mod Curve.Params().N +// A invertible implements fast inverse in GF(N). type invertible interface { - // Inverse returns the inverse of k in GF(P) + // Inverse returns the inverse of k mod Params().N. Inverse(k *big.Int) *big.Int } -// combinedMult implements fast multiplication S1*g + S2*p (g - generator, p - arbitrary point) +// A combinedMult implements fast combined multiplication for verification. type combinedMult interface { - CombinedMult(bigX, bigY *big.Int, baseScalar, scalar []byte) (x, y *big.Int) + // CombinedMult returns [s1]G + [s2]P where G is the generator. + CombinedMult(Px, Py *big.Int, s1, s2 []byte) (x, y *big.Int) } const ( @@ -111,7 +105,7 @@ func (priv *PrivateKey) Equal(x crypto.PrivateKey) bool { // // This method implements crypto.Signer, which is an interface to support keys // where the private part is kept in, for example, a hardware module. Common -// uses should use the Sign function in this package directly. +// uses can use the SignASN1 function in this package directly. func (priv *PrivateKey) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error) { r, s, err := Sign(rand, priv, digest) if err != nil { @@ -128,11 +122,13 @@ func (priv *PrivateKey) Sign(rand io.Reader, digest []byte, opts crypto.SignerOp var one = new(big.Int).SetInt64(1) -// randFieldElement returns a random element of the field underlying the given -// curve using the procedure given in [NSA] A.2.1. +// randFieldElement returns a random element of the order of the given +// curve using the procedure given in FIPS 186-4, Appendix B.5.1. func randFieldElement(c elliptic.Curve, rand io.Reader) (k *big.Int, err error) { params := c.Params() - b := make([]byte, params.BitSize/8+8) + // Note that for P-521 this will actually be 63 bits more than the order, as + // division rounds down, but the extra bit is inconsequential. + b := make([]byte, params.BitSize/8+8) // TODO: use params.N.BitLen() _, err = io.ReadFull(rand, b) if err != nil { return @@ -159,12 +155,9 @@ func GenerateKey(c elliptic.Curve, rand io.Reader) (*PrivateKey, error) { return priv, nil } -// hashToInt converts a hash value to an integer. There is some disagreement -// about how this is done. [NSA] suggests that this is done in the obvious -// manner, but [SECG] truncates the hash to the bit-length of the curve order -// first. We follow [SECG] because that's what OpenSSL does. Additionally, -// OpenSSL right shifts excess bits from the number if the hash is too large -// and we mirror that too. +// hashToInt converts a hash value to an integer. Per FIPS 186-4, Section 6.4, +// we use the left-most bits of the hash to match the bit-length of the order of +// the curve. This also performs Step 5 of SEC 1, Version 2.0, Section 4.1.3. func hashToInt(hash []byte, c elliptic.Curve) *big.Int { orderBits := c.Params().N.BitLen() orderBytes := (orderBits + 7) / 8 @@ -180,10 +173,11 @@ func hashToInt(hash []byte, c elliptic.Curve) *big.Int { return ret } -// fermatInverse calculates the inverse of k in GF(P) using Fermat's method. -// This has better constant-time properties than Euclid's method (implemented -// in math/big.Int.ModInverse) although math/big itself isn't strictly -// constant-time so it's not perfect. +// fermatInverse calculates the inverse of k in GF(P) using Fermat's method +// (exponentiation modulo P - 2, per Euler's theorem). This has better +// constant-time properties than Euclid's method (implemented in +// math/big.Int.ModInverse and FIPS 186-4, Appendix C.1) although math/big +// itself isn't strictly constant-time so it's not perfect. func fermatInverse(k, N *big.Int) *big.Int { two := big.NewInt(2) nMinus2 := new(big.Int).Sub(N, two) @@ -195,11 +189,22 @@ var errZeroParam = errors.New("zero parameter") // Sign signs a hash (which should be the result of hashing a larger message) // using the private key, priv. If the hash is longer than the bit-length of the // private key's curve order, the hash will be truncated to that length. It -// returns the signature as a pair of integers. The security of the private key -// depends on the entropy of rand. +// returns the signature as a pair of integers. Most applications should use +// SignASN1 instead of dealing directly with r, s. func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error) { randutil.MaybeReadByte(rand) + // This implementation derives the nonce from an AES-CTR CSPRNG keyed by: + // + // SHA2-512(priv.D || entropy || hash)[:32] + // + // The CSPRNG key is indifferentiable from a random oracle as shown in + // [Coron], the AES-CTR stream is indifferentiable from a random oracle + // under standard cryptographic assumptions (see [Larsson] for examples). + // + // [Coron]: https://cs.nyu.edu/~dodis/ps/merkle.pdf + // [Larsson]: https://web.archive.org/web/20040719170906/https://www.nada.kth.se/kurser/kth/2D1441/semteo03/lecturenotes/assump.pdf + // Get 256 bits of entropy from rand. entropy := make([]byte, 32) _, err = io.ReadFull(rand, entropy) @@ -207,7 +212,7 @@ func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err err return } - // Initialize an SHA-512 hash context; digest ... + // Initialize an SHA-512 hash context; digest... md := sha512.New() md.Write(priv.D.Bytes()) // the private key, md.Write(entropy) // the entropy, @@ -228,12 +233,12 @@ func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err err S: cipher.NewCTR(block, []byte(aesIV)), } - // See [NSA] 3.4.1 c := priv.PublicKey.Curve return sign(priv, &csprng, c, hash) } func signGeneric(priv *PrivateKey, csprng *cipher.StreamReader, c elliptic.Curve, hash []byte) (r, s *big.Int, err error) { + // SEC 1, Version 2.0, Section 4.1.3 N := c.Params().N if N.Sign() == 0 { return nil, nil, errZeroParam @@ -276,16 +281,15 @@ func signGeneric(priv *PrivateKey, csprng *cipher.StreamReader, c elliptic.Curve // SignASN1 signs a hash (which should be the result of hashing a larger message) // using the private key, priv. If the hash is longer than the bit-length of the // private key's curve order, the hash will be truncated to that length. It -// returns the ASN.1 encoded signature. The security of the private key -// depends on the entropy of rand. +// returns the ASN.1 encoded signature. func SignASN1(rand io.Reader, priv *PrivateKey, hash []byte) ([]byte, error) { return priv.Sign(rand, hash, nil) } // Verify verifies the signature in r, s of hash using the public key, pub. Its -// return value records whether the signature is valid. +// return value records whether the signature is valid. Most applications should +// use VerifyASN1 instead of dealing directly with r, s. func Verify(pub *PublicKey, hash []byte, r, s *big.Int) bool { - // See [NSA] 3.4.2 c := pub.Curve N := c.Params().N @@ -299,6 +303,7 @@ func Verify(pub *PublicKey, hash []byte, r, s *big.Int) bool { } func verifyGeneric(pub *PublicKey, c elliptic.Curve, hash []byte, r, s *big.Int) bool { + // SEC 1, Version 2.0, Section 4.1.4 e := hashToInt(hash, c) var w *big.Int N := c.Params().N diff --git a/src/crypto/elliptic/elliptic.go b/src/crypto/elliptic/elliptic.go index d06a284154..c5c5a906c4 100644 --- a/src/crypto/elliptic/elliptic.go +++ b/src/crypto/elliptic/elliptic.go @@ -2,17 +2,10 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// Package elliptic implements several standard elliptic curves over prime -// fields. +// Package elliptic implements the standard NIST P-224, P-256, P-384, and P-521 +// elliptic curves over prime fields. package elliptic -// This package operates, internally, on Jacobian coordinates. For a given -// (x, y) position on the curve, the Jacobian coordinates are (x1, y1, z1) -// where x = x1/z1² and y = y1/z1³. The greatest speedups come when the whole -// calculation can be performed within the transform (as in ScalarMult and -// ScalarBaseMult). But even for Add and Double, it's faster to apply and -// reverse the transform than to operate in affine coordinates. - import ( "io" "math/big" @@ -21,12 +14,12 @@ import ( // A Curve represents a short-form Weierstrass curve with a=-3. // -// The output of Add, Double, and ScalarMult when the input is not a point on +// The behavior of Add, Double, and ScalarMult when the input is not a point on // the curve is undefined. // // Note that the conventional point at infinity (0, 0) is not considered on the // curve, although it can be returned by Add, Double, ScalarMult, or -// ScalarBaseMult (but not Unmarshal or UnmarshalCompressed). +// ScalarBaseMult (but not the Unmarshal or UnmarshalCompressed functions). type Curve interface { // Params returns the parameters for the curve. Params() *CurveParams @@ -67,6 +60,13 @@ func (curve *CurveParams) Params() *CurveParams { return curve } +// CurveParams operates, internally, on Jacobian coordinates. For a given +// (x, y) position on the curve, the Jacobian coordinates are (x1, y1, z1) +// where x = x1/z1² and y = y1/z1³. The greatest speedups come when the whole +// calculation can be performed within the transform (as in ScalarMult and +// ScalarBaseMult). But even for Add and Double, it's faster to apply and +// reverse the transform than to operate in affine coordinates. + // polynomial returns x³ - 3x + b. func (curve *CurveParams) polynomial(x *big.Int) *big.Int { x3 := new(big.Int).Mul(x, x) @@ -353,7 +353,8 @@ func GenerateKey(curve Curve, rand io.Reader) (priv []byte, x, y *big.Int, err e } // Marshal converts a point on the curve into the uncompressed form specified in -// section 4.3.6 of ANSI X9.62. +// SEC 1, Version 2.0, Section 2.3.3. If the point is not on the curve (or is +// the conventional point at infinity), the behavior is undefined. func Marshal(curve Curve, x, y *big.Int) []byte { byteLen := (curve.Params().BitSize + 7) / 8 @@ -367,7 +368,8 @@ func Marshal(curve Curve, x, y *big.Int) []byte { } // MarshalCompressed converts a point on the curve into the compressed form -// specified in section 4.3.6 of ANSI X9.62. +// specified in SEC 1, Version 2.0, Section 2.3.3. If the point is not on the +// curve (or is the conventional point at infinity), the behavior is undefined. func MarshalCompressed(curve Curve, x, y *big.Int) []byte { byteLen := (curve.Params().BitSize + 7) / 8 compressed := make([]byte, 1+byteLen) @@ -376,9 +378,9 @@ func MarshalCompressed(curve Curve, x, y *big.Int) []byte { return compressed } -// Unmarshal converts a point, serialized by Marshal, into an x, y pair. -// It is an error if the point is not in uncompressed form or is not on the curve. -// On error, x = nil. +// Unmarshal converts a point, serialized by Marshal, into an x, y pair. It is +// an error if the point is not in uncompressed form, is not on the curve, or is +// the point at infinity. On error, x = nil. func Unmarshal(curve Curve, data []byte) (x, y *big.Int) { byteLen := (curve.Params().BitSize + 7) / 8 if len(data) != 1+2*byteLen { @@ -399,9 +401,9 @@ func Unmarshal(curve Curve, data []byte) (x, y *big.Int) { return } -// UnmarshalCompressed converts a point, serialized by MarshalCompressed, into an x, y pair. -// It is an error if the point is not in compressed form or is not on the curve. -// On error, x = nil. +// UnmarshalCompressed converts a point, serialized by MarshalCompressed, into +// an x, y pair. It is an error if the point is not in compressed form, is not +// on the curve, or is the point at infinity. On error, x = nil. func UnmarshalCompressed(curve Curve, data []byte) (x, y *big.Int) { byteLen := (curve.Params().BitSize + 7) / 8 if len(data) != 1+byteLen { diff --git a/src/crypto/elliptic/p256.go b/src/crypto/elliptic/p256.go index 7ff7e33548..e1c6ff4f87 100644 --- a/src/crypto/elliptic/p256.go +++ b/src/crypto/elliptic/p256.go @@ -6,11 +6,11 @@ package elliptic -// This file contains a constant-time, 32-bit implementation of P256. +// P-256 is implemented by various different backends, including a generic +// 32-bit constant-time one in this file, which is used when assembly +// implementations are not available, or not appropriate for the hardware. -import ( - "math/big" -) +import "math/big" type p256Curve struct { *CurveParams